lab3 some minor fixes

.idea/.name

@@ -0,0 +1 @@
+Main.java

.idea/misc.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="true" project-jdk-name="1.8" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_19" project-jdk-name="openjdk-21" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
 </project>

src/Main.java

@@ -1,5 +1,9 @@
+import frames.FrameBattleship;
+import frames.FrameShipsCollection;
+import frames.HardFrame;
+
+import java.io.IOException;
+
 public class Main {
-    public static void main(String[] args) {
-        System.out.println("Hello world!");
-    }
+    public static void main(String[] args) throws IOException { new HardFrame(); }
 }

src/drawing_objects/BlocksNumber.java

@@ -0,0 +1,7 @@
+package drawing_objects;
+
+public enum BlocksNumber {
+    TWO,
+    FOUR,
+    SIX
+}

src/drawing_objects/DirectionType.java

@@ -0,0 +1,8 @@
+package drawing_objects;
+
+public enum DirectionType {
+    UP,
+    DOWN,
+    LEFT,
+    RIGHT
+}

src/drawing_objects/DrawingBattleship.java

@@ -0,0 +1,47 @@
+package drawing_objects;
+
+import entities.EntityBattleship;
+
+import java.awt.*;
+
+public class DrawingBattleship extends DrawingShip {
+    public DrawingBattleship(int speed, double weight, Color bodyColor, Color additionalColor, boolean turret,
+                             boolean rocketLauncher, int width, int height, int blocksType, int blocksNumber) {
+        super(speed, weight, bodyColor, width, height, blocksType, blocksNumber);
+        if (entityShip != null)
+            entityShip = new EntityBattleship(speed, weight, bodyColor, additionalColor, turret, rocketLauncher);
+    }
+    @Override
+    public void drawTransport(Graphics2D graphics2D) {
+        if (!(entityShip instanceof EntityBattleship))
+            return;
+        BasicStroke pen = new BasicStroke(2);
+        graphics2D.setStroke(pen);
+        Color additionalColor = ((EntityBattleship)entityShip).getAdditionalColor();
+        super.drawTransport(graphics2D);
+        //орудийная башня
+        if (((EntityBattleship)entityShip).getTurret()) {
+            int[] shieldX = new int[] {startPosX + 112, startPosX + 112, startPosX + 119, startPosX + 119, };
+            int[] shieldY = new int[] {startPosY + 19, startPosY + 31, startPosY + 28, startPosY + 22};
+            graphics2D.setPaint(additionalColor);
+            graphics2D.fillPolygon(shieldX, shieldY, 4);
+            graphics2D.fillRect(startPosX + 119, startPosY + 24, 12, 2);
+            graphics2D.setPaint(Color.BLACK);
+            graphics2D.drawPolygon(shieldX, shieldY, 4);
+            graphics2D.drawRect(startPosX + 119, startPosY + 24, 12, 2);
+        }
+        //ячейки для ракет
+        if (((EntityBattleship)entityShip).getRocketLauncher()) {
+            graphics2D.setPaint(additionalColor);
+            graphics2D.fillRect(startPosX + 14, startPosY + 14, 10, 10);
+            graphics2D.fillRect(startPosX + 26, startPosY + 14, 10, 10);
+            graphics2D.fillRect(startPosX + 14, startPosY + 26, 10, 10);
+            graphics2D.fillRect(startPosX + 26, startPosY + 26, 10, 10);
+            graphics2D.setPaint(Color.BLACK);
+            graphics2D.drawRect(startPosX + 14, startPosY + 14, 10, 10);
+            graphics2D.drawRect(startPosX + 26, startPosY + 14, 10, 10);
+            graphics2D.drawRect(startPosX + 14, startPosY + 26, 10, 10);
+            graphics2D.drawRect(startPosX + 26, startPosY + 26, 10, 10);
+        }
+    }
+}

src/drawing_objects/DrawingBlocks.java

@@ -0,0 +1,44 @@
+package drawing_objects;
+
+import java.awt.*;
+
+public class DrawingBlocks implements IDrawBlocks{
+    private BlocksNumber number;
+    @Override
+    public int getNumber() {
+        int x = 0;
+        if(number == BlocksNumber.TWO)
+            x = 2;
+        else if(number == BlocksNumber.FOUR)
+            x = 4;
+        else if(number == BlocksNumber.SIX)
+            x = 6;
+        return x;
+    }
+    @Override
+    public void setNumber(int x){
+        if(x <= 2)
+            number = BlocksNumber.TWO;
+        if(x == 4)
+            number = BlocksNumber.FOUR;
+        if(x >= 6)
+            number = BlocksNumber.SIX;
+    }
+    @Override
+    public int getType() {
+        return 0;
+    }
+    @Override
+    public void drawBlocks(Graphics2D graphics2D, int _startX, int _startY){
+        graphics2D.fillRect(_startX+52, _startY+12, 6, 6);
+        graphics2D.fillRect(_startX+52, _startY+32, 6, 6);
+        if (number == BlocksNumber.FOUR || number == BlocksNumber.SIX){
+            graphics2D.fillRect(_startX+62, _startY+12, 6, 6);
+            graphics2D.fillRect(_startX+62, _startY+32, 6, 6);
+            if (number == BlocksNumber.SIX){
+                graphics2D.fillRect(_startX+42, _startY+12, 6, 6);
+                graphics2D.fillRect(_startX+42, _startY+32, 6, 6);
+            }
+        }
+    }
+}

src/drawing_objects/DrawingCrossBlocks.java

