#pragma once
#include <memory>

class BoardT;

class RobotT{
    public:
        RobotT(BoardT & b, std::size_t xpos, std::size_t ypos);
        virtual ~RobotT();
        virtual void Move() = 0;
        virtual bool IsSafe(int i) const;
        virtual char Rep() const = 0 ;

    protected:
        BoardT & board;
        std::size_t x,y;
};

using RobotPtr = std::shared_ptr<RobotT>;

class RandomRobotT: public RobotT {
    public:
        RandomRobotT(BoardT & b, std::size_t xpos, std::size_t ypos): 
                                  RobotT{b, xpos, ypos} { };
        void Move() override;
        char Rep() const  override;
};

class StatRobotT: public RobotT {
    public:
        StatRobotT(BoardT & b, std::size_t xpos, std::size_t ypos): 
                                  RobotT{b, xpos, ypos} { };
        void Move() override;
        bool IsSafe()const;
        char Rep() const  override;
};

class HuntedRobotT: public RobotT {
    public:
        HuntedRobotT(BoardT & b, std::size_t xpos, std::size_t ypos): 
                                  RobotT{b, xpos, ypos} { };
        ~HuntedRobotT();
        void Move() override;
        char Rep() const  override;
        virtual void Squeek() const;
    private:
        int dir{0};
};

class BigHuntedRobotT: public HuntedRobotT {
    public:
        BigHuntedRobotT(BoardT & b, std::size_t xpos, std::size_t ypos): 
                                  HuntedRobotT{b, xpos, ypos} { };
        ~BigHuntedRobotT();
        void Squeek() const override;
        char Rep() const  override;

};