<?php

abstract class Animal
{
    public  $symbol;                  //символ на карте
    public  $x;                       //координата
    public  $y;                       //координата
    public  $name;                    //имя животного
    public  $possibleMoves = array(); //возможныеые ходы
    private $enemies;                 //найденные враги
    private $dogs;                    //найденные собаки
    public  $field;                   //карта класса FIeld
    public  $vision;                  //дальность обзора

    abstract protected function tryToMove();
    abstract protected function searchPossibleMoves();

    //Называем животное
    public function __construct($name)
    {
        $this->name = $name;
    }

    //Метод Печати символа животного на карте
    public function printSymbol()
    {
        echo "$this->symbol  ";
    }

    //Метод передвижения в определенную координату
    protected function moveTo($x, $y)
    {
        echo "Я, {$this->name}, хожу x:{$x}, y:{$y}.\n";
        $this->x = $x;
        $this->y = $y;
    }

    //Метод удаления информации за прошлый ход
    public function clearPastInfo()
    {
        $this->possibleMoves = NULL;
        $this->enemies       = NULL;
        $this->dogs          = NULL;
    }

    //Метод случайного хода без обдумывания побега или охоты
    protected function freeMove()
    {
        //Выбираем случайный ход из возможных
        $randomTurn = $this->possibleMoves[mt_rand(0, count($this->possibleMoves) - 1)];
        //Ходим
        $this->moveTo($randomTurn['x'], $randomTurn['y']);
    }
}

class Mouse extends Animal
{
    public  $symbol;                  //символ на карте
    public  $x;                       //координата
    public  $y;                       //координата
    public  $name;                    //имя животного
    public  $possibleMoves = array(); //возможные ходы
    private $enemies;                 //найденные враги
    private $dogs;                    //найденные собаки
    public  $field;                   //карта класса Field
    public  $vision = 4;              //дальность обзора

    //Метод хода
    public function tryToMove()
    {
        //Ищем животное в дальности обзора
        $foundAnimals  = $this->field->searchForAnimals($this->x, $this->y, $this->vision);
        //Присваиваем полям найденные результаты
        $this->enemies = $foundAnimals["cats"];
        $this->dogs    = $foundAnimals["dogs"];
        //Ищем возможные ходы
        $this->possibleMoves = $this->searchPossibleMoves();
        //Если нельзя сдвинуться - стоим
        if (count($this->possibleMoves) == 0) {
            echo "Стою на месте.\n";
        //Если  нашли кошку - убегаем
        } elseif ($this->enemies != NULL) {
            $this->escape();
        //Если ничего не нашли - свободно ходим
        } else {
            echo "Кошек рядом нет. ";
            $this->freeMove();
        }
    }

    //Метод поиска возможных ходов
    public function searchPossibleMoves()
    {
        //Возможые ходы для мышки (4 стороны)
        $possibleMoves   = array();
        $arrows["up"]    = array('x' => $this->x,     'y' => $this->y - 1);
        $arrows["right"] = array('x' => $this->x + 1, 'y' => $this->y);
        $arrows["down"]  = array('x' => $this->x,     'y' => $this->y + 1);
        $arrows["left"]  = array('x' => $this->x - 1, 'y' => $this->y);
        foreach ($arrows as $arrow) {
            //Отсеиваем невозможные ходы (ход за карту, ход на собрата мыша или панибрата собаку)
            if ($this->field->canIMoveTo($arrow['x'], $arrow['y'])) {
                $possibleMoves[] = $arrow;
            }
        }
        //Возвращаем результат
        return $possibleMoves;
    }

    //Метод побега для кошки
    public function escape()
    {
        echo "У мышки {$this->name} рядом кошка. ";
        //Ищем наилучший возможный ход и ходим
        $bestMove = $this->searchBestMove();
        $this->moveTo($bestMove['x'], $bestMove['y']);
    }

