Добавлен абстрактный класс карты, нужно дописать

src/AbstractMap.java

@@ -0,0 +1,173 @@
+package src;
+
+import java.awt.*;
+import java.util.Random;
+
+public abstract class AbstractMap {
+    private IDrawingObject __drawingObject = null;
+    protected int[][] _map = null;
+    protected int _width;
+    protected int _height;
+    protected float _size_x;
+    protected float _size_y;
+    protected Random _random;
+    protected int _freeWater = 0;
+    protected int _barrier = 1;
+    protected Graphics graphics;
+
+    public void CreateMap(Graphics g, int width, int height, IDrawingObject drawingObject) {
+        graphics = g;
+        _width = width;
+        _height = height;
+        __drawingObject = drawingObject;
+        GenerateMap();
+        while (!SetObjectOnMap()) {
+            GenerateMap();
+        }
+        DrawMapWithObject();
+    }
+
+    /// <summary>
+    /// Функция для передвижения объекта по карте
+    /// </summary>
+    /// <param name="direction"></param>
+    /// <returns>Bitmap карты с объектом</returns>
+    public void MoveObject(EnumDirection enumDirection) {
+        // Проверка, что объект может переместится в требуемом направлении
+        // Получаем текщую позицию объекта
+        Position objectPosition = __drawingObject.GetCurrentPosition();
+        float currentX = objectPosition.Left;
+        float currentY = objectPosition.Top;
+
+        // В зависимости от направления уставналиваем dx, dy
+        float dx = 0;
+        float dy = 0;
+        // TODO дописать код
+        switch (enumDirection) {
+            case (EnumDirection.None):
+                break;
+            case (EnumDirection.Up): {
+                dy = -__drawingObject.Step();
+            }
+            break;
+            case (EnumDirection.Down): {
+                dy = __drawingObject.Step();
+            }
+            break;
+            case (EnumDirection.Left): {
+                dx = -__drawingObject.Step();
+            }
+            break;
+            case (EnumDirection.Right): {
+                dx = __drawingObject.Step();
+            }
+            break;
+            default:
+                break;
+        }
+        // ЕСли нет коллизии, то перемещаем объект
+        if (!CheckCollision(currentX + dx, currentY + dy)) {
+            __drawingObject.MoveObject(enumDirection);
+        }
+        DrawMapWithObject();
+    }
+
+    /// <summary>
+    /// Функция пытается поместить объект на карту
+    /// </summary>
+    /// <returns>Если удачно возвращает true, иначе - false</returns>
+    private boolean SetObjectOnMap() {
+        if (__drawingObject == null || _map == null) {
+            return false;
+        }
+        // Генерируем новые координаты объекта
+        int x = _random.nextInt(100, 200);
+        int y = _random.nextInt(100, 200);
+        __drawingObject.SetObject(x, y, _width, _height);
+
+        // Проверка, что объект не "накладывается" на закрытые участки
+        return !CheckCollision(x, y);
+    }
+
+    /// <summary>
+    /// Функция для проверки коллизии объекта с препятствиями на карте.
+    /// </summary>
+    /// <param name="x">Координата x объекта</param>
+    /// <param name="y">Координата y объекта</param>
+    /// <returns>Возвращает true если есть коллизия и false - если ее нет</returns>
+    protected boolean CheckCollision(float x, float y) {
+        // Получаем ширину и высоту отображаемого объекта
+        var objectPosition = __drawingObject.GetCurrentPosition();
+        float objectWidth = objectPosition.Right - objectPosition.Left;
+        float objectHeight = objectPosition.Bottom - objectPosition.Top;
+
+        // Теперь узнаем сколько клеток в ширину и высоту объект занимает на карте
+        int objectCellsCountX = (int) Math.ceil(objectWidth / _size_x);
+        int objectCellsCountY = (int) Math.ceil(objectHeight / _size_y);
+
+        // Получим координаты объекта в сетке карты
+        int objectMapX = (int) Math.floor((float) x / _size_x);
+        int objectMapY = (int) Math.floor((float) y / _size_y);
+
+        // В цикле проверяем все клетки карты на коллизию с объектом
+        int dy = 0;
+        int mapCellsX = _map[0].length;
+        int mapCellsY = _map.length;
+        int mapState = _freeWater;
+
+        while (objectMapY + dy < mapCellsY && dy <= objectCellsCountY) {
+            int dx = 0;
+            while (objectMapX + dx < mapCellsX && dx <= objectCellsCountX) {
+                mapState = _map[objectMapX + dx, objectMapY + dy];
+                if (mapState == _barrier) {
+                    return true;
+                }
+                dx++;
+            }
+            dy++;
+        }
+        return false;
+    }
+
+    /// <summary>
+    /// Функция для отрисовки карты с объектом
+    /// </summary>
+    /// <returns></returns>
+    private void DrawMapWithObject() {
+        if (__drawingObject == null || _map == null) {
+            return;
+        }
+
+        for (int i = 0; i < _map.length; ++i) {
+            for (int j = 0; j < _map[0].length; ++j) {
+                if (_map[i][j] == _freeWater) {
+                    DrawWaterPart(graphics, i, j);
+                } else if (_map[i][j] == _barrier) {
+                    DrawBarrierPart(graphics, i, j);
+                }
+            }
+        }
+        __drawingObject.DrawingObject(graphics);
+    }
+
+    /// <summary>
+    /// Метод для генерации карты
+    /// </summary>
+    protected abstract void GenerateMap();
+
+    /// <summary>
+    /// Метод для отрисовки свободного участка на экране
+    /// </summary>
+    /// <param name="g"></param>
+    /// <param name="i"></param>
+    /// <param name="j"></param>
+    protected abstract void DrawWaterPart(Graphics g, int i, int j);
+
+    /// <summary>
+    /// Метод для отрисовки закрытого участка на экране
+    /// </summary>
+    /// <param name="g"></param>
+    /// <param name="i"></param>
+    /// <param name="j"></param>
+    protected abstract void DrawBarrierPart(Graphics g, int i, int j);
+}

src/EnumDirection.java

@@ -2,8 +2,15 @@ package src;
 
 // Перечисление для направлений движения лодки
 public enum EnumDirection {
-    Up,
+    None(0),
-    Down,
+    Up(1),
-    Left,
+    Down(2),
-    Right
+    Left(3),
+    Right(3);
+
+    public final int enumNumber;
+
+    EnumDirection(int i) {
+        this.enumNumber = i;
+    }
 }