Недоделанная 2 лаба

AntiAirCraftGun.form

@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<form xmlns="http://www.intellij.com/uidesigner/form/" version="1" bind-to-class="AntiAirCraftGun">
-  <grid id="27dc6" row-count="1" column-count="1" layout-manager="GridLayoutManager">
-    <margin top="0" left="0" bottom="0" right="0"/>
-    <constraints>
-      <xy x="20" y="20" width="500" height="400"/>
-      <grid row="0" column="0" row-span="1" col-span="1" vsize-policy="3" hsize-policy="3" anchor="0" fill="3" indent="0" use-parent-layout="false"/>
-    </constraints>
-    <properties/>
-    <border type="none"/>
-    <children/>
-  </grid>
-</form>

AntiAirCraftGun.java

@@ -1,2 +0,0 @@
-public class AntiAirCraftGun {
-}

AntiAirCraftGun/src/AntiAircraftGun.form

@@ -0,0 +1,92 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<form xmlns="http://www.intellij.com/uidesigner/form/" version="1" bind-to-class="AntiAircraftGun">
+  <grid id="27dc6" binding="panelAntiAircraftGun" layout-manager="GridLayoutManager" row-count="5" column-count="6" same-size-horizontally="false" same-size-vertically="false" hgap="-1" vgap="-1">
+    <margin top="0" left="0" bottom="0" right="0"/>
+    <constraints>
+      <xy x="41" y="20" width="810" height="380"/>
+    </constraints>
+    <properties/>
+    <border type="none"/>
+    <children>
+      <component id="f9412" class="javax.swing.JButton" binding="buttonCreateGun">
+        <constraints>
+          <grid row="4" column="0" row-span="1" col-span="1" vsize-policy="0" hsize-policy="3" anchor="0" fill="1" indent="0" use-parent-layout="false"/>
+        </constraints>
+        <properties>
+          <text value="Создать установку"/>
+        </properties>
+      </component>
+      <vspacer id="bf8a3">
+        <constraints>
+          <grid row="1" column="0" row-span="2" col-span="1" vsize-policy="6" hsize-policy="1" anchor="0" fill="2" indent="0" use-parent-layout="false"/>
+        </constraints>
+      </vspacer>
+      <component id="9c76c" class="javax.swing.JButton" binding="buttonDown">
+        <constraints>
+          <grid row="4" column="4" row-span="1" col-span="1" vsize-policy="0" hsize-policy="3" anchor="0" fill="1" indent="0" use-parent-layout="false"/>
+        </constraints>
+        <properties>
+          <text value=""/>
+        </properties>
+      </component>
+      <component id="4edcf" class="javax.swing.JButton" binding="buttonLeft">
+        <constraints>
+          <grid row="4" column="3" row-span="1" col-span="1" vsize-policy="0" hsize-policy="3" anchor="0" fill="1" indent="0" use-parent-layout="false"/>
+        </constraints>
+        <properties>
+          <hideActionText value="false"/>
+          <horizontalTextPosition value="11"/>
+          <text value=""/>
+        </properties>
+      </component>
+      <component id="40000" class="javax.swing.JButton" binding="buttonRight">
+        <constraints>
+          <grid row="4" column="5" row-span="1" col-span="1" vsize-policy="0" hsize-policy="3" anchor="0" fill="1" indent="0" use-parent-layout="false"/>
+        </constraints>
+        <properties>
+          <text value=""/>
+        </properties>
+      </component>
+      <component id="ab0ea" class="javax.swing.JButton" binding="buttonUp">
+        <constraints>
+          <grid row="3" column="4" row-span="1" col-span="1" vsize-policy="0" hsize-policy="3" anchor="0" fill="1" indent="0" use-parent-layout="false"/>
+        </constraints>
+        <properties>
+          <text value=""/>
+        </properties>
+      </component>
+      <hspacer id="c1d4a">
+        <constraints>
+          <grid row="4" column="2" row-span="1" col-span="1" vsize-policy="1" hsize-policy="6" anchor="0" fill="1" indent="0" use-parent-layout="false"/>
+        </constraints>
+      </hspacer>
+      <component id="cb31c" class="javax.swing.JButton" binding="buttonCreateAntiAircraftGun">
+        <constraints>
+          <grid row="4" column="1" row-span="1" col-span="1" vsize-policy="0" hsize-policy="3" anchor="0" fill="1" indent="0" use-parent-layout="false"/>
+        </constraints>
+        <properties>
+          <text value="Создать зенитную установку"/>
+        </properties>
+      </component>
+      <component id="699cc" class="javax.swing.JButton" binding="buttonStep">
+        <constraints>
+          <grid row="1" column="5" row-span="1" col-span="1" vsize-policy="0" hsize-policy="3" anchor="0" fill="1" indent="0" use-parent-layout="false"/>
+        </constraints>
+        <properties>
+          <text value="Шаг"/>
+        </properties>
+      </component>
+      <vspacer id="cec6d">
+        <constraints>
+          <grid row="2" column="5" row-span="1" col-span="1" vsize-policy="6" hsize-policy="1" anchor="0" fill="2" indent="0" use-parent-layout="false"/>
+        </constraints>
+      </vspacer>
+      <component id="96b8a" class="javax.swing.JComboBox" binding="comboBoxStrategy">
+        <constraints>
+          <grid row="0" column="5" row-span="1" col-span="1" vsize-policy="0" hsize-policy="2" anchor="8" fill="1" indent="0" use-parent-layout="false"/>
+        </constraints>
+        <properties/>
+      </component>
+    </children>
+  </grid>
+</form>

AntiAirCraftGun/src/AntiAircraftGun.java