    //Метод поиска лучшего хода
    private function searchBestMove()
    {
        $bestMove = array();
        //Очки за лучшиий за ход мыши. -1 из-за случаев когда лучший ход приносит 0 баллов
        $pointsMax = -1;
        foreach ($this->possibleMoves as $move)
        {
        /**
         * Оценка каждого хода.
         * Приоритет 1: Количество клеток до врага. Их должно быть как можно больше. Коэффициент 100
         * Приоритет 2: Количество клеток до ближайшего угла. Как можно больше, чтобы не забиться в угол. Коэфициент 10
         * Приоритет 3: Количество клеток до собаки. Может стать приоритетом 2 в ситуации когда только собака может спасти от съедения кошкой
         */
            //Ищем ближайшего врага и считаем шаги до него
            $nearbyEnemy    = $this->field->searchNearbyAnimal($move['x'], $move['y'], $this->enemies);
            $stepsToEnemy   = $this->field->countSteps($move['x'], $move['y'], $nearbyEnemy->x, $nearbyEnemy->y);
            //Не даем очки, если один шаг чтобы этот ход был максимально плохим вариантом
            if ($stepsToEnemy == 1) {
                $pointsForEnemy = 0;
            } else {
                $pointsForEnemy = $stepsToEnemy * 100;
            }
            //Если есть рядом собаки - используем их в плане побега
            if ($this->dogs != NULL) {
                //Ищем ближайшую собаку и считаем ходы до нее
                $nearbyDog  = $this->field->searchNearbyAnimal($move['x'], $move['y'], $this->enemies);
                $stepsToDog = $this->field->countSteps($move['x'], $move['y'], $nearbyDog->x, $nearbyDog->y);
                //Тот случай когда собака становится приоритетом 2, потому что может спасти мышку
                if ($stepsToDog == 1 && $stepsToEnemy == 1) {
                    $pointsForDog = 90;
                //В остальных случаях это наименьший по очкам приоритет
                } else{
                    $pointsForDog = $this->field->getWidth() - $stepsToDog;
                }
            //Если собак нету - не даем очков
            } else {
                $pointsForDog = 0;
            }
            //Считаем очки за степень приближения к ближайшему краю, стараемся быть дальше от него
            $pointsForCorner = $this->field->searchNearCorner($move['x'], $move['y']) * 10;
            //Считаем общее число очков за ход
            $points = $pointsForEnemy + $pointsForDog + $pointsForCorner;
            //Если этот ход обогнал лучший результат - он становится лучшим ходом
            if ($points > $pointsMax) {
                $pointsMax = $points;
                $bestMove  = $move;
            }
        }
        //Возвращаем лучший ход
        return $bestMove;
    }
}

class Cat extends Animal
{
    public  $symbol = "K";            //символ на карте(для кошки еще состояние активности)
    public  $x;                       //координата
    public  $y;                       //координата
    public  $name;                    //имя животного
    public  $possibleMoves = array(); //возможные ходы
    private $enemies = array();       //найденные враги
    private $dogs = array();          //найденные собаки
    public  $field;                   //карта класса Field
    public  $vision;                  //дальность обзора
    public  $movesInARow = 0;         //кол-во ходов подряд
    private $turnWhenCatSleep = 8;    //правило "на каком ходу подряд кошка засыпает"

    //Метод хода
    public function tryToMove()
    {
        //Если кошка спит
        if ($this->symbol == "@") {
            //Она просыпается
            $this->symbol = "K";
            //Cчетчик ходов обнуляется
            $this->movesInARow = 0;
            echo "Кошка спит :3\n";
            //Следующий ход
            return;
        //Если ходили n-ое кол-во ходов подряд - спим
        } elseif($this->movesInARow == $this->turnWhenCatSleep) {
            $this->symbol = "@";
        }
        //Ищем животное в дальности обзора
        $foundAnimals  = $this->field->searchForAnimals($this->x, $this->y, $this->vision);
        //Присваиваем полям найденные результаты
        $this->enemies = $foundAnimals["mice"];
        $this->dogs    = $foundAnimals["dogs"];
        //Ищем возможные ходы
        $this->possibleMoves = $this->searchPossibleMoves();
        //Если нельзя сдвинуться - стоим
        if (count($this->possibleMoves) == 0) {
            echo "Стою на месте.\n";
        } else {
            //Ищем лучший ход
            $bestMove = $this->searchBestMove();
            //Если можно съесть мышь по данным координатам - едим
            if ($this->canIEatIt($bestMove['x'], $bestMove['y'])) {
                $this->eatIt($bestMove['x'], $bestMove['y']);
            //В остальных случаях - ходим туда
            } else {
                $this->moveTo($bestMove['x'], $bestMove['y']);
            }
            //Прибавляем счетчик ходов подряд
            $this->movesInARow++;
        }
    }