@@ -0,0 +1,50 @@
+package drawing_objects;
+
+import java.awt.*;
+
+public class DrawingCrossBlocks implements IDrawBlocks{
+    private BlocksNumber number;
+    @Override
+    public int getNumber() {
+        int x = 0;
+        if(number == BlocksNumber.TWO)
+            x = 2;
+        else if(number == BlocksNumber.FOUR)
+            x = 4;
+        else if(number == BlocksNumber.SIX)
+            x = 6;
+        return x;
+    }
+    @Override
+    public void setNumber(int x){
+        if(x <= 2)
+            number = BlocksNumber.TWO;
+        if(x == 4)
+            number = BlocksNumber.FOUR;
+        if(x >= 6)
+            number = BlocksNumber.SIX;
+    }
+    @Override
+    public int getType() {
+        return 2;
+    }
+    @Override
+    public void drawBlocks(Graphics2D graphics2D, int _startX, int _startY){
+        graphics2D.fillRect(_startX+54, _startY+12, 2, 6);
+        graphics2D.fillRect(_startX+52, _startY+14, 6, 2);
+        graphics2D.fillRect(_startX+54, _startY+32, 2, 6);
+        graphics2D.fillRect(_startX+52, _startY+34, 6, 2);
+        if (number == BlocksNumber.FOUR || number == BlocksNumber.SIX){
+            graphics2D.fillRect(_startX+64, _startY+12, 2, 6);
+            graphics2D.fillRect(_startX+62, _startY+14, 6, 2);
+            graphics2D.fillRect(_startX+64, _startY+32, 2, 6);
+            graphics2D.fillRect(_startX+62, _startY+34, 6, 2);
+            if (number == BlocksNumber.SIX){
+                graphics2D.fillRect(_startX+44, _startY+12, 2, 6);
+                graphics2D.fillRect(_startX+42, _startY+14, 6, 2);
+                graphics2D.fillRect(_startX+44, _startY+32, 2, 6);
+                graphics2D.fillRect(_startX+42, _startY+34, 6, 2);
+            }
+        }
+    }
+}

src/drawing_objects/DrawingRoundBlocks.java

@@ -0,0 +1,44 @@
+package drawing_objects;
+
+import java.awt.*;
+
+public class DrawingRoundBlocks implements IDrawBlocks{
+    private BlocksNumber number;
+    @Override
+    public int getNumber() {
+        int x = 0;
+        if(number == BlocksNumber.TWO)
+            x = 2;
+        else if(number == BlocksNumber.FOUR)
+            x = 4;
+        else if(number == BlocksNumber.SIX)
+            x = 6;
+        return x;
+    }
+    @Override
+    public void setNumber(int x){
+        if(x <= 2)
+            number = BlocksNumber.TWO;
+        if(x == 4)
+            number = BlocksNumber.FOUR;
+        if(x >= 6)
+            number = BlocksNumber.SIX;
+    }
+    @Override
+    public int getType() {
+        return 1;
+    }
+    @Override
+    public void drawBlocks(Graphics2D graphics2D, int _startX, int _startY){
+        graphics2D.fillOval(_startX+50, _startY+11, 8, 8);
+        graphics2D.fillOval(_startX+50, _startY+31, 8, 8);
+        if (number == BlocksNumber.FOUR || number == BlocksNumber.SIX){
+            graphics2D.fillOval(_startX+60, _startY+11, 8, 8);
+            graphics2D.fillOval(_startX+60, _startY+31, 8, 8);
+            if (number == BlocksNumber.SIX){
+                graphics2D.fillOval(_startX+40, _startY+11, 8, 8);
+                graphics2D.fillOval(_startX+40, _startY+31, 8, 8);
+            }
+        }
+    }
+}

src/drawing_objects/DrawingShip.java

