field.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <vector> // std::vector
#include <memory> // std::shared_ptr, std::move
#include <map> // std::map
#include <set> // std::set
#include "pawn.hpp"
#include "border.hpp"
#include "cursor.hpp"
 
namespace sista {
    enum class Effect { // Effect enum - effect when a coordinate is out of bounds
        PACMAN = 0, // Pacman effect when a coordinate overflows
        MATRIX = 1 // Classic C style matrix effect when a coordinate overflows
    };
 
    class Field { // Field class - represents the field [parent class]
    protected:
        std::vector<std::vector<std::shared_ptr<Pawn>>> pawns;
        Cursor cursor; 
        int width; 
        int height; 
        void cleanCoordinates(const Coordinates&) const;
        void cleanCoordinates(unsigned short, unsigned short) const;
 
    public:
        void clear();
 
        Field(int, int);
        virtual ~Field() = default;
 
        void print() const;
        void print(char) const;
        void print(Border&) const;
 
        virtual void addPawn(std::shared_ptr<Pawn>);
        virtual void removePawn(Pawn*);
        virtual void removePawn(const Coordinates&);
        virtual void erasePawn(Pawn*);
        virtual void erasePawn(const Coordinates&);
 
        void addPrintPawn(std::shared_ptr<Pawn>);
        void rePrintPawn(Pawn*);
 
        void movePawn(Pawn*, const Coordinates&);
        void movePawn(Pawn*, unsigned short, unsigned short);
 
        void movePawnBy(Pawn*, const Coordinates&);
        void movePawnBy(Pawn*, unsigned short, unsigned short);
 
        // 🎮 movePawnBy() with arcade game effects on coordinates overflow
        void movePawnBy(Pawn*, const Coordinates&, Effect);
        void movePawnBy(Pawn*, short int, short int, Effect);
 
        void movePawnFromTo(const Coordinates&, const Coordinates&);
        void movePawnFromTo(unsigned short, unsigned short, unsigned short, unsigned short);
 
        Coordinates movingByCoordinates(Pawn*, short int, short int) const;        
        Coordinates movingByCoordinates(Pawn*, short int, short int, Effect) const; // movingByCoordinates - calculate the coordinates of a pawn after a movement
 
        Pawn* getPawn(const Coordinates&) const;
        Pawn* getPawn(unsigned short, unsigned short) const;
 
        bool isOccupied(const Coordinates&) const;
        bool isOccupied(unsigned short, unsigned short) const;
        bool isOccupied(short int, short int) const;
 
        bool isOutOfBounds(const Coordinates&) const;
        bool isOutOfBounds(unsigned short, unsigned short) const;
        bool isOutOfBounds(short int, short int) const;
 
        bool isFree(const Coordinates&) const;
        bool isFree(unsigned short, unsigned short) const;
        bool isFree(short int, short int) const;
 
        void validateCoordinates(const Coordinates&) const;
        void validateCoordinates(unsigned short, unsigned short) const;
    };    
 
    struct Path {
        static long long int current_priority; 
        int priority; 
        Coordinates begin; 
        Coordinates end; 
        Pawn* pawn; 
        Path(Coordinates, Coordinates, Pawn*);
 
        bool operator|(const Path&) const;
        bool operator<(const Path&) const;
        bool operator==(const Path&) const;
    };
}
 
namespace std {
    template<>
    struct hash<sista::Path> {
        std::size_t operator()(const sista::Path& k) const noexcept {
            auto h1 = std::hash<sista::Coordinates>{}(k.begin);
            auto h2 = std::hash<sista::Coordinates>{}(k.end);
            return h1 ^ (h2 << 1);
        }
    };
}
 
namespace sista {
    class SwappableField final : public Field {
    private:
        std::vector<std::vector<short int>> pawnsCount;
        std::set<Path> pawnsToSwap;
        
        Coordinates firstInvalidCell(std::map<Coordinates, short int>&) const; // firstInvalidCell - find the first cell with 2 or more pawns
 
        void clearPawnsToSwap(); // clearPawnsToSwap - clear the pawnsToSwap
 
    public:
        SwappableField(int, int);
        ~SwappableField();
 
        void addPawn(std::shared_ptr<Pawn>) override; // addPawn - add a pawn to the field
        void removePawn(Pawn*) override; // removePawn - remove a pawn from the field
 
        void addPawnToSwap(Pawn*, const Coordinates&); // addPawnToSwap - add a pawn to the pawnsToSwap
        void addPawnToSwap(Path&); // addPawnToSwap - add a path to the pawnsToSwap
 
        void simulateSwaps(); // simulateSwaps - simulate the swaps of the pawnsToSwap
        void applySwaps(); // applySwaps - apply the swaps of the pawnsToSwap
 
        void swapTwoPawns(const Coordinates&, const Coordinates&);
        void swapTwoPawns(Pawn*, Pawn*);
    };
};