    //Метод поиска возможных ходов
    public function searchPossibleMoves()
    {
        $possibleMoves = array();
        //Возможые ходы для кошки (8 сторон);
        $arrows["up"]         = array('x' => $this->x,     'y' => $this->y - 1);
        $arrows["up-right"]   = array('x' => $this->x + 1, 'y' => $this->y - 1);
        $arrows["right"]      = array('x' => $this->x + 1, 'y' => $this->y);
        $arrows["right-down"] = array('x' => $this->x + 1, 'y' => $this->y + 1);
        $arrows["down"]       = array('x' => $this->x,     'y' => $this->y + 1);
        $arrows["down-left"]  = array('x' => $this->x - 1, 'y' => $this->y + 1);
        $arrows["left"]       = array('x' => $this->x - 1, 'y' => $this->y);
        $arrows["left-up"]    = array('x' => $this->x - 1, 'y' => $this->y - 1);
        foreach ($arrows as $arrow) {
            //Если на этой клетке собака - сразу отбрасываем этот ход
            if (!$this->field->areChosenAnimalsNearTheCage($arrow['x'], $arrow['y'], $this->dogs)) {
                //Если там можно съесть мышь или походить - это возможных ход
                if ($this->canIEatIt($arrow['x'], $arrow['y'])) {
                    $possibleMoves[] = $arrow;
                } elseif ($this->field->canIMoveTo($arrow['x'], $arrow['y'])) {
                    $possibleMoves[] = $arrow;
                }
            }
        }
        //Возвращаем результат
        return $possibleMoves;
    }

    //Метод поиска лучшего хода
    private function searchBestMove()
    {
        $bestMove = array();
        //Очки за лучшиий за ход мыши. -1 из-за случаев когда лучший ход приносит 0 баллов
        $pointsMax = -1;
        foreach ($this->possibleMoves as $move) {
        /**
         * Приоритет 1: Мышку можно съесть. 9999 очков
         * Приоритет 2: Количество клеток до врага. Их должно быть как можно меньше. Коэффициент 100.
         * Приоритет 3: Количество клеток до одной линии с мышью, удобная позиция для зажатия в угол.
         */
            //Ищем ближайшего врага и считаем шаги до него
            $nearbyEnemy = $this->field->searchNearbyAnimal($move['x'], $move['y'], $this->enemies);
            $stepsToEnemy = $this->field->countSteps($move['x'], $move['y'], $nearbyEnemy->x, $nearbyEnemy->y);
            //Если можно съесть мышь по указанным координатам - это однозначно лучший ход
            if ($this->canIEatIt($move['x'], $move['y'])) {
                $pointsForEnemy = 9999;
            } else {
                $pointsForEnemy = ($this->field->getWidth() - $stepsToEnemy) * 100;
            }
            //Если кошка на одной линии с мышкой
            if ($move['x'] == $nearbyEnemy->x || $move['y'] == $nearbyEnemy->y) {
                $pointsForOneLine = 99;
            //Если нет
            } else {
                $pointsForOneLine = $this->field->getWidth() - abs(min($move['x'] - $nearbyEnemy->x, $move['y'] - $nearbyEnemy->y));
            }
            //Считаем общее очков за ход
            $points = $pointsForEnemy + $pointsForOneLine;
            //Если этот ход обогнал лучший результат - он становится лучшим ходом
            if ($points > $pointsMax) {
                $pointsMax = $points;
                $bestMove = $move;
            }
        }
        //Возвращаем результат
        return $bestMove;
    }