@@ -0,0 +1,118 @@
+package drawing_objects;
+
+import entities.EntityShip;
+import movement_strategy.*;
+
+import java.awt.*;
+
+public class DrawingShip {
+    protected EntityShip entityShip;
+    public EntityShip getEntityShip(){return entityShip;}
+    private IDrawBlocks drawingBlocks;
+    private int pictureWidth;
+    private int pictureHeight;
+    protected int startPosX;
+    public int getPosX() {return startPosX;}
+    protected int startPosY;
+    public int getPosY() {return startPosY;}
+    private int shipWidth = 150;
+    public int getWidth() {return shipWidth;}
+    private int shipHeight = 50;
+    public int getHeight() {return shipHeight;}
+    public IMoveableObject getMoveableObject() {return new DrawingObjectShip(this);}
+    public DrawingShip(int speed, double weight, Color bodyColor, int width, int height, int blocksType, int blocksNumber) {
+        if (width < shipWidth || height < shipHeight)
+            return;
+        pictureWidth = width;
+        pictureHeight = height;
+        entityShip = new EntityShip(speed, weight, bodyColor);
+        switch (blocksType) {
+            case 1 -> drawingBlocks = new DrawingRoundBlocks();
+            case 2 -> drawingBlocks = new DrawingCrossBlocks();
+            default -> drawingBlocks = new DrawingBlocks();
+        }
+        drawingBlocks.setNumber(blocksNumber);
+    }
+    protected DrawingShip(int speed, double weight, Color bodyColor, int width, int height, int shipWidth,
+                          int shipHeight, int blocksType, int blocksNumber) {
+        if (width < shipWidth || height < shipHeight)
+            return;
+        pictureWidth = width;
+        pictureHeight = height;
+        this.shipWidth = shipWidth;
+        this.shipHeight = shipHeight;
+        entityShip = new EntityShip(speed, weight, bodyColor);
+        switch (blocksType) {
+            case 1 -> drawingBlocks = new DrawingRoundBlocks();
+            case 2 -> drawingBlocks = new DrawingCrossBlocks();
+            default -> drawingBlocks = new DrawingBlocks();
+        }
+        drawingBlocks.setNumber(blocksNumber);
+    }
+    public void setPosition(int x, int y) {
+        if (x < 0 || y < 0 || x + shipWidth > pictureWidth || y + shipHeight > pictureHeight) {
+            x = 0;
+            y = 0;
+        }
+        startPosX = x;
+        startPosY = y;
+    }
+    public void drawTransport(Graphics2D graphics2D) {
+        if (entityShip == null) {
+            return;
+        }
+        BasicStroke pen = new BasicStroke(2);
+        graphics2D.setStroke(pen);
+        Color bodyColor = entityShip.getBodyColor();
+        //корпус
+        int[] hullX = new int[] {startPosX + 5, startPosX + 100, startPosX + 150, startPosX + 100, startPosX + 5};
+        int[] hullY = new int[] {startPosY, startPosY, startPosY + 25, startPosY + 50, startPosY + 50};
+        graphics2D.setPaint(bodyColor);
+        graphics2D.fillPolygon(hullX, hullY, 5);
+        graphics2D.setPaint(Color.BLACK);
+        graphics2D.drawPolygon(hullX, hullY, 5);
+        graphics2D.fillRect(startPosX, startPosY + 6, 5, 13);
+        graphics2D.fillRect(startPosX, startPosY + 31, 5, 13);
+        //надстройки
+        graphics2D.setPaint(Color.DARK_GRAY);
+        graphics2D.fillRect(startPosX + 40, startPosY + 20, 30, 10);
+        graphics2D.fillRect(startPosX + 70, startPosY + 12, 18, 26);
+        graphics2D.fillOval(startPosX + 94, startPosY + 19, 12, 12);
+        graphics2D.setPaint(Color.BLACK);
+        graphics2D.drawRect(startPosX + 40, startPosY + 20, 30, 10);
+        graphics2D.drawRect(startPosX + 70, startPosY + 12, 18, 26);
+        graphics2D.drawOval(startPosX + 94, startPosY + 19, 12, 12);
+        //блоки
+        if (drawingBlocks != null){
+            drawingBlocks.drawBlocks(graphics2D, startPosX, startPosY);
+        }
+    }
+    public boolean canMove(DirectionType direction) {
+        if (entityShip == null) {
+            return false;
+        }
+        return switch (direction) {
+            case LEFT -> startPosX - entityShip.step.get().intValue() > 0;
+            case UP -> startPosY - entityShip.step.get().intValue() > 0;
+            case RIGHT -> startPosX + entityShip.step.get().intValue() + shipWidth < pictureWidth;
+            case DOWN -> startPosY + entityShip.step.get().intValue() + shipHeight < pictureHeight;
+            default -> false;
+        };
+    }
+    public void moveTransport(DirectionType direction) {
+        if (!canMove(direction) || entityShip == null)
+        {
+            return;
+        }
+        switch (direction) {
+            //влево
+            case LEFT -> startPosX -= entityShip.step.get().intValue();
+            //вверх
+            case UP -> startPosY -= entityShip.step.get().intValue();
+            // вправо
+            case RIGHT -> startPosX += entityShip.step.get().intValue();
+            //вниз
+            case DOWN -> startPosY += entityShip.step.get().intValue();
+        }
+    }
+}

src/drawing_objects/IDrawBlocks.java

@@ -0,0 +1,10 @@
+package drawing_objects;
+
+import java.awt.*;
+
+public interface IDrawBlocks {
+    int getNumber();
+    void setNumber(int x);
+    int getType();
+    void drawBlocks(Graphics2D graphics2D, int _startX, int _startY);
+}

src/entities/EntityBattleship.java

@@ -0,0 +1,20 @@
+package entities;
+
+import java.awt.*;
+
+public class EntityBattleship extends EntityShip {
+    private Color additionalColor;
+    public Color getAdditionalColor(){
+        return additionalColor;
+    }
+    private boolean turret;
+    public boolean getTurret() {return turret;}
+    private boolean rocketLauncher;
+    public boolean getRocketLauncher() {return rocketLauncher;}
+    public EntityBattleship(int speed, double weight, Color bodyColor, Color additionalColor, boolean turret, boolean rocketLauncher) {
+        super(speed, weight, bodyColor);
+        this.additionalColor = additionalColor;
+        this.turret = turret;
+        this.rocketLauncher = rocketLauncher;
+    }
+}

src/entities/EntityShip.java

@@ -0,0 +1,25 @@
+package entities;
+
+import java.awt.*;
+import java.util.function.Supplier;
+
+public class EntityShip{
+    private int speed;
+    public int getSpeed(){
+        return speed;
+    }
+    private double weight;
+    public double getWeight(){
+        return weight;
+    }
+    private Color bodyColor;
+    public Color getBodyColor(){
+        return bodyColor;
+    }
+    public Supplier<Double> step = () -> (double) speed * 100 / weight;
+    public EntityShip(int speed, double weight, Color bodyColor){
+        this.speed = speed;
+        this.weight = weight;
+        this.bodyColor = bodyColor;
+    }
+}

src/frames/FrameBattleship.java

