Game.hpp

Go to the documentation of this file.

// Copyright (c) 2020-2026 Chris Ohk
 
// I am making my contributions/submissions to this project solely in our
// personal capacity and am not conveying any rights to any intellectual
// property of any third parties.
 
#ifndef BABA_IS_AUTO_GAME_HPP
#define BABA_IS_AUTO_GAME_HPP
 
#include <baba-is-auto/Enums/RuleEnums.hpp>
#include <baba-is-auto/Games/Map.hpp>
#include <baba-is-auto/Rules/RuleManager.hpp>
 
#include <cstdint>
#include <random>
#include <string_view>
#include <vector>
 
namespace baba_is_auto
{
class Game
{
 public:
    explicit Game(std::string_view filename);
 
    void Reset();
 
    void SetRandomSeed(std::uint32_t seed);
 
    Map& GetMap();
 
    const Map& GetMap() const;
 
    RuleManager& GetRuleManager();
 
    PlayState GetPlayState() const;
 
    ObjectType GetPlayerIcon() const;
 
    void MovePlayer(Direction dir);
 
 private:
    void ParseRules();
 
    void ParseRule(std::size_t x, std::size_t y, RuleDirection direction);
 
    bool CanMove(std::size_t x, std::size_t y, Direction dir,
                 const std::vector<ObjectID>& movingIDs = {});
 
    void ProcessPlayerMove(Direction dir);
 
    std::vector<ObjectID> GetPlayerIDsAt(const Position& position) const;
 
    void ProcessPlayerStack(const Position& position,
                            const std::vector<ObjectID>& playerIDs,
                            Direction dir);
 
    void ProcessMoveProperty();
 
    struct MoveState
    {
        ObjectID id = 0;
 
        Position position{};
 
        Direction direction = Direction::NONE;
 
        std::size_t attempts = 0;
 
        bool turned = false;
 
        bool active = true;
    };
 
    void AddMoveRuleAttempts(const Rule& rule, std::vector<MoveState>& moving,
                             std::size_t& rounds);
 
    void AppendMatchingMoveObjects(const Rule& rule,
                                   const std::vector<ObjectType>& subjects,
                                   const Position& position,
                                   std::vector<ObjectID>& matching) const;
 
    void RegisterEmptyMoveAttemptAt(const Rule& rule, const Position& position,
                                    std::vector<MoveState>& moving,
                                    std::size_t& rounds);
 
    static void RegisterMoveAttempt(std::vector<MoveState>& moving, ObjectID id,
                                    const Position& position,
                                    Direction direction, std::size_t& rounds);
 
    void ProcessMoveRound(std::vector<MoveState>& moving, std::size_t round);
 
    void ProcessEmptyMoveState(std::vector<MoveState>& moving,
                               std::size_t index);
 
    static void MergeEmptyMoveStates(std::vector<MoveState>& moving,
                                     std::size_t index);
 
    void ProcessObjectMoveState(MoveState& state);
 
    void ProcessDirectionProperties();
 
    void ApplyDirectionProperties(ObjectInstance& instance,
                                  const Position& position,
                                  const std::vector<Rule>& rules) const;
 
    ObjectInstance EmptyAt(const Position& position) const;
 
    void ProcessTransformations();
 
    struct Transformation
    {
        ObjectType subject;
 
        ObjectType predicate;
 
        std::vector<RuleCondition> conditions;
    };
 
    struct TransformationResult
    {
        bool matched = false;
 
        bool transforms = false;
 
        bool expandsAll = false;
 
        bool protectedByIdentity = false;
 
        std::vector<ObjectType> targets;
 
        std::vector<ObjectType> allTargets;
    };
 
    struct LocatedInstance
    {
        ObjectInstance instance;
 
        Position position;
    };
 
    struct EmptyTransformation
    {
        Position position;
 
        Direction direction;
 
        TransformationResult result;
    };
 
    std::vector<Transformation> FindTransformations() const;
 
    void AppendSubjectTransformations(
        const Rule& rule, ObjectType subject,
        std::vector<Transformation>& transformations) const;
 
    TransformationResult ResolveTransformation(
        const LocatedInstance& source,
        const std::vector<Transformation>& transformations) const;
 
    void AppendAllTargets(TransformationResult& result) const;
 
    static ObjectType ResolveTransformationTarget(ObjectType source,
                                                  ObjectType predicate);
 
    void CollectTransformationSnapshot(std::vector<LocatedInstance>& instances,
                                       std::vector<Position>& emptyTiles) const;
 
    void AppendTransformationInstancesAt(
        const Position& position,
        std::vector<LocatedInstance>& instances) const;
 
    void ApplyTransformation(const LocatedInstance& source,
                             const TransformationResult& result);
 
    bool SpawnAllTargets(const Position& position, Direction direction,
                         const std::vector<ObjectType>& targets);
 
    void ApplyEmptyTransformation(const EmptyTransformation& pending);
 
    void UpdateAllNouns();
 
    Direction RandomDirection();
 
    bool HasPropertyAtPosition(const ObjectInstance& instance,
                               const Position& position,
                               ObjectType property) const;
 
    bool HasPropertyAt(std::size_t x, std::size_t y, ObjectType property) const;
 
    bool MatchesConditionsAt(
        const ObjectInstance& instance, const Position& position,
        const std::vector<RuleCondition>& conditions) const;
 
    bool MatchesConditionAt(const ObjectInstance& instance,
                            const Position& position,
                            const RuleCondition& condition) const;
 
    struct OpenShutInteraction
    {
        std::vector<ObjectID> matchedIDs;
        std::vector<ObjectID> destroyedIDs;
    };
 
    OpenShutInteraction GetOpenShutInteraction(
        const Position& source, const std::vector<ObjectID>& movingIDs,
        const Position& destination) const;
 
    std::vector<ObjectID> DestroyOpenShutObjects(
        const std::vector<ObjectID>& ids);
 
    void ProcessMove(std::size_t x, std::size_t y, Direction dir,
                     const std::vector<ObjectID>& ids);
 
    void ProcessPush(std::size_t x, std::size_t y, Direction dir,
                     const std::vector<ObjectID>& ids);
 
    void ProcessOpenShut();
 
    void ProcessSink();
 
    void ProcessWeak();
 
    void ProcessHotMelt();
 
    void ProcessDefeat();
 
    void CheckPlayState();
 
    Map m_map;
    RuleManager m_ruleManager;
 
    PlayState m_playState = PlayState::INVALID;
    ObjectType m_playerIcon = ObjectType::ICON_EMPTY;
 
    std::vector<ObjectType> m_playerIcons;
    std::vector<ObjectType> m_allNouns;
    std::vector<ObjectID> m_movementGeneratedIDs;
    std::mt19937 m_randomEngine{ std::random_device{}() };
};
}  // namespace baba_is_auto
 
#endif