    //Метод возможности съедения мышки по данным координатам
    private function canIEatIt($x, $y)
    {
        //Если там мышка - очевидно возомжно, но еще не можно
        if ($this->field->getAnimal($x, $y) instanceof Mouse) {
            //Обнажили зубки
            echo "Пытаюсь съесть {$this->field->getAnimal($x, $y)->name}. ";
            //В переменной oneLine считаем количество мышей которые рядом с друг другом
            $oneLine = 0;
            foreach ($this->enemies as $mouse) {
                if ($this->field->areChosenAnimalsNearTheCage($mouse->x, $mouse->y, $this->enemies)) {
                    $oneLine++;
                }
            }
            //Если их меньше трех - омномном
            if ($oneLine < 3) {
                return TRUE;
            //Если больше - мы грустим
            } else {
                echo "Мыши защищают друг друга. ";
                return FALSE;
            }
        //Если там мышки нет - не можем
        } else {
            return FALSE;
        }
    }

    //Метод поедения несчастного объекта
    private function eatIt ($x, $y)
    {
        //Удаление элемента массива по значению
        if(($key = array_search($this->field->getAnimal($x, $y), $this->field->animals)) !== FALSE){
            unset($this->field->animals[$key]);
	    }
        //Ход на освободившуюся клетку
        $this->moveTo($x, $y);
        //Переход в спящий режим
        $this->symbol = "@";
    }

}

class Dog extends Animal {
    public $symbol = "D";            //символ на карте(для кошки еще состояние активности)
    public $x;                       //координата
    public $y;                       //координата
    public $name;                    //имя животного
    public $possibleMoves = array(); //возможные ходы
    public $field;                   //карта класса Field

    //Метод хода
    public function tryToMove()
    {
        //Ищем возможные ходы
        $this->possibleMoves = $this->searchPossibleMoves();
        //Если нельзя сдвинуться - стоим
        if (count($this->possibleMoves) == 0) {
            echo "Ходить $this->name некуда.\n";
        //Если можно сдвинуться - ходим, как ни странно
        } else {
            $this->freeMove();
        }
    }

    //Метод поиска возможных ходов
    public function searchPossibleMoves()
    {
        $possibleMoves = array();
        //Возможые ходы для собаки (8 сторон)
        $arrows["up"]         = array('x' => $this->x,   'y' => $this->y-2);
        $arrows["up-right"]   = array('x' => $this->x+2, 'y' => $this->y-2);
        $arrows["right"]      = array('x' => $this->x+2, 'y' => $this->y);
        $arrows["right-down"] = array('x' => $this->x+2, 'y' => $this->y+2);
        $arrows["down"]       = array('x' => $this->x,   'y' => $this->y+2);
        $arrows["down-left"]  = array('x' => $this->x-2, 'y' => $this->y+2);
        $arrows["left"]       = array('x' => $this->x-2, 'y' => $this->y);
        $arrows["left-up"]    = array('x' => $this->x-2, 'y' => $this->y-2);
        foreach ($arrows as $arrow) {
            //Отсеиваем невозможные ходы (ход за карту, ход на собрата собаку или противного мыша)
            if ($this->field->canIMoveTo($arrow['x'], $arrow['y'])) {
                $possibleMoves[] = $arrow;
            }
        }
        //Возвращаем результат
        return $possibleMoves;
    }


}

class Field {
    private $width;              //ширина
    private $height;             //высота
    private $numberOfTurns = 30; //количество ходов
    public  $animals = array();  //массив животных

    //Задаем ширину, высоту
    public function __construct($width, $height)
    {
        $this->width = $width;
        $this->height = $height;
    }

    //Метод размещения животного на карте
    public function addAnimal(Field $field, Animal $animal)
    {
        //Добавляем животное в список
        $this->animals[] = $animal;
        //Счетчик для различия мышей на карте
        static $i = 1;
        //Передаем карту в поле животного как советовал мудрый ОП
        $animal->field = $field;
        //Если животное - кошка, делаем ей максимальную дальность обзора
        if ($animal instanceof Cat) {
        $animal->vision = $this->width;
        }
        //Координаты могут быть заняты, если мы вручную их забиваем
        if ($animal->x == NULL && $animal->y == NULL) {
        //Рандомим пока не найдем пустую клетку
            do {
                $x = mt_rand(1, $this->width);
                $y = mt_rand(1, $this->height);
            } while ($this->isCageClose($x, $y));
            //Инициализурем удачные координаты
            $animal->x = $x;
            $animal->y = $y;
            //Увеличиваем счетчик для символа на карте
            if ($animal instanceof Mouse) {
                $animal->symbol = $i++;
            }
        }
    }