@@ -0,0 +1,187 @@
+package frames;
+
+import drawing_objects.DirectionType;
+import drawing_objects.DrawingBattleship;
+import drawing_objects.DrawingShip;
+import movement_strategy.AbstractStrategy;
+import movement_strategy.MoveToCenter;
+import movement_strategy.MoveToBorder;
+import movement_strategy.DrawingObjectShip;
+import movement_strategy.Status;
+
+import javax.imageio.ImageIO;
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.io.File;
+import java.io.IOException;
+import java.util.Random;
+
+public class FrameBattleship extends JFrame {
+    private DrawingShip drawingShip;
+    private AbstractStrategy abstractStrategy;
+    public JButton selectShipButton;
+    private DrawingShip selectedShip;
+    public DrawingShip getSelectedShip() {return selectedShip;}
+    private JComboBox<String> comboBoxStrategy;
+    private JComponent pictureBoxBattleship;
+    public FrameBattleship() throws IOException {
+        super("Линкор");
+        setSize(new Dimension(900,500));
+        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        //components initialisation
+        pictureBoxBattleship = new JComponent(){
+            public void paintComponent(Graphics graphics){
+                super.paintComponent(graphics);
+                Graphics2D graphics2D = (Graphics2D) graphics;
+                if (drawingShip != null) drawingShip.drawTransport(graphics2D);
+                super.repaint();
+            }
+        };
+        pictureBoxBattleship.setBounds( 0, 0, getContentPane().getWidth(), getContentPane().getHeight());
+        comboBoxStrategy = new JComboBox<>(new String[]{"к центру", "к границе"});
+        JButton stepButton = new JButton("Шаг");
+        JButton createShipButton = new JButton("Создать корабль");
+        JButton createBattleshipButton = new JButton("Создать линкор");
+        selectShipButton = new JButton("Выбрать корабль");
+        JButton rightButton = new JButton(new ImageIcon(ImageIO.read(new File("images/right.png"))));
+        rightButton.setPreferredSize(new Dimension(30,30));
+        JButton leftButton = new JButton(new ImageIcon(ImageIO.read(new File("images/left.png"))));
+        leftButton.setPreferredSize(new Dimension(30,30));
+        JButton upButton = new JButton(new ImageIcon(ImageIO.read(new File("images/up.png"))));
+        upButton.setPreferredSize(new Dimension(30,30));
+        JButton downButton = new JButton(new ImageIcon(ImageIO.read(new File("images/down.png"))));
+        downButton.setPreferredSize(new Dimension(30,30));
+        //ActionListeners and ActionCommand addition
+        createShipButton.addActionListener(e -> buttonCreateShipClick());
+        createBattleshipButton.addActionListener(e -> buttonCreateBattleshipClick());
+        stepButton.addActionListener(e -> buttonStepClick());
+        rightButton.setActionCommand("right");
+        rightButton.addActionListener(this::buttonMoveClick);
+        leftButton.setActionCommand("left");
+        leftButton.addActionListener(this::buttonMoveClick);
+        upButton.setActionCommand("up");
+        upButton.addActionListener(this::buttonMoveClick);
+        downButton.setActionCommand("down");
+        downButton.addActionListener(this::buttonMoveClick);
+        //panels and constraints initialisation
+        JPanel panelBattleship = new JPanel(new BorderLayout());
+        JPanel rightPanel = new JPanel(new BorderLayout());
+        JPanel leftPanel = new JPanel(new BorderLayout());
+        JPanel createPanel = new JPanel(new GridBagLayout());
+        JPanel movementPanel = new JPanel(new GridBagLayout());
+        GridBagConstraints constraints = new GridBagConstraints();
+        constraints.insets.left = constraints.insets.top = constraints.insets.bottom = constraints.insets.right = 2;
+        //addition to createPanel
+        constraints.gridx = 0;
+        constraints.gridy = 0;
+        createPanel.add(createShipButton, constraints);
+        constraints.gridx = 1;
+        constraints.gridy = 0;
+        createPanel.add(createBattleshipButton, constraints);
+        constraints.gridx = 2;
+        constraints.gridy = 0;
+        createPanel.add(selectShipButton, constraints);
+        //addition to movementPanel
+        constraints.gridx = 2;
+        constraints.gridy = 1;
+        movementPanel.add(rightButton, constraints);
+        constraints.gridx = 0;
+        constraints.gridy = 1;
+        movementPanel.add(leftButton, constraints);
+        constraints.gridx = 1;
+        constraints.gridy = 0;
+        movementPanel.add(upButton, constraints);
+        constraints.gridx = 1;
+        constraints.gridy = 1;
+        movementPanel.add(downButton, constraints);
+        //addition to stepPanel
+        JPanel stepPanel = new JPanel(new GridBagLayout());
+        constraints.gridx = 0;
+        constraints.gridy = 0;
+        stepPanel.add(comboBoxStrategy, constraints);
+        constraints.gridx = 0;
+        constraints.gridy = 1;
+        stepPanel.add(stepButton, constraints);
+        //addition to frame
+        setLayout(new BorderLayout());
+        add(pictureBoxBattleship);
+        rightPanel.add(movementPanel, BorderLayout.SOUTH);
+        rightPanel.add(stepPanel, BorderLayout.NORTH);
+        leftPanel.add(createPanel, BorderLayout.SOUTH);
+        panelBattleship.add(rightPanel, BorderLayout.EAST);
+        panelBattleship.add(leftPanel, BorderLayout.WEST);
+        add(panelBattleship,BorderLayout.CENTER);
+        setVisible(true);
+    }
+    private void buttonCreateBattleshipClick() {
+        Random random = new Random();
+        pictureBoxBattleship.setBounds(0,0,getContentPane().getWidth(),getContentPane().getHeight());
+        Color bodyColor = JColorChooser.showDialog(this,"Выбор базового цвета", null);
+        Color additColor = JColorChooser.showDialog(this,"Выбор дополнительного цвета", null);
+        drawingShip = new DrawingBattleship(random.nextInt(200) + 100, random.nextInt(2000) + 1000, bodyColor, additColor, random.nextBoolean(),
+            random.nextBoolean(), pictureBoxBattleship.getWidth(), pictureBoxBattleship.getHeight(), random.nextInt(3),(random.nextInt(3)+1)*2);
+        drawingShip.setPosition(random.nextInt(90) + 10, random.nextInt(90) + 10);
+        draw();
+    }
+    private void buttonCreateShipClick(){
+        Random random = new Random();
+        pictureBoxBattleship.setBounds(0,0,getContentPane().getWidth(),getContentPane().getHeight());
+        Color bodyColor = JColorChooser.showDialog(this,"Выбор цвета", null);
+        drawingShip = new DrawingShip(random.nextInt(200) + 100, random.nextInt(2000) + 1000, bodyColor, pictureBoxBattleship.getWidth(),
+                pictureBoxBattleship.getHeight(), random.nextInt(3),(random.nextInt(3)+1)*2);
+        drawingShip.setPosition(random.nextInt(90) + 10, random.nextInt(90) + 10);
+        draw();
+    }
+    private void buttonStepClick(){
+        if (drawingShip == null) {
+            return;
+        }
+        if (comboBoxStrategy.isEnabled()) {
+            switch (comboBoxStrategy.getSelectedIndex()) {
+                case 0 -> abstractStrategy = new MoveToCenter();
+                case 1 -> abstractStrategy = new MoveToBorder();
+                default -> abstractStrategy = null;
+            }
+            if (abstractStrategy == null) {
+                return;
+            }
+            abstractStrategy.setData(new DrawingObjectShip(drawingShip), pictureBoxBattleship.getWidth(), pictureBoxBattleship.getHeight());
+            comboBoxStrategy.setEnabled(false);
+        }
+        if (abstractStrategy == null) {
+            return;
+        }
+        abstractStrategy.makeStep();
+        draw();
+        if (abstractStrategy.getStatus() == Status.FINISH)
+        {
+            comboBoxStrategy.setEnabled(true);
+            abstractStrategy = null;
+        }
+    }
+    private void buttonMoveClick(ActionEvent event) {
+        if(drawingShip == null || drawingShip.getEntityShip() == null)
+            return;
+        switch (event.getActionCommand()) {
+            case "left" -> drawingShip.moveTransport(DirectionType.LEFT);
+            case "right" -> drawingShip.moveTransport(DirectionType.RIGHT);
+            case "up" -> drawingShip.moveTransport(DirectionType.UP);
+            case "down" -> drawingShip.moveTransport(DirectionType.DOWN);
+        }
+        draw();
+    }
+    private void draw() {
+        if (drawingShip == null)
+        {
+            return;
+        }
+        pictureBoxBattleship.repaint();
+    }
+    public void select(){
+        if (drawingShip == null) {
+            return;
+        }
+        selectedShip = drawingShip;
+    }
+}

