#include <iostream>
#include <vector>
#include <string>



class Entity;

class FieldObject
{

public:
	bool isDangerous() const
	{
		return false;
	}
};


struct Cell
{
	FieldObject *field;
	Entity *enity;
	Cell()
	{
		field = nullptr;
		enity = nullptr;
	}
};



struct GameField
{
	std::vector<std::vector<Cell>> playingField_;
	size_t size_;

	GameField(size_t size) :size_(size)
	{
		playingField_.resize(size);
		for (size_t i=0;i<size_;i++)
		{
			playingField_[i].resize(size);
		}

	}
};



class Entity
{
	size_t x_;
	size_t y_;

public:
	Entity(size_t x,size_t y):x_(x),y_(y)
	{}

	virtual bool isDangerous() const
	{
		return false;
	}

	size_t getX()
	{
		x_;
	}

	size_t getY()
	{
		y_;
	}

	void move(GameField &gameField, size_t x, size_t y)
	{
		Entity *ptrEnity=this;
		gameField.playingField_[y_][x_].enity=nullptr;
		x_ = x;
		y_ = y;
		gameField.playingField_[y_][x_].enity = ptrEnity;
	}
};


class Hunter:public Entity
{


public:
	Hunter(size_t x, size_t y):Entity(x,y)
	{}

	bool isDangerous() const
	{
		return true;
	}

	size_t getX()
	{
		return Entity::getX();
	}

	size_t getY()
	{
		return Entity::getY();
	}

	void move(GameField &gameField, size_t x, size_t y)
	{
		Entity::move(gameField, x, y);
	}


};


class Beast :public Entity
{

public:
	Beast(size_t x, size_t y) :Entity(x, y)
	{}

	bool isDangerous() const
	{
		return true;
	}

	size_t getX()
	{
		return Entity::getX();
	}

	size_t getY()
	{
		return Entity::getY();
	}

	void move(GameField &gameField, size_t x, size_t y)
	{
		Entity::move(gameField, x, y);
	}
};



int main()
{
	size_t gameFieldSize = 5;
	GameField gameField(gameFieldSize);

	for (size_t i = 0; i < gameFieldSize; i++)
	{
		for (size_t j = 0; j < gameFieldSize; j++)
		{
			if (gameField.playingField_[i][j].enity != nullptr)
			{
				std::cout << 1 << " ";
			}
			else
			{
				std::cout << 0 << " ";
			}
		}
		std::cout << "\n";
	}
	std::cout << "\n";
	Beast beast(1, 3);
	beast.move(gameField, 1, 3);



	for (size_t i = 0; i < gameFieldSize; i++)
	{
		for (size_t j = 0; j < gameFieldSize; j++)
		{
			if (gameField.playingField_[i][j].enity != nullptr)
			{
				std::cout << 1 << " ";
			}
			else
			{
				std::cout << 0 << " ";
			}
		}
		std::cout << "\n";
	}


	system("pause");
	return 0;
}