    //Метод определения возможности животного походить по указанным координатам
    public function canIMoveTo($x, $y)
    {
        //Если хочет сбежать за пределы карты или клетка занята - нет
        if ($x < 1             ||
            $y < 1             ||
            $x > $this->width  ||
            $y > $this->height ||
            $this->isCageClose($x, $y)) {
            return FALSE;
        } else {
            return TRUE;
        }
    }

    //Метод поиска ближайшего угла
    public function searchNearCorner($x, $y)
    {
        //Находимся ли мы слева от центра или справа, вверху или внизу
        $stepsToCornerX = ($x < $this->width/2)  ? $x - 1 : $this->width - $x;
        $stepsToCornerY = ($y < $this->height/2) ? $y - 1 : $this->height - $y;
        return min($stepsToCornerX, $stepsToCornerY);
    }


    //Метод определяющий занятость клетки
    private function isCageClose($x, $y)
    {
        foreach ($this->animals as $animal)
        {
            if ($x == $animal->x && $y == $animal->y) {
                return True;
            }
        }
        return False;
    }

    //Метод получения объекта по координатам из массива животных
    public function getAnimal ($x, $y)
    {
        foreach ($this->animals as $animal)
        {
            if ($x == $animal->x && $y == $animal->y) {
                return $animal;
            }
        }
    }

    //Метод вывода карты
    private function showField($turn)
    {
        //Номер координаты на оси Y
        $line = 0;
        //Номер координаты на оси X
        $top  = 1;
        //Выводим ось X
        //Если первая строка
        if ($line == 0) {
            //Три пробела
            echo "   ";
            while ($top <= $this->width) {
                //А потом печатаем цифры и пробелы
                if ($top < 10) {
                    //Два для двухзначных чисел
                    echo $top++ . "  ";
                    //Один для однозначных
                } else {
                    echo $top++  . " ";
                }
            }
            //Следующая строка
            $line++;
            echo "\n";
        }
        //Выводим ось Y
        for ($i = 1; $i <= $this->height; $i++) {
            //Если число однозачное - два пробела
            if ($line < 10) {
                echo "$line  ";
            //Если число двухзначное - один пробел
            } else {
                echo "$line ";
            }
            //Выводим карту
            for($j = 1; $j <= $this->width; $j++) {
                //Если клетка ззанята - выводим символ животного
                if ($this->isCageClose($j, $i)) {
                    $this->getAnimal($j, $i)->printSymbol();
                //Если клетка пустая - выводим ее в форме точки
                } else {
                    echo ".  ";
                }
            }
            //Выводи дополнительные данные рядом с определенной строкой
            if ($line == 1) echo "   Ход: {$turn}";
            if ($line == 2) echo "   Мышек: {$this->countAnimals('Mouse')}";
            if ($line == 3) echo "   Кошек: {$this->countAnimals('Cat')}";
            if ($line == 4) echo "   Собак: {$this->countAnimals('Dog')}";
            //Следующая строка
            $line++;
            echo "\n";
        }
    }

    //Метод игры
    public function startGame(Field $field)
    {
        //Делаем заданное заранее количество ходов
        for ($turn = 0; $turn <= ($this->numberOfTurns); $turn++) {
            //Выводим поле
            $this->showfield($turn);
            //Каждое животное делает ход
            foreach ($this->animals as $animal) {
                //Так как в цикле foreach копия массива надо проверять данные с изменениями
                if(!in_array($animal, $this->animals)) {
                    continue;
                }
                //Животное делает ход
                $animal->tryToMove();
                //Чистим устаревшую информацию о ходе
                $animal->clearPastInfo();
                //Если всех мышей съели - конец игры
                if ($this->countAnimals("Mouse") == 0) {
                    die("Конец игры.");
                }
            }
            echo "\n";
        }
    }