@@ -0,0 +1,220 @@
+import Drawings.DirectionType;
+import Drawings.DrawingAntiAircraftGun;
+import Drawings.DrawingGun;
+import Drawings.EnumerateWheels;
+import MovementStrategy.*;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.util.Random;
+
+/**
+ * Форма
+ */
+public class AntiAircraftGun extends JFrame {
+    /**
+     * Стратегия перемещения
+     */
+    private AbstractStrategy abstractStrategy;
+    /**
+     * Объект сущности зенитной установки
+     */
+    private DrawingGun _drawingGun;
+    /**
+     * Панель
+     */
+    public JPanel panelAntiAircraftGun;
+    /**
+     * Кнопка создания
+     */
+    private JButton buttonCreateGun;
+    /**
+     * Кнопка движения вниз
+     */
+    private JButton buttonDown;
+    /**
+     * Кнопка движения вверх
+     */
+    private JButton buttonUp;
+    /**
+     * Кнопка движения влево
+     */
+    private JButton buttonLeft;
+    /**
+     * Кнопка движения вправо
+     */
+    private JButton buttonRight;
+    private JButton buttonCreateAntiAircraftGun;
+    private JButton buttonStep;
+    private JComboBox comboBoxStrategy;
+
+    /**
+     * Метод отрисовки
+     *
+     * @param g - графика
+     */
+    public void paint(Graphics g) {
+        super.paint(g);
+        if (_drawingGun == null) {
+            System.out.println("Значение пустое, я ничего не нарисовал");
+            return;
+        }
+        System.out.println(_drawingGun.getClass().getSimpleName());
+        _drawingGun.DrawTransport(g);
+        System.out.println("Ура, я что-то нарисовал");
+    }
+
+    /**
+     * Конструктор
+     */
+    public AntiAircraftGun() {
+        add(panelAntiAircraftGun);
+        setVisible(true);
+        setSize(800, 800);
+        setResizable(false);
+        Graphics g = getGraphics().create();
+        abstractStrategy = null;
+        Icon iconDown = new ImageIcon("AntiAirCraftGun\\src\\Resources\\Down123.jpg");
+        Icon iconUp = new ImageIcon("AntiAirCraftGun\\src\\Resources\\up123.jpg");
+        Icon iconLeft = new ImageIcon("AntiAirCraftGun\\src\\Resources\\left123.jpg");
+        Icon iconRight = new ImageIcon("AntiAirCraftGun\\src\\Resources\\right123.jpg");
+        buttonDown.setIcon(iconDown);
+        buttonUp.setIcon(iconUp);
+        buttonRight.setIcon(iconRight);
+        buttonLeft.setIcon(iconLeft);
+        comboBoxStrategy.addItem("К центру");
+        comboBoxStrategy.addItem("К краю");
+        buttonCreateGun.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                System.out.println("Я нажал на кнопку");
+                System.out.println(e.paramString());
+                CreateObj(g, "EntityGun");
+            }
+        });
+        buttonCreateAntiAircraftGun.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent actionEvent) {
+                System.out.println("Я нажал на кнопку");
+                System.out.println(actionEvent.paramString());
+                CreateObj(g, "EntityAntiAircraftGun");
+            }
+        });
+        if (_drawingGun == null) {
+            System.out.println("Это выход из формы");
+            return;
+        }
+        System.out.println("Все нормально, идем дальше");
+        buttonDown.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent actionEvent) {
+                boolean result = _drawingGun.MoveTransport(DirectionType.Down);
+                if (result) {
+                    paint(g);
+                    System.out.println(actionEvent.paramString());
+                }
+            }
+        });
+        buttonUp.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent actionEvent) {
+                _drawingGun.MoveTransport(DirectionType.Up);
+                paint(g);
+                System.out.println(actionEvent.paramString());
+            }
+        });
+        buttonLeft.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent actionEvent) {
+                _drawingGun.MoveTransport(DirectionType.Left);
+                paint(g);
+                System.out.println(actionEvent.paramString());
+            }
+        });
+        buttonRight.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent actionEvent) {
+                _drawingGun.MoveTransport(DirectionType.Right);
+                paint(g);
+                System.out.println(actionEvent.paramString());
+            }
+        });
+
+        buttonStep.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent actionEvent) {
+                if (_drawingGun == null) {
+                    return;
+                }
+                if (comboBoxStrategy.isEnabled()) {
+                    abstractStrategy = null;
+                    switch (comboBoxStrategy.getSelectedIndex()) {
+                        case 0: {
+                            abstractStrategy = new MoveToCenter();
+                            break;
+                        }
+                        case 1: {
+                            abstractStrategy = new MoveToBorder();
+                            break;
+                        }
+                    }
+                    if (abstractStrategy == null) {
+                        return;
+                    }
+                    abstractStrategy.SetData(new MoveableGun(_drawingGun),
+                            panelAntiAircraftGun.getWidth(), panelAntiAircraftGun.getHeight());
+                }
+                if (abstractStrategy == null) {
+                    return;
+                }
+                comboBoxStrategy.setEnabled(false);
+                abstractStrategy.MakeStep();
+                paint(g);
+                if (abstractStrategy.GetStatus() == StrategyStatus.Finish) {
+                    comboBoxStrategy.setEnabled(true);
+                    abstractStrategy = null;
+                }
+            }
+        });
+    }
+
+    private void CreateObj(Graphics g, String type) {
+        Random random = new Random();
+        switch (type) {
+            case "EntityAntiAircraftGun": {
+                System.out.println("Я зашле внутрь зенитной установик");
+                _drawingGun =
+                        new DrawingAntiAircraftGun(
+                                random.nextInt(100, 300),
+                                random.nextInt(1000, 3000),
+                                new Color(random.nextInt(0, 255), random.nextInt(0, 255), random.nextInt(0, 255)),
+                                new Color(random.nextInt(0, 255), random.nextInt(0, 255), random.nextInt(0, 255)),
+                                random.nextBoolean(),
+                                random.nextBoolean(),
+                                EnumerateWheels.getRandomEnumerateWheels()
+                        );
+                break;
+            }
+            case "EntityGun": {
+                _drawingGun = new DrawingGun(
+                        random.nextInt(100, 300),
+                        random.nextInt(1000, 3000),
+                        new Color(random.nextInt(0, 255), random.nextInt(0, 255), random.nextInt(0, 255)),
+                        EnumerateWheels.getRandomEnumerateWheels()
+                );
+                break;
+            }
+            default:
+                break;
+        }
+        System.out.println("А здесь мы начинаем рисовать");
+        _drawingGun.SetPictureSize(panelAntiAircraftGun.getWidth(), panelAntiAircraftGun.getHeight());
+        _drawingGun.SetPosition(random.nextInt(10, 100), random.nextInt(10, 100));
+        abstractStrategy = null;
+        comboBoxStrategy.setEnabled(true);
+        paint(g);
+    }
+}
+