src/frames/FrameShipsCollection.java

@@ -0,0 +1,95 @@
+package frames;
+
+import javax.swing.*;
+import java.awt.*;
+import java.io.IOException;
+
+import drawing_objects.DrawingShip;
+import generics.ShipsGenericCollection;
+import movement_strategy.DrawingObjectShip;
+
+public class FrameShipsCollection extends JFrame {
+    private ShipsGenericCollection<DrawingShip, DrawingObjectShip> ships;
+    JComponent pictureBoxCollection;
+    TextField textFieldNumber;
+    public FrameShipsCollection(){
+        super("Набор кораблей");
+        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        createGui();
+        ships = new ShipsGenericCollection<>(pictureBoxCollection.getWidth(), pictureBoxCollection.getHeight());
+        setVisible(true);
+    }
+    private void createGui(){
+        //components initialisation
+        pictureBoxCollection = new JComponent(){
+            public void paintComponent(Graphics graphics){
+                super.paintComponent(graphics);
+                Graphics2D graphics2D = (Graphics2D) graphics;
+                if (ships != null) ships.showShips(graphics2D);
+                super.repaint();
+            }
+        };
+        pictureBoxCollection.setPreferredSize(new Dimension(700, 450));
+        JButton buttonAddShip = new JButton("Добавить корабль");
+        textFieldNumber = new TextField();
+        JButton buttonRemoveShip = new JButton("Удалить корабль");
+        JButton buttonRefreshCollection = new JButton("Обновить коллекцию");
+        //ActionListeners and ActionCommand addition
+        buttonAddShip.addActionListener(e -> buttonAddShipClick());
+        buttonRemoveShip.addActionListener(e -> buttonRemoveShipClick());
+        buttonRefreshCollection.addActionListener(e -> buttonRefreshCollectionClick());
+        //addition to frame
+        JPanel panelCollection = new JPanel(new GridBagLayout());
+        GridBagConstraints constraints = new GridBagConstraints();
+        constraints.insets.left = constraints.insets.right = 2;
+        constraints.insets.top = constraints.insets.bottom = 25;
+        constraints.fill = GridBagConstraints.BOTH;
+        constraints.gridx = 0;
+        constraints.gridy = 0;
+        panelCollection.add(buttonAddShip, constraints);
+        constraints.gridx = 0;
+        constraints.gridy = 1;
+        panelCollection.add(textFieldNumber, constraints);
+        constraints.gridx = 0;
+        constraints.gridy = 2;
+        panelCollection.add(buttonRemoveShip, constraints);
+        constraints.gridx = 0;
+        constraints.gridy = 3;
+        panelCollection.add(buttonRefreshCollection, constraints);
+        setLayout(new BorderLayout());
+        add(panelCollection, BorderLayout.EAST);
+        add(pictureBoxCollection, BorderLayout.CENTER);
+        pack();
+    }
+    private void buttonAddShipClick() {
+        FrameBattleship form;
+        try {
+            form = new FrameBattleship();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+        form.selectShipButton.addActionListener(e->{
+            form.select();
+            DrawingShip ship = form.getSelectedShip();
+            form.dispose();
+            if (ships.insert(ship)) {
+                JOptionPane.showMessageDialog(this, "Объект добавлен");
+                pictureBoxCollection.repaint();
+            }
+            else {
+                JOptionPane.showMessageDialog(this, "Не удалось добавить объект");
+            }
+        });
+    }
+    private void buttonRemoveShipClick(){
+        int pos = Integer.parseInt(textFieldNumber.getText());
+        if (ships.remove(pos)){
+            JOptionPane.showMessageDialog(this, "Объект удален");
+            pictureBoxCollection.repaint();
+        }
+        else{
+            JOptionPane.showMessageDialog(this, "Не удалось удалить объект");
+        }
+    }
+    private void buttonRefreshCollectionClick(){pictureBoxCollection.repaint();}
+}

src/frames/HardFrame.java

@@ -0,0 +1,51 @@
+package frames;
+
+import drawing_objects.DrawingShip;
+import drawing_objects.IDrawBlocks;
+import entities.EntityShip;
+import generics.HardGeneric;
+
+import javax.swing.*;
+import java.awt.*;
+
+public class HardFrame extends JFrame {
+    HardGeneric<EntityShip, IDrawBlocks> generic;
+    DrawingShip drawing;
+    private final JComponent pictureBox;
+    private final int pictureBoxWidth = 200;
+    private final int pictureBoxHeight = 100;
+    public HardFrame(){
+        setLocationRelativeTo(null);
+        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
+        pictureBox = new JComponent(){
+            public void paintComponent(Graphics graphics){
+                super.paintComponent(graphics);
+                Graphics2D graphics2D = (Graphics2D) graphics;
+                if (drawing != null) drawing.drawTransport(graphics2D);
+                super.repaint();
+            }
+        };
+        pictureBox.setPreferredSize(new Dimension(pictureBoxWidth, pictureBoxHeight));
+        JButton buttonMakeObject = new JButton("Создать новый объект");
+        generic = new HardGeneric<>(10, 25, pictureBoxWidth, pictureBoxHeight);
+        boolean check;
+        do{
+            check = generic.insertShip(generic.makeRandomShip());
+        }while(check);
+        do {
+            check = generic.insertBlock(generic.makeRandomBlock());
+        }while(check);
+        buttonMakeObject.addActionListener(e -> {
+                    DrawingShip drawingShip = generic.makeObject();
+                    drawingShip.setPosition(pictureBoxWidth / 2 - drawingShip.getWidth()/2, pictureBoxHeight / 2 - drawingShip.getHeight()/2);
+                    drawing = drawingShip;
+                    draw();
+                });
+        setLayout(new BorderLayout());
+        add(pictureBox, BorderLayout.CENTER);
+        add(buttonMakeObject, BorderLayout.SOUTH);
+        pack();
+        setVisible(true);
+    }
+    void draw(){pictureBox.repaint();}
+}

src/generics/HardGeneric.java

@@ -0,0 +1,77 @@
+package generics;
+
+import drawing_objects.*;
+import entities.EntityBattleship;
+import entities.EntityShip;
+
+import java.awt.*;
+import java.util.Random;
+
+public class HardGeneric<T extends EntityShip, U extends IDrawBlocks>{
+    T[] ships;
+    U[] blocks;
+    private int shipsNumber;
+    private int blocksNumber;
+    private final int PICTURE_WIDTH;
+    private final int PICTURE_HEIGHT;
+    public HardGeneric(int shipsCount, int blocksCount, int width, int height){
+        shipsNumber = 0;
+        blocksNumber = 0;
+        ships = (T[]) new EntityShip[shipsCount];
+        blocks = (U[]) new IDrawBlocks[blocksCount];
+        PICTURE_HEIGHT = height;
+        PICTURE_WIDTH = width;
+    }
+    public boolean insertShip(T entityShip){
+        if(ships[ships.length-1] != null)
+            return false;
+        for(int i = shipsNumber -1; i>= 0; i--) {
+            ships[i + 1] = ships[i];
+        }
+        shipsNumber++;
+        ships[0] = entityShip;
+        return true;
+    }
+    public boolean insertBlock(U block){
+        if(blocks[blocks.length-1] != null)
+            return false;
+        for(int i = blocksNumber -1; i>= 0; i--) {
+            blocks[i + 1] = blocks[i];
+        }
+        blocksNumber++;
+        blocks[0] = block;
+        return true;
+    }
+    public DrawingShip makeObject(){
+        Random rand = new Random();
+        EntityShip entity = ships[rand.nextInt(0, shipsNumber)];
+        IDrawBlocks block = blocks[rand.nextInt(0, blocksNumber)];
+        if (entity instanceof EntityBattleship)
+            return new DrawingBattleship(entity.getSpeed(), entity.getWeight(), entity.getBodyColor(), ((EntityBattleship) entity).getAdditionalColor(),
+            ((EntityBattleship) entity).getTurret(), ((EntityBattleship) entity).getRocketLauncher(), PICTURE_WIDTH, PICTURE_HEIGHT, block.getType(), block.getNumber());
+        return new DrawingShip(entity.getSpeed(), entity.getWeight(), entity.getBodyColor(), PICTURE_WIDTH, PICTURE_HEIGHT, block.getType(), block.getNumber());
+    }
+    public EntityShip makeRandomShip(){
+        Random random = new Random();
+        if (random.nextInt(2) == 0) {
+            return new EntityShip(random.nextInt(100, 300), random.nextDouble(1000, 3000),
+                    new Color(random.nextInt(256), random.nextInt(256), random.nextInt(256)));
+        } else {
+            return new EntityBattleship(random.nextInt(100, 300), random.nextDouble(1000, 3000),
+                    new Color(random.nextInt(256), random.nextInt(256), random.nextInt(256)),
+                    new Color(random.nextInt(256), random.nextInt(256), random.nextInt(256)),
+                    random.nextBoolean(), random.nextBoolean());
+        }
+    }
+    public IDrawBlocks makeRandomBlock(){
+        Random random = new Random();
+        IDrawBlocks block;
+        switch (random.nextInt(3)){
+            case 1 -> block = new DrawingRoundBlocks();
+            case 2 -> block = new DrawingCrossBlocks();
+            default -> block = new DrawingBlocks();
+        }
+        block.setNumber((random.nextInt(3) + 1) * 2);
+        return block;
+    }
+}

src/generics/SetGeneric.java

@@ -0,0 +1,41 @@
+package generics;
+
+import java.lang.reflect.Array;
+
+public class SetGeneric<T extends Object>{
+    private final T[] places;
+    public int getCount() {return places.length;}
+    public SetGeneric(int count, Class<T> type){
+        places = (T[]) Array.newInstance(type, count);
+    }
+    public boolean insert(T ship){
+        return insert(ship, 0);
+    }
+    public boolean insert(T ship, int position){
+        if (!(position >= 0 && position < places.length))
+            return false;
+        if (places[position] != null)
+        {
+            int ind = position;
+            while (ind < places.length && places[ind] != null)
+                ind++;
+            if (ind == places.length)
+                return false;
+            for (int i = ind - 1; i >= position; i--)
+                places[i + 1] = places[i];
+        }
+        places[position] = ship;
+        return true;
+    }
+    public boolean remove(int position){
+        if(!(position >= 0 && position < getCount()))
+            return false;
+        places[position] = null;
+        return true;
+    }
+    public T get(int position){
+        if(!(position >= 0 && position < getCount()))
+            return null;
+        return places[position];
+    }
+}

src/generics/ShipsGenericCollection.java

@@ -0,0 +1,64 @@
+package generics;
+
+import drawing_objects.*;
+import movement_strategy.*;
+
+import java.awt.*;
+
+public class ShipsGenericCollection<T extends DrawingShip, U extends IMoveableObject>{
+    private int pictureWidth;
+    private int pictureHeight;
+    private final int placeSizeWidth = 220;
+    private final int placeSizeHeight = 60;
+    private SetGeneric<T> collection;
+    public ShipsGenericCollection(int picWidth, int picHeight){
+        int width = picWidth / placeSizeWidth;
+        int height = picHeight / placeSizeHeight;
+        pictureWidth = picWidth;
+        pictureHeight = picHeight;
+        collection = new SetGeneric<T>(width * height, (Class<T>) DrawingShip.class);
+    }
+    public boolean insert ( T obj) {
+        if (obj != null)
+            return collection.insert(obj);
+        return false;
+    }
+    public boolean remove (int pos){
+        T obj = collection.get(pos);
+        if (obj != null)
+            return collection.remove(pos);
+        return false;
+    }
+    public U getU(int pos){
+        if(collection.get(pos) == null)
+            return null;
+        return (U)collection.get(pos).getMoveableObject();
+    }
+    public void showShips(Graphics2D graphics2D){
+        DrawBackground(graphics2D);
+        DrawObjects(graphics2D);
+    }
+    private void DrawBackground(Graphics2D g){
+        BasicStroke stroke = new BasicStroke(3);
+        g.setStroke(stroke);
+        for (int i = 0; i < pictureWidth / placeSizeWidth; i++){
+            for (int j = 0; j < pictureHeight / placeSizeHeight + 1; ++j){
+                g.drawLine(i * placeSizeWidth, j * placeSizeHeight, i *
+                        placeSizeWidth + placeSizeWidth / 2, j * placeSizeHeight);
+            }
+            g.drawLine(i * placeSizeWidth, 0, i * placeSizeWidth,
+                    pictureHeight / placeSizeHeight * placeSizeHeight);
+        }
+    }
+    private void DrawObjects(Graphics2D g){
+        for (int i = 0; i < collection.getCount(); i++){
+            DrawingShip ship = collection.get(i);
+            if (ship != null)
+            {
+                int inRow = pictureWidth / placeSizeWidth;
+                ship.setPosition(i % inRow * placeSizeWidth, (collection.getCount() / inRow - 1 - i / inRow) * placeSizeHeight + 5);
+                ship.drawTransport(g);
+            }
+        }
+    }
+}

src/movement_strategy/AbstractStrategy.java

@@ -0,0 +1,64 @@
+package movement_strategy;
+
+import drawing_objects.DirectionType;
+
+public abstract class AbstractStrategy {
+    private IMoveableObject moveableObject;
+    private Status state = Status.NOT_INIT;
+    private int fieldWidth;
+    protected int getFieldWidth(){return fieldWidth;}
+    private int fieldHeight;
+    protected int getFieldHeight(){return fieldHeight;}
+    public Status getStatus() {return state;}
+    public void setData(IMoveableObject moveableObject, int width, int height){
+        if (moveableObject == null)
+        {
+            state = Status.NOT_INIT;
+            return;
+        }
+        state = Status.IN_PROGRESS;
+        this.moveableObject = moveableObject;
+        fieldWidth = width;
+        fieldHeight = height;
+    }
+    public void makeStep(){
+        if (state != Status.IN_PROGRESS) {
+            return;
+        }
+        if (isTargetDestination()) {
+            state = Status.FINISH;
+            return;
+        }
+        moveToTarget();
+    }
+    protected boolean moveLeft() {return moveTo(DirectionType.LEFT);}
+    protected boolean moveRight() {return moveTo(DirectionType.RIGHT);}
+    protected boolean moveUp() {return moveTo(DirectionType.UP);}
+    protected boolean moveDown() {return moveTo(DirectionType.DOWN);}
+    protected ObjectParameters getObjectParameters(){
+        if(moveableObject != null)
+            return moveableObject.getObjectPosition();
+        else return null;
+    }
+    protected Integer getStep() {
+        if (state != Status.IN_PROGRESS)
+        {
+            return null;
+        }
+        return moveableObject.getStep();
+    }
+    protected abstract void moveToTarget();
+    protected abstract boolean isTargetDestination();
+    private boolean moveTo(DirectionType directionType) {
+        if (state != Status.IN_PROGRESS)
+        {
+            return false;
+        }
+        if (moveableObject.checkCanMove(directionType))
+        {
+            moveableObject.moveObject(directionType);
+            return true;
+        }
+        return false;
+    }
+}

src/movement_strategy/DrawingObjectShip.java

@@ -0,0 +1,36 @@
+package movement_strategy;
+
+import drawing_objects.DrawingShip;
+import drawing_objects.DirectionType;
+
+public class DrawingObjectShip implements IMoveableObject{
+    private final DrawingShip drawingShip;
+    public DrawingObjectShip(DrawingShip drawingShip){
+        this.drawingShip = drawingShip;
+    }
+    @Override
+    public ObjectParameters getObjectPosition(){
+        if(drawingShip == null || drawingShip.getEntityShip() == null)
+            return null;
+        return new ObjectParameters(drawingShip.getPosX(), drawingShip.getPosY(),
+                drawingShip.getWidth(), drawingShip.getHeight());
+    }
+    @Override
+    public int getStep(){
+        if(drawingShip.getEntityShip() == null)
+            return 0;
+        return drawingShip.getEntityShip().step.get().intValue();
+    }
+    @Override
+    public boolean checkCanMove(DirectionType direction){
+        if(drawingShip == null)
+            return false;
+        return drawingShip.canMove(direction);
+    }
+    @Override
+    public void moveObject(DirectionType direction){
+        if(drawingShip == null)
+            return;
+        drawingShip.moveTransport(direction);
+    }
+}

src/movement_strategy/IMoveableObject.java

@@ -0,0 +1,10 @@
+package movement_strategy;
+
+import drawing_objects.DirectionType;
+
+public interface IMoveableObject {
+    ObjectParameters getObjectPosition();
+    int getStep();
+    boolean checkCanMove(DirectionType direction);
+    void moveObject(DirectionType direction);
+}

src/movement_strategy/MoveToBorder.java

@@ -0,0 +1,32 @@
+package movement_strategy;
+
+public class MoveToBorder extends AbstractStrategy {
+    @Override
+    protected boolean isTargetDestination() {
+        var objParams = getObjectParameters();
+        if (objParams == null) {
+            return false;
+        }
+        return objParams.getRightBorder() + getStep() >= getFieldWidth() &&
+               objParams.getDownBorder() + getStep() >= getFieldHeight();
+    }
+    @Override
+    protected void moveToTarget() {
+        var objParams = getObjectParameters();
+        if (objParams == null) {
+            return;
+        }
+        var diffX = objParams.getRightBorder() - getFieldWidth();
+        if (Math.abs(diffX) >= getStep()) {
+            if (diffX < 0) {
+                moveRight();
+            }
+        }
+        var diffY = objParams.getDownBorder() - getFieldHeight();
+        if (Math.abs(diffY) >= getStep()) {
+            if (diffY < 0) {
+                moveDown();
+            }
+        }
+    }
+}

src/movement_strategy/MoveToCenter.java

@@ -0,0 +1,39 @@
+package movement_strategy;
+
+public class MoveToCenter extends AbstractStrategy{
+    @Override
+    protected boolean isTargetDestination(){
+        var objParams = getObjectParameters();
+        if(objParams == null)
+            return false;
+        return objParams.getObjectMiddleHorizontal() <= getFieldWidth() / 2 &&
+               objParams.getObjectMiddleHorizontal() + getStep() >= getFieldWidth() / 2 &&
+               objParams.getObjectMiddleVertical() <= getFieldHeight() / 2 &&
+               objParams.getObjectMiddleVertical() + getStep() >= getFieldHeight() / 2;
+    }
+    @Override
+    protected  void moveToTarget() {
+        ObjectParameters objParams = getObjectParameters();
+        if (objParams == null) {
+            return;
+        }
+        var diffX = objParams.getObjectMiddleHorizontal() - getFieldWidth() / 2;
+        if (Math.abs(diffX) > getStep()) {
+            if (diffX > 0) {
+                moveLeft();
+            }
+            else {
+                moveRight();
+            }
+        }
+        var diffY = objParams.getObjectMiddleVertical() - getFieldHeight() / 2;
+        if (Math.abs(diffY) > getStep()) {
+            if (diffY > 0) {
+                moveUp();
+            }
+            else {
+                moveDown();
+            }
+        }
+    }
+}

src/movement_strategy/ObjectParameters.java

@@ -0,0 +1,20 @@
+package movement_strategy;
+
+public class ObjectParameters {
+    private final int POS_X;
+    private final int POS_Y;
+    private final int WIDTH;
+    private final int HEIGHT;
+    public int getLeftBorder() {return POS_X;}
+    public int getTopBorder() {return POS_Y;}
+    public int getRightBorder() {return POS_X + WIDTH;}
+    public int getDownBorder() {return POS_Y + HEIGHT;}
+    public int getObjectMiddleHorizontal() {return POS_X + this.WIDTH / 2;}
+    public int getObjectMiddleVertical() {return POS_Y + this.HEIGHT / 2;}
+    public ObjectParameters(int x, int y, int width, int height) {
+        POS_X = x;
+        POS_Y = y;
+        WIDTH = width;
+        HEIGHT = height;
+    }
+}

src/movement_strategy/Status.java

@@ -0,0 +1,7 @@
+package movement_strategy;
+
+public enum Status {
+    NOT_INIT,
+    IN_PROGRESS,
+    FINISH
+}