    //Метод поиска животных в определенном обзоре
    public function searchForAnimals($x, $y, $vision)
    {
        $foundAnimals = array("mice" => NULL, "cats" => NULL, "dogs" => NULL);
        //Обзор не должен выходить за пределы карты, в этом случае крайней точкой обзора будет край карты
        for ($i = max($y - $vision, 1), $k = min($y + $vision, $this->height); $i <= $k; $i++) {
            //Проходим во вложенном цикле по воображаемому квадрату обзора, животное в центре
            for ($j = max($x - $vision, 1), $l = min($x + $vision, $this->width); $j <= $l; $j++) {
                //Если мы увидели свои координаты - не добавляем их в результат
                if ($i == $y && $j == $x) {
                    continue;
                //В остальных случаев записываем увиденных животных в массив
                } elseif ($this->getAnimal($j, $i) instanceof Mouse) {
                    $foundAnimals["mice"][] = $this->getAnimal($j, $i);
                } elseif ($this->getAnimal($j, $i) instanceof Cat) {
                    $foundAnimals["cats"][] = $this->getAnimal($j, $i);
                } elseif ($this->getAnimal($j, $i) instanceof Dog) {
                    $foundAnimals["dogs"][] = $this->getAnimal($j, $i);
                }
            }
        }
        //Возвращаем результат
        return $foundAnimals;
    }

    //Метод подсчета животных. Считает определенных животных
    private function countAnimals($nameOfTheAnimal)
    {
        $counter = 0;
        //Если нужное животное есть в массиве - прибавляем счетчик
        foreach ($this->animals as $animal) {
            if ($animal instanceof $nameOfTheAnimal) {
                $counter++;
            }
        }
        return $counter;
    }

    //Возвращаем private поле с длинной карты
    public function getWidth()
    {
        return $this->width;
    }

    //Возвращаем private поле с высотой карты
    public function getHeight()
    {
        return $this->height;
    }

    //Метод определяющий наличие опреденного вида животных с данными координатами
    public function areChosenAnimalsNearTheCage($x, $y, array $animals)
    {
        foreach ($animals as $animal)
        {
            //Наши координаты не влияют на ответ на поставленный вопрос
            if ($animal->x == $x && $animal->y == $y) {
                continue;
            }
            //Если количество шагов до животного равно одному, ответ - да
            if($this->countSteps($x, $y, $animal->x, $animal->y) == 1) {
                return TRUE;
            }
        }
        //В остальных случаях ответ - нет
        return FALSE;
    }

    //Метод подсчета шагов между двумя точками
    public function countSteps($point1X, $point1Y, $point2X, $point2Y)
    {
        //Подсчет шагов по оси X
        $countStepsX = abs($point1X - $point2X);
        //ПОдсчет шагов по оси Y
        $countStepsY = abs($point1Y - $point2Y);
        //Возвращаем наибольшее
        return max($countStepsX, $countStepsY);
    }

    //Метод нахождения ближайшего животного из определенного массива
    public function searchNearbyAnimal($x, $y, array $animals)
    {
        //Лучший результат по умолчанию
        $stepsNearestAnimal = 1000;
        foreach ($animals as $animal) {
            //Считаем  шаги между животным и координатами
            $countSteps = $this->countSteps($x, $y, $animal->x, $animal->y);
            //Если меньше лучшего результата - это лучший результат
            if ($countSteps < $stepsNearestAnimal) {
                $nearbyAnimal = $animal;
                $stepsNearestAnimal = $countSteps;
            //Если на одном расстоянии с результатом - продалжаем поиск
            } elseif ($countSteps == $stepsNearestAnimal) {
                continue;
            }
        }
        //Возвращаем ближайшее животное
        return $nearbyAnimal;
    }
}