AntiAirCraftGun/src/Drawings/DirectionType.java

@@ -0,0 +1,27 @@
+package Drawings;
+
+/**
+ * Пересичление напрваления
+ */
+public enum DirectionType {
+    /**
+     * Вверх
+     */
+    Up,
+    /**
+     * Вниз
+     */
+    Down,
+    /**
+     * Влево
+     */
+    Left,
+    /**
+     * Вправо
+     */
+    Right,
+    /**
+     * Без направления
+     */
+    Unknow,
+}

AntiAirCraftGun/src/Drawings/DrawingAntiAircraftGun.java

@@ -0,0 +1,236 @@
+package Drawings;
+
+import Entites.EntityAntiAirCraftGun;
+import Entites.EntityGun;
+
+import java.awt.*;
+
+/**
+ * Класс отрисовки зенитной установки
+ */
+public class DrawingAntiAircraftGun extends DrawingGun {
+
+    public DrawingAntiAircraftGun(int speed, double weight, Color bodyColor, Color optionalElementsColor, boolean hatchHeight, boolean radar,EnumerateWheels enumerateWheels){
+        super(140,65);
+        setEntityGun(new EntityAntiAirCraftGun(speed,weight,bodyColor,optionalElementsColor,hatchHeight,radar,enumerateWheels));
+    }
+    /**
+     * Класс-сущность
+     */
+    private Entites.EntityAntiAirCraftGun EntityAntiAirCraftGun;
+    /**
+     * Объект прорисовки колес
+     */
+    private DrawingWheels drawingWheels;
+
+    /**
+     * Geter для сущности
+     *
+     * @return Возвращает сущность
+     */
+    public EntityAntiAirCraftGun getEntityAntiAirCraftGun() {
+        return EntityAntiAirCraftGun;
+    }
+
+    /**
+     * Setter для сущности
+     *
+     * @param EntityAntiAirCraftGun - объект сущности
+     */
+    private void setEntityAntiAirCraftGun(EntityAntiAirCraftGun EntityAntiAirCraftGun) {
+        this.EntityAntiAirCraftGun = EntityAntiAirCraftGun;
+    }
+
+    /**
+     * Ширина окна
+     */
+    private Integer _pictureWidth;
+    /**
+     * Высота окна
+     */
+    private Integer _pictureHeight;
+    /**
+     * Позиция по Х
+     */
+    private Integer _startPosX;
+
+    /**
+     * Геттер для стартовой позиции Y
+     *
+     * @return стартовую позицию по Y
+     */
+    public Integer get_startPosY() {
+        return _startPosY;
+    }
+
+    /**
+     * Геттер для стартовой позиции X
+     *
+     * @return стартовую позицию по X
+     */
+    public Integer get_startPosX() {
+        return _startPosX;
+    }
+
+    /**
+     * Сеттер для стартовой позиции X
+     *
+     * @param _startPosX - стартовая позиция X
+     */
+    public void set_startPosX(Integer _startPosX) {
+        this._startPosX = _startPosX;
+    }
+
+    /**
+     * Сеттер для стартовой позиции Y
+     *
+     * @param _startPosY - стартовая позиция Y
+     */
+    public void set_startPosY(Integer _startPosY) {
+        this._startPosY = _startPosY;
+    }
+
+    /**
+     * Позиция по Y
+     */
+    private Integer _startPosY;
+    /**
+     * Ширина прорисовки зенитной установки
+     */
+    private final int _drawingGunWidth = 150;
+    /**
+     * Высота прорисовки зенитной установки
+     */
+    private final int _drawingGunHeight = 115;
+
+
+    /**
+     * Установка границ поля
+     *
+     * @param width  - ширина
+     * @param height - высота
+     * @return false - проверка не пройдена, нельзя разместить объект в этих границах,
+     * true - проверка пройдена
+     */
+    public boolean SetPictureSize(int width, int height) {
+        if (_drawingGunHeight > height || _drawingGunWidth > width) {
+            return false;
+        }
+        if (_startPosY != null && _startPosX != null) {
+            if (_startPosX + _drawingGunWidth > width) {
+                _startPosX = width - _drawingGunWidth;
+            }
+            if (_startPosY + _drawingGunHeight > height) {
+                _startPosY = height - _drawingGunHeight;
+            }
+        }
+        _pictureWidth = width;
+        _pictureHeight = height;
+        return true;
+    }
+
+    /**
+     * Установка позиции
+     *
+     * @param x - позиция по x
+     * @param y - позиция по y
+     */
+    public void SetPosition(int x, int y) {
+        if (_pictureHeight == null || _pictureWidth == null) {
+            return;
+        }
+        if (x + _drawingGunWidth > _pictureWidth || x < 0) {
+            _startPosX = _pictureWidth - _drawingGunWidth;
+        } else {
+            _startPosX = x;
+        }
+        if (y + _drawingGunHeight > _pictureHeight || y < 0) {
+            _startPosY = _pictureHeight - _drawingGunHeight;
+        } else {
+            _startPosY = y;
+        }
+    }
+
+    /**
+     * Изменение направления перемещения
+     *
+     * @param direction - тип перемещения
+     * @return true - перемещение удалось;
+     * false - не удалось переместить объект
+     */
+    public boolean MoveTransport(DirectionType direction) {
+        if ((EntityAntiAirCraftGun == null) || (_startPosX == null) || (_startPosY == null)) {
+            System.out.println("Все плохо");
+            return false;
+        }
+        /**
+         * Высота шапки экрана
+         */
+        int heightCap=28;
+        double step = EntityAntiAirCraftGun.getStep();
+        switch (direction) {
+            case DirectionType.Left:
+                if (_startPosX - step > 0) {
+                    System.out.println("Left");
+                    _startPosX -= (int) step;
+                }
+                return true;
+            case DirectionType.Right:
+                if (_startPosX + step + _drawingGunWidth < _pictureWidth) {
+                    System.out.println("Right");
+                    _startPosX += (int) step;
+                }
+                return true;
+            case DirectionType.Down:
+                if (_startPosY + step + _drawingGunHeight < _pictureHeight+heightCap) {
+                    System.out.println("Down");
+                    _startPosY += (int) step;
+                }
+                return true;
+            case DirectionType.Up:
+                if (_startPosY - step > heightCap) {
+                    System.out.println("Up");
+                    _startPosY -= (int) step;
+                }
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    /**
+     * Прорисовка объекта
+     *
+     * @param g - объект графики
+     */
+    public void DrawTransport(Graphics g) {
+        if(EntityGun()==null){
+
+            System.out.println("Здесь EntityGun уже не существует");
+            return;
+        }
+        _startPosX+=10;
+        _startPosY+=50;
+        super.DrawTransport(g);
+        _startPosX-=10;
+        _startPosY-=50;
+        //Орудие
+        g.drawLine(_startPosX + 100, _startPosY + 70, _startPosX + 150, _startPosY + 10);
+        System.out.println(EntityAntiAirCraftGun.isHatch()+"здЕСЬ НЕ ДОЛЖНО БЫТЬ ПУСТО");
+        //Люк
+        if (EntityAntiAirCraftGun.isHatch()) {
+            g.setColor(EntityAntiAirCraftGun.getOptionalElementsColor());
+            g.fillRect(_startPosX + 85, _startPosY + 45, 20, 5);
+        }
+        //Радар
+        if (EntityAntiAirCraftGun.isRadar()) {
+            g.setColor(Color.BLACK);
+            g.drawLine(_startPosX + 65, _startPosY + 50, _startPosX + 65, _startPosY + 25);
+            g.fillOval(_startPosX + 35, _startPosY, 60, 25);
+            g.setColor(Color.GREEN);
+            g.drawLine(_startPosX + 65, _startPosY + 25, _startPosX + 65, _startPosY);
+            g.drawLine(_startPosX + 35, _startPosY + 13, _startPosX + 95, _startPosY + 13);
+        }
+    }
+
+}

AntiAirCraftGun/src/Drawings/DrawingGun.java

@@ -0,0 +1,244 @@
+package Drawings;
+
+import Entites.EntityGun;
+
+import java.awt.*;
+
+public class DrawingGun {
+    private DrawingWheels drawingWheels;
+    private EntityGun entityGun;
+
+    public EntityGun EntityGun() {
+        return entityGun;
+    }
+
+    protected void setEntityGun(EntityGun entityGun) {
+        this.entityGun = entityGun;
+    }
+
+    private Integer _pictureWidth;
+
+    public Integer GetPictureWidth() {
+        return _pictureWidth;
+    }
+
+    ;
+    private Integer _pictureHeight;
+
+    public Integer GetPictureHeight() {
+        return _pictureHeight;
+    }
+
+    /**
+     * Позиция по Х
+     */
+    private Integer _startPosX;
+
+    /**
+     * Геттер для стартовой позиции Y
+     *
+     * @return стартовую позицию по Y
+     */
+    public Integer get_startPosY() {
+        return _startPosY;
+    }
+
+    /**
+     * Геттер для стартовой позиции X
+     *
+     * @return стартовую позицию по X
+     */
+    public Integer get_startPosX() {
+        return _startPosX;
+    }
+
+    /**
+     * Сеттер для стартовой позиции X
+     *
+     * @param _startPosX - стартовая позиция X
+     */
+    public void set_startPosX(Integer _startPosX) {
+        this._startPosX = _startPosX;
+    }
+
+    /**
+     * Сеттер для стартовой позиции Y
+     *
+     * @param _startPosY - стартовая позиция Y
+     */
+    public void set_startPosY(Integer _startPosY) {
+        this._startPosY = _startPosY;
+    }
+
+    /**
+     * Позиция по Y
+     */
+    private Integer _startPosY;
+
+    private Integer _drawingGunWidth = 140;
+    private Integer _drawingGunHeight = 65;
+
+    public Integer GetWidth() {
+        return _drawingGunWidth;
+    }
+
+    public Integer GetHeight() {
+        return _drawingGunHeight;
+    }
+
+    private DrawingGun() {
+        _pictureHeight = null;
+        _pictureWidth = null;
+        _startPosX = null;
+        _startPosY = null;
+    }
+
+    public DrawingGun(int speed, double weight, Color bodyColor, EnumerateWheels countWheels) {
+        super();
+        setEntityGun(new EntityGun(speed, weight, bodyColor, countWheels));
+    }
+
+    protected DrawingGun(int _drawingGunWidth, int _drawingGunHeight) {
+        super();
+        this._drawingGunWidth = _drawingGunWidth;
+        this._drawingGunHeight = _drawingGunHeight;
+    }
+
+    /**
+     * Установка границ поля
+     *
+     * @param width  - ширина
+     * @param height - высота
+     * @return false - проверка не пройдена, нельзя разместить объект в этих границах,
+     * true - проверка пройдена
+     */
+    public boolean SetPictureSize(int width, int height) {
+        if (_drawingGunHeight > height || _drawingGunWidth > width) {
+            return false;
+        }
+        if (_startPosY != null && _startPosX != null) {
+            if (_startPosX + _drawingGunWidth > width) {
+                _startPosX = width - _drawingGunWidth;
+            }
+            if (_startPosY + _drawingGunHeight > height) {
+                _startPosY = height - _drawingGunHeight;
+            }
+        }
+        _pictureWidth = width;
+        _pictureHeight = height;
+        return true;
+    }
+
+    /**
+     * Установка позиции
+     *
+     * @param x - позиция по x
+     * @param y - позиция по y
+     */
+    public void SetPosition(int x, int y) {
+        if (_pictureHeight == null || _pictureWidth == null) {
+            return;
+        }
+        if (x + _drawingGunWidth > _pictureWidth || x < 0) {
+            _startPosX = _pictureWidth - _drawingGunWidth;
+        } else {
+            _startPosX = x;
+        }
+        if (y + _drawingGunHeight > _pictureHeight || y < 0) {
+            _startPosY = _pictureHeight - _drawingGunHeight;
+        } else {
+            _startPosY = y;
+        }
+    }
+
+    /**
+     * Изменение направления перемещения
+     *
+     * @param direction - тип перемещения
+     * @return true - перемещение удалось;
+     * false - не удалось переместить объект
+     */
+    public boolean MoveTransport(DirectionType direction) {
+        if ((EntityGun() == null) || (_startPosX == null) || (_startPosY == null)) {
+            System.out.println("Все плохо");
+            return false;
+        }
+        /**
+         * Высота шапки экрана
+         */
+        int heightCap = 28;
+        double step = EntityGun().getStep();
+        switch (direction) {
+            case DirectionType.Left:
+                if (_startPosX - step > 0) {
+                    System.out.println("Left");
+                    _startPosX -= (int) step;
+                }
+                return true;
+            case DirectionType.Right:
+                if (_startPosX + step + _drawingGunWidth < _pictureWidth) {
+                    System.out.println("Right");
+                    _startPosX += (int) step;
+                }
+                return true;
+            case DirectionType.Down:
+                if (_startPosY + step + _drawingGunHeight < _pictureHeight + heightCap) {
+                    System.out.println("Down");
+                    _startPosY += (int) step;
+                }
+                return true;
+            case DirectionType.Up:
+                if (_startPosY - step > heightCap) {
+                    System.out.println("Up");
+                    _startPosY -= (int) step;
+                }
+                return true;
+            default:
+                return false;
+        }
+    }
+
+
+    /**
+     * Прорисовка объекта
+     *
+     * @param g - объект графики
+     */
+    public void DrawTransport(Graphics g) {
+        if (EntityGun() == null || _startPosX == null || _startPosY == null) {
+            System.out.println("При вызове DrawTransport, получилось исключение");
+            return;
+        }
+        drawingWheels = new DrawingWheels(_startPosX, _startPosY, EntityGun().getCountWheels());
+        // Башня
+        g.setColor(EntityGun().getBodyColor());
+        g.fillRect(_startPosX + 50 - 10, _startPosY + 50 - 50, 60, 25);
+        g.fillRect(_startPosX + 25 - 10, _startPosY + 75 - 50, 110, 10);
+        // Гусеницы
+        g.drawArc(_startPosX + 110 - 10, _startPosY + 85 - 50, 40, 30, 270, 180);
+        g.drawArc(_startPosX + 10 - 10, _startPosY + 85 - 50, 40, 30, 90, 180);
+        g.drawLine(_startPosX + 30 - 10, _startPosY + 115 - 50, _startPosX + 130 - 10, _startPosY + 115 - 50);
+        //Катки большие
+        g.drawOval(_startPosX + 13 - 10, _startPosY + 93 - 50, 20, 20);
+        g.drawOval(_startPosX + 126 - 10, _startPosY + 93 - 50, 20, 20);
+        // Катки малые
+        drawingWheels.drawWheels(g, EntityGun().getBodyColor());
+//        //Орудие
+//        g.drawLine(_startPosX + 100, _startPosY + 70, _startPosX + 150, _startPosY + 10);
+//        //Люк
+//        if (EntityGun().isHatch()) {
+//            g.setColor(EntityGun().getOptionalElementsColor());
+//            g.fillRect(_startPosX + 85, _startPosY + 45, 20, 5);
+//        }
+//        //Радар
+//        if (EntityGun().isRadar()) {
+//            g.setColor(Color.BLACK);
+//            g.drawLine(_startPosX + 65, _startPosY + 50, _startPosX + 65, _startPosY + 25);
+//            g.fillOval(_startPosX + 35, _startPosY, 60, 25);
+//            g.setColor(Color.GREEN);
+//            g.drawLine(_startPosX + 65, _startPosY + 25, _startPosX + 65, _startPosY);
+//            g.drawLine(_startPosX + 35, _startPosY + 13, _startPosX + 95, _startPosY + 13);
+//        }
+    }
+
+}

AntiAirCraftGun/src/Drawings/DrawingWheels.java

@@ -0,0 +1,101 @@
+package Drawings;
+
+import java.awt.*;
+
+public class DrawingWheels {
+    /**
+     * Координата по Х
+     */
+    private final Integer _startPosX;
+    /**
+     * Координата по У
+     */
+    private final Integer _startPosY;
+    /**
+     * Объект перечисления
+     */
+    private EnumerateWheels enumerateWheels;
+
+//    /**
+//     * Установка кол-ва колес
+//     *
+//     * @param countWheels - кол-во колес
+//     */
+//    public void setEnumerateWheels(int countWheels) {
+//        if (4 > countWheels || 6 < countWheels) {
+//            enumerateWheels = Drawings.EnumerateWheels.getRandomEnumerateWheels();
+//        }
+//        switch (countWheels) {
+//            case 4:
+//                enumerateWheels = Drawings.EnumerateWheels.Four;
+//                break;
+//            case 5:
+//                enumerateWheels = Drawings.EnumerateWheels.Five;
+//                break;
+//            case 6:
+//                enumerateWheels = Drawings.EnumerateWheels.Six;
+//                break;
+//
+//        }
+//    }
+
+    /**
+     * Геттер для объекта перечисления
+     *
+     * @return - объект перечисления
+     */
+    public EnumerateWheels getEnumerateWheels() {
+        return enumerateWheels;
+    }
+
+    /**
+     * Конструктор
+     *
+     * @param _startPosX      - координата по Х
+     * @param _startPosY      - координата по У
+     * @param enumerateWheels - объект перечисления
+     */
+    public DrawingWheels(Integer _startPosX, Integer _startPosY, EnumerateWheels enumerateWheels) {
+        this._startPosX = _startPosX;
+        this._startPosY = _startPosY;
+        this.enumerateWheels = enumerateWheels;
+    }
+
+    /**
+     * Геттер для кол-ва колес
+     *
+     * @return кол-во колес
+     */
+    public Integer getEnumerateWheelsCount() {
+        switch (getEnumerateWheels()) {
+            case EnumerateWheels.Five -> {
+                return 5;
+            }
+            case EnumerateWheels.Four -> {
+                return 4;
+            }
+            case EnumerateWheels.Six -> {
+                return 6;
+            }
+            default -> {
+                return -1;
+            }
+        }
+    }
+
+    /**
+     * Отрисовка колес
+     *
+     * @param g           - объект графики
+     * @param optionColor - цвет колес
+     */
+    public void drawWheels(Graphics g, Color optionColor) {
+        int count = 15;
+        System.out.println("Дошел до drawWheels");
+        g.setColor(optionColor);
+        for (int i = 1; i <= getEnumerateWheelsCount(); i++) {
+            g.drawOval(_startPosX + 20 + count - 10, _startPosY + 105 - 50, 10, 10);
+            count += 15;
+        }
+    }
+}

AntiAirCraftGun/src/Drawings/EnumerateWheels.java

@@ -0,0 +1,39 @@
+package Drawings;
+
+import java.util.Random;
+
+public enum EnumerateWheels {
+    /**
+     * Четыре
+     */
+    Four,
+    /**
+     * Пять
+     */
+    Five,
+    /**
+     * Шесть
+     */
+    Six;
+    /**
+     * Массив перечисления
+     */
+    private static final EnumerateWheels[] VALUES = values();
+    /**
+     * Размер массива
+     */
+    private static final int SIZE = VALUES.length;
+    /**
+     * Объект рандома
+     */
+    private static final Random RANDOM = new Random();
+
+    /**
+     * Геттер для рандомного кол-ва колес
+     *
+     * @return рандомное кол-во колес
+     */
+    public static EnumerateWheels getRandomEnumerateWheels() {
+        return VALUES[RANDOM.nextInt(SIZE)];
+    }
+}

AntiAirCraftGun/src/Entites/EntityAntiAirCraftGun.java

@@ -0,0 +1,96 @@
+package Entites;
+
+import Drawings.EnumerateWheels;
+
+import java.awt.*;
+
+/**
+ * Класс-сущность зенитной установки
+ */
+public class EntityAntiAirCraftGun extends EntityGun{
+    private EntityGun EntityGun;
+    private Color optionalElementsColor;
+
+    /**
+     * Геттер для опциональных элементов
+     *
+     * @return цвет для опциональных элементов
+     */
+    public Color getOptionalElementsColor() {
+        return optionalElementsColor;
+    }
+
+    /**
+     * Сеттер для опциональных элементов
+     *
+     * @param optionalElementsColor - цвет для опциональных элементов
+     */
+    public void setOptionalElementsColor(Color optionalElementsColor) {
+        this.optionalElementsColor = optionalElementsColor;
+    }
+
+    /**
+     * Люк
+     */
+    private boolean Hatch;
+
+    /**
+     * Геттер на наличие люка
+     *
+     * @return true - люк есть, false - люка нет
+     */
+    public boolean isHatch() {
+        return Hatch;
+    }
+
+    /**
+     * Сеттер для люка
+     *
+     * @param hatch - наличие люка
+     */
+    private void setHatch(boolean hatch) {
+        Hatch = hatch;
+    }
+
+    /**
+     * Радар
+     */
+    private boolean Radar;
+
+    /**
+     * Геттер для радара
+     *
+     * @return true - радар есть, false - радара нет
+     */
+    public boolean isRadar() {
+        return Radar;
+    }
+
+    /**
+     * Сеттер для радара
+     *
+     * @param radar - наличие радара
+     */
+    private void setRadar(boolean radar) {
+        Radar = radar;
+    }
+
+    /**
+     * Инициализация
+     *
+     * @param speed                 - скорость
+     * @param weight                - вес
+     * @param bodyColor             - основной цвет
+     * @param optionalElementsColor - дополнительный цве
+     * @param hatch                 - люк
+     * @param radar                 - радара
+     */
+
+    public EntityAntiAirCraftGun(int speed, double weight, Color bodyColor, Color optionalElementsColor, boolean hatch, boolean radar, EnumerateWheels countWheels) {
+        super(speed, weight, bodyColor,countWheels);
+        EntityGun = new EntityGun(speed,weight,bodyColor,countWheels);
+        this.optionalElementsColor = optionalElementsColor;
+        Hatch = hatch;
+        Radar = radar;
+    }
+}

AntiAirCraftGun/src/Entites/EntityGun.java

@@ -0,0 +1,115 @@
+package Entites;
+
+import Drawings.EnumerateWheels;
+
+import java.awt.*;
+
+public class EntityGun {
+
+    /**
+     * Скорость
+     */
+    private int speed;
+
+    /**
+     * Геттер для скорости
+     *
+     * @return скорость
+     */
+    public int getSpeed() {
+        return speed;
+    }
+
+    /**
+     * Сеттер для скорости
+     *
+     * @param speed - скорость
+     */
+    private void setSpeed(int speed) {
+        this.speed = speed;
+    }
+
+    /**
+     * Вес
+     */
+    private double weight;
+
+    /**
+     * Геттер для веса
+     *
+     * @return вес
+     */
+    public double getWeight() {
+        return weight;
+    }
+
+    /**
+     * Сеттер для веса
+     *
+     * @param weight - вес
+     */
+    private void setWeight(double weight) {
+        this.weight = weight;
+    }
+
+    /**
+     * Основной цвет
+     */
+    private Color bodyColor;
+
+    /**
+     * Геттер для основого цвета
+     *
+     * @return основной цвет
+     */
+    public Color getBodyColor() {
+        return bodyColor;
+    }
+
+    /**
+     * Сеттер для основого цвета
+     *
+     * @param bodyColor - основной цвет
+     */
+    private void setBodyColor(Color bodyColor) {
+        this.bodyColor = bodyColor;
+    }
+
+    /**
+     * Кол-во колес
+     */
+    private EnumerateWheels countWheels;
+
+    /**
+     * Геттер для кол-ва колес
+     *
+     * @return кол-во колес
+     */
+    public EnumerateWheels getCountWheels() {
+        return countWheels;
+    }
+
+    /**
+     * Сеттер для кол-ва колес
+     *
+     * @param countWheels - кол-во колес
+     */
+    public void setCountWheels(EnumerateWheels countWheels) {
+        this.countWheels = countWheels;
+    }
+    /**
+     * Геттер для шага
+     *
+     * @return шаг
+     */
+    public Double getStep() {
+        return getSpeed() * 100 / getWeight();
+    }
+
+    public EntityGun(int speed, double weight, Color bodyColor, EnumerateWheels countWheels) {
+        this.speed = speed;
+        this.weight = weight;
+        this.bodyColor = bodyColor;
+        this.countWheels = countWheels;
+    }
+}

AntiAirCraftGun/src/Main.java

@@ -0,0 +1,9 @@
+import javax.swing.*;
+
+
+public class Main {
+    public static void main(String[] args) {
+        JFrame frame = new AntiAircraftGun();
+    }
+}
+

AntiAirCraftGun/src/MovementStrategy/AbstractStrategy.java

@@ -0,0 +1,183 @@
+package MovementStrategy;
+
+/**
+ * Класс стратегии
+ */
+public abstract class AbstractStrategy {
+    /**
+     * Перемещаемый объект
+     */
+    private IMoveableObject _moveableObject;
+    /**
+     * Статус перемещения
+     */
+    private StrategyStatus _state = StrategyStatus.NotInit;
+    /**
+     * Ширина поля
+     */
+    private Integer fieldWidth;
+
+    /**
+     * Геттер для ширины поля
+     *
+     * @return ширину поля
+     */
+    protected Integer FieldWidth() {
+        return fieldWidth;
+    }
+
+    /**
+     * Сеттер для ширины поля
+     *
+     * @param fieldWidth ширина поля
+     */
+    private void setFieldWidth(Integer fieldWidth) {
+        this.fieldWidth = fieldWidth;
+    }
+
+    /**
+     * Высота поля
+     */
+    private Integer fieldHeight;
+
+    /**
+     * Геттер для высоты поля
+     *
+     * @return высота поля
+     */
+    protected Integer FieldHeight() {
+        return fieldHeight;
+    }
+
+    /**
+     * Сеттер для высоты поля
+     *
+     * @param fieldHeight высота поля
+     */
+
+    private void setFieldHeight(Integer fieldHeight) {
+        this.fieldHeight = fieldHeight;
+    }
+
+    /**
+     * Геттер для состояния
+     *
+     * @return состояние
+     */
+    public StrategyStatus GetStatus() {
+        return _state;
+    }
+
+    ;
+
+    /**
+     * Установка данных
+     *
+     * @param moveableObject перемещаемый объект
+     * @param width          ширина
+     * @param height         высота
+     */
+    public void SetData(IMoveableObject moveableObject, Integer width, Integer height) {
+        if (moveableObject == null) {
+            _state = StrategyStatus.NotInit;
+            return;
+        }
+        _state = StrategyStatus.InProgress;
+        _moveableObject = moveableObject;
+        setFieldWidth(width);
+        setFieldHeight(height);
+    }
+
+    /**
+     * Шаг перемещения
+     */
+    public void MakeStep() {
+        if (_state != StrategyStatus.InProgress) {
+            return;
+        }
+        if (IsTargetDestinaion()) {
+            _state = StrategyStatus.Finish;
+            return;
+        }
+        MoveToTarget();
+    }
+
+    /**
+     * Влево
+     *
+     * @return Результат перемещения (true - удалось переместиться, false -неудача)
+     */
+    protected boolean MoveLeft() {
+        return MoveTo(MovementDirection.Left);
+    }
+
+    /**
+     * Вправо
+     *
+     * @return Результат перемещения (true - удалось переместиться, false -неудача)
+     */
+    protected boolean MoveRight() {
+        return MoveTo(MovementDirection.Right);
+    }
+
+    /**
+     * Наверх
+     *
+     * @return Результат перемещения (true - удалось переместиться, false -неудача)
+     */
+    protected boolean MoveUp() {
+        return MoveTo(MovementDirection.Up);
+    }
+
+    /**
+     * Вниз
+     *
+     * @return Результат перемещения (true - удалось переместиться, false -неудача)
+     */
+    protected boolean MoveDown() {
+        return MoveTo(MovementDirection.Down);
+    }
+
+    /**
+     * Параметры объекта
+     *
+     * @return
+     */
+    protected ObjectParameters GetObjectParameters() {
+        return _moveableObject.GetObjectPosition();
+    }
+
+    /**
+     * Шаг объекта
+     *
+     * @return
+     */
+    protected Integer GetStep() {
+        if (_state != StrategyStatus.InProgress) {
+            return null;
+        }
+        return _moveableObject.GetStep();
+    }
+
+    /**
+     * Перемещение к цели
+     */
+    protected abstract void MoveToTarget();
+
+    /**
+     * Достигнута ли цель
+     */
+    protected abstract boolean IsTargetDestinaion();
+
+    /**
+     * Попытка перемещения в требуемом направлении
+     *
+     * @return Результат попытки (true - удалось переместиться, false -неудача)
+     */
+    private boolean MoveTo(MovementDirection movementDirection) {
+        if (_state != StrategyStatus.InProgress) {
+            return false;
+        }
+        return _moveableObject.TryMoveObject(movementDirection) && _moveableObject.TryMoveObject(movementDirection);
+    }
+}

AntiAirCraftGun/src/MovementStrategy/IMoveableObject.java

@@ -0,0 +1,10 @@
+package MovementStrategy;
+
+/**
+ * Интерфейс для работы с перемещаемым объектом
+ */
+public interface IMoveableObject {
+    ObjectParameters GetObjectPosition();
+    int GetStep();
+    boolean TryMoveObject(MovementDirection direction);
+}

AntiAirCraftGun/src/MovementStrategy/MoveToBorder.java

@@ -0,0 +1,27 @@
+package MovementStrategy;
+
+public class MoveToBorder extends AbstractStrategy {
+    @Override
+    protected void MoveToTarget() {
+        ObjectParameters objectParameters = GetObjectParameters();
+        if (objectParameters == null) {
+            return;
+        }
+        if (objectParameters.RightBorder() < FieldWidth()) {
+            MoveRight();
+        }
+        if (objectParameters.DownBorder() < FieldHeight()) {
+            MoveDown();
+        }
+    }
+
+    @Override
+    protected boolean IsTargetDestinaion() {
+        ObjectParameters objectParameters = GetObjectParameters();
+        if (objectParameters == null) {
+            return false;
+        }
+        return objectParameters.RightBorder() <= FieldWidth() && objectParameters.RightBorder() + GetStep() >= FieldWidth() &&
+                objectParameters.DownBorder() <= FieldHeight() && objectParameters.DownBorder() + GetStep() >= FieldHeight();
+    }
+}

AntiAirCraftGun/src/MovementStrategy/MoveToCenter.java

@@ -0,0 +1,39 @@
+package MovementStrategy;
+
+public class MoveToCenter extends AbstractStrategy {
+    @Override
+    protected void MoveToTarget() {
+        ObjectParameters objectParameters = GetObjectParameters();
+        if (objectParameters == null) {
+            return;
+        }
+        int diffx = objectParameters.ObjectMiddleHorizontal() - FieldWidth() / 2;
+        if (Math.abs(diffx) > GetStep()) {
+            if (diffx > 0) {
+                MoveLeft();
+            } else {
+                MoveRight();
+            }
+        }
+        int diffy = objectParameters.ObjectMiddleVertical() - FieldHeight() / 2;
+        if (Math.abs(diffx) > GetStep()) {
+            if (diffx > 0) {
+                MoveUp();
+            } else {
+                MoveDown();
+            }
+        }
+    }
+
+    @Override
+    protected boolean IsTargetDestinaion() {
+        ObjectParameters objectParameters = GetObjectParameters();
+        if (objectParameters == null) {
+            return false;
+        }
+        return objectParameters.ObjectMiddleHorizontal() - GetStep() <= FieldWidth() / 2
+                && objectParameters.ObjectMiddleHorizontal() + GetStep() >= FieldWidth() / 2
+                && objectParameters.ObjectMiddleVertical() - GetStep() <= FieldHeight() / 2
+                && objectParameters.ObjectMiddleVertical() + GetStep() >= FieldHeight() / 2;
+    }
+}

AntiAirCraftGun/src/MovementStrategy/MoveableGun.java

@@ -0,0 +1,60 @@
+package MovementStrategy;
+
+import Drawings.DirectionType;
+import Drawings.DrawingAntiAircraftGun;
+import Drawings.DrawingGun;
+
+public class MoveableGun implements IMoveableObject{
+
+    private DrawingGun _drawingGun = null;
+
+    public MoveableGun(DrawingGun drawingGun) {
+        this._drawingGun=drawingGun;
+    }
+
+    @Override
+    public ObjectParameters GetObjectPosition() {
+        if(_drawingGun==null || _drawingGun.EntityGun()==null
+        || _drawingGun.get_startPosX()==null
+                ||_drawingGun.get_startPosY()==null){
+            return null;
+        }
+        return new ObjectParameters(
+                _drawingGun.get_startPosX(),
+                _drawingGun.get_startPosY(),
+                _drawingGun.GetWidth(),
+                _drawingGun.GetHeight()
+        );
+    }
+
+    @Override
+    public int GetStep() {
+        return (int)(_drawingGun.EntityGun().getStep()!=null ? _drawingGun.EntityGun().getStep():0);
+    }
+
+    @Override
+    public boolean TryMoveObject(MovementDirection direction) {
+        if(_drawingGun==null||_drawingGun.EntityGun()==null)return false;
+        return _drawingGun.MoveTransport(GetObjectType(direction));
+    }
+
+    private static DirectionType GetObjectType(MovementDirection direction){
+        switch (direction){
+            case Left -> {
+                return DirectionType.Left;
+            }
+            case Up -> {
+                return DirectionType.Up;
+            }
+            case Down -> {
+                return DirectionType.Down;
+            }
+            case Right -> {
+                return DirectionType.Right;
+            }
+            case null -> {
+                return DirectionType.Unknow;
+            }
+        }
+    }
+}

AntiAirCraftGun/src/MovementStrategy/MovementDirection.java

@@ -0,0 +1,23 @@
+package MovementStrategy;
+
+/**
+ * Направление перемещения
+ */
+public enum MovementDirection {
+    /**
+     * Влево
+     */
+    Left,
+    /**
+     * Вправо
+     */
+    Right,
+    /**
+     * Вверх
+     */
+    Up,
+    /**
+     * Вниз
+     */
+    Down
+}

AntiAirCraftGun/src/MovementStrategy/ObjectParameters.java

@@ -0,0 +1,69 @@
+package MovementStrategy;
+
+public class ObjectParameters {
+    /**
+     * Координата по х
+     */
+    private final Integer _x;
+    /**
+     * Координат по y
+     */
+    private final Integer _y;
+    /**
+     * Ширина объекта
+     */
+    private final Integer _width;
+    /**
+     * Высоат объекта
+     */
+    private final Integer _height;
+
+    /**
+     * Левая граница
+     * @return - х
+     */
+    public Integer LeftBorder(){return _x;}
+
+    /**
+     * Правая граница
+     * @return - х + высота
+     */
+    public Integer RightBorder() {return _x+_width;}
+
+    /**
+     * Верхняя граница
+     * @return - у
+     */
+    public Integer TopBorder(){return _y;}
+
+    /**
+     * Нижняя граница
+     * @return - y + высота
+     */
+    public Integer DownBorder(){return _y+_height;}
+
+    /**
+     * Середина обеъкта
+     * @return - середину объекта по горизонтали
+     */
+    public Integer ObjectMiddleHorizontal(){return _x+_width/2;}
+    /**
+     * Середина обеъкта
+     * @return - середину объекта по вертикали
+     */
+    public Integer ObjectMiddleVertical(){return _y+_height/2;}
+
+    /**
+     * Констурктор
+     * @param _x - x
+     * @param _y - y
+     * @param _width - ширина
+     * @param _height - высота
+     */
+    public ObjectParameters(Integer _x, Integer _y, Integer _width, Integer _height) {
+        this._x = _x;
+        this._y = _y;
+        this._width = _width;
+        this._height = _height;
+    }
+}

AntiAirCraftGun/src/MovementStrategy/StrategyStatus.java

@@ -0,0 +1,16 @@
+package MovementStrategy;
+
+public enum StrategyStatus {
+    /**
+     * Все готово к началу
+     */
+    NotInit,
+    /**
+     * В процессе
+     */
+    InProgress,
+    /**
+     * Завершено
+     */
+    Finish
+}

Main.java

@@ -1,5 +0,0 @@
-public class Main {
-    public static void main(String[] args){
-
-    }
-}