//Создаем карту
$field  = new Field(10,10);
//Создаем и именум зверье
$mouse1 = new Mouse("mouse1");
$field->addAnimal($field, $mouse1);
$mouse2 = new Mouse("mouse2");
$field->addAnimal($field, $mouse2);
$mouse3 = new Mouse("mouse3");
$field->addAnimal($field, $mouse3);
$cat1   = new Cat("cat1");
$field->addAnimal($field, $cat1);
$cat2   = new Cat("cat2");
$field->addAnimal($field, $cat2);
$dog1   = new Dog("dog1");
$field->addAnimal($field, $dog1);
$dog2   = new Dog("dog2");
$field->addAnimal($field, $dog2);
//Начинаем игру
$field->startGame($field);

foreach ($field->animals as $key => $value) {
	echo $key;
	echo $value;
}

//Тест на два огня
/**
$field  = new Field(5, 6);
$mouse1 = new Mouse("mouse1");
$mouse1->x = 3;
$mouse1->y = 3;
$mouse1->symbol = 1;
$field->addAnimal($field, $mouse1);
$cat1   = new Cat("cat1");
$cat1->x = 1;
$cat1->y = 3;
$field->addAnimal($field, $cat1);
$cat2   = new Cat("cat2");
$cat2->x = 5;
$cat2->y = 3;
$field->addAnimal($field, $cat2);
$dog1 = new Dog("dog1");
$dog1->x = 5;
$dog1->y = 6;
$field->addAnimal($field, $dog1);
$field->startGame($field);
*/

//Тест на мышинную оборону
/**
$field  = new Field(10, 10);
$mouse1 = new Mouse("mouse1");
$mouse1->x = 1;
$mouse1->y = 1;
$mouse1->symbol = 1;
$field->addAnimal($field, $mouse1);
$mouse2 = new Mouse("mouse2");
$mouse2->x = 2;
$mouse2->y = 2;
$mouse2->symbol = 2;
$field->addAnimal($field, $mouse2);
$mouse3 = new Mouse("mouse3");
$mouse3->x = 3;
$mouse3->y = 3;
$mouse3->symbol = 3;
$field->addAnimal($field, $mouse3);
$cat1   = new Cat("cat1");
$cat1->x   = 2;
$cat1->y   = 1;
$field->addAnimal($field, $cat1);
$dog1   = new Dog("dog1");
$dog1->x = 5;
$dog1->y = 5;
$field->addAnimal($field, $dog1);
$field->startGame($field);
*/

//Тест на пирамиду котов
/**
$field  = new Field(7, 7);
$mouse1 = new Mouse("mouse1");
$mouse1->x = 3;
$mouse1->y = 4;
$mouse1->symbol = 1;
$field->addAnimal($field, $mouse1);
$cat1    = new Cat("cat1");
$cat1->x = 1;
$cat1->y = 3;
$field->addAnimal($field, $cat1);
$cat2    = new Cat("cat2");
$cat2->x = 2;
$cat2->y = 2;
$field->addAnimal($field, $cat2);
$cat3    = new Cat("cat3");
$cat3->x = 3;
$cat3->y = 1;
$field->addAnimal($field, $cat3);
$cat4    = new Cat("cat4");
$cat4->x = 4;
$cat4->y = 2;
$field->addAnimal($field, $cat4);
$cat5    = new Cat("cat5");
$cat5->x = 5;
$cat5->y = 3;
$field->addAnimal($field, $cat5);
$dog1    = new Dog("dog1");
$dog1->x = 7;
$dog1->y = 7;
$field->addAnimal($field, $dog1);
$field->startGame($field);
*/

//Тест на два огня #2
/**
$field          = new Field(8, 8);
$mouse1         = new Mouse("mouse1");
$mouse1->x      = 3;
$mouse1->y      = 4;
$mouse1->symbol = 1;
$field->addAnimal($field, $mouse1);
$cat1           = new Cat("cat1");
$cat1->x        = 1;
$cat1->y        = 3;
$field->addAnimal($field, $cat1);
$cat2   = new Cat("cat2");
$cat2->x        = 5;
$cat2->y        = 5;
$field->addAnimal($field, $cat2);
$dog1 = new Dog("dog1");
$dog1->x        = 8;
$dog1->y        = 8;
$field->addAnimal($field, $dog1);
$field->startGame($field);
*/