Лаба 2

src/LinerHard/Direction.java

@@ -0,0 +1,16 @@
+package LinerHard;
+
+public enum Direction {
+    Up(1),
+    Down(2),
+    Left (3),
+    Right(4)
+    ;
+    private final int Direct;
+    Direction(int i) {
+        this.Direct=i;
+    }
+    public int GetDirect() {
+        return Direct;
+    }
+}

src/LinerHard/DrawingObjects/DrawingBigLiner.java

@@ -0,0 +1,47 @@
+package LinerHard.DrawingObjects;
+
+import LinerHard.ExtraThings.AdditionalEnum;
+import LinerHard.Entities.*;
+import LinerHard.ExtraThings.*;
+
+import java.awt.*;
+import java.util.Random;
+public class DrawingBigLiner extends DrawingLiner {
+    public DrawingBigLiner(int speed, float weight, Color bottomColor, int width, int height,Color bodyColor, boolean swimmingPool, boolean deck,int deckNum) {
+        super(speed,weight,bottomColor,width,height,deckNum);
+        if (width < _linerWidth || height < _linerHeight) {
+            return;
+        }
+        if(EntityLiner != null) {
+            EntityLiner = new EntityBigLiner(speed, weight, bottomColor, bodyColor, swimmingPool, deck);
+        }
+    }
+    @Override
+    public void DrawLiner(Graphics g) {
+        if (GetLiner() == null || !(GetLiner() instanceof EntityBigLiner)) {
+            return;
+        }
+        if (_startPosX < 0 || _startPosY < 0) {
+            return;
+        }
+        EntityBigLiner liner = (EntityBigLiner)EntityLiner;
+        int yDiff = Deck.DrawDeck(liner.GetBodyColor(), g, _startPosX, _startPosY) + 20;//+1 основная палуба
+        Graphics2D g2d = (Graphics2D) g;
+        g2d.setPaint(liner.GetBottomColor());
+        //корпус
+        int[] xBottom = {_startPosX,_startPosX + 100, _startPosX + 80, _startPosX + 20};
+        int[] yBottom = {_startPosY + yDiff,_startPosY + yDiff,_startPosY + 40 + yDiff, _startPosY + 40 + yDiff};
+        //бассейн
+        int[] xPool = {_startPosX + 10, _startPosX + 30, _startPosX + 30, _startPosX + 10};
+        int[] yPool = {_startPosY + yDiff,_startPosY + yDiff,_startPosY + 10 + yDiff,_startPosY + 10 + yDiff};
+        g2d.fillPolygon(xBottom,yBottom,4);
+        g2d.setPaint(Color.BLACK);
+        g2d.drawPolygon(xBottom,yBottom,4);
+        if(liner.GetSwimmingPool()) {
+            g2d.setPaint(Color.BLUE);
+            g2d.fillPolygon(xPool, yPool, 4);
+            g2d.setPaint(Color.BLACK);
+            g2d.drawPolygon(xPool, yPool, 4);
+        }
+    }
+}

src/LinerHard/DrawingObjects/DrawingLiner.java

@@ -0,0 +1,106 @@
+package LinerHard.DrawingObjects;
+import LinerHard.ExtraThings.*;
+import LinerHard.Direction;
+import LinerHard.Entities.EntityLiner;
+import java.awt.*;
+import java.util.Random;
+
+public class DrawingLiner{
+    public EntityLiner EntityLiner;
+    public IDrawingDeck Deck;
+    public EntityLiner GetLiner() {
+        return EntityLiner;
+    }
+    protected int _startPosX;
+    protected int _startPosY;
+    protected Integer _pictureWidth = null;
+    protected Integer _pictureHeight = null;
+    protected final int _linerWidth = 100;
+    protected int _linerHeight = 60;
+    public int GetWidth(){return _linerWidth;}
+    public int GetHeight(){return _linerHeight;}
+    public int GetPosX(){return _startPosX;}
+    public int GetPosY(){return _startPosY;}
+    public DrawingLiner(int speed, float weight, Color bottomColor,int width,int height,int deckNumber) {
+        if (width < _linerWidth || height < _linerHeight) {
+            return;
+        }
+        EntityLiner = new EntityLiner(speed,weight,bottomColor);
+        _pictureWidth = width;
+        _pictureHeight = height;
+        Random rand = new Random();
+        Deck = switch (rand.nextInt(0, 3)) {
+            case 0 -> new DrawingDeck();
+            case 1 -> new DrawingOvalDeck();
+            case 2 -> new DrawingTriangleDeck();
+            default -> new DrawingDeck();
+        };
+        Deck.SetAddEnum(deckNumber);
+    }
+    public void SetPosition(int x, int y) {
+        if(x < 0 || y < 0 || x > _pictureWidth - _linerWidth || y > _pictureHeight - _linerHeight){
+            _startPosX = 0;
+            _startPosY = 0;
+            return;
+        }
+        _startPosX = x;
+        _startPosY = y;
+    }
+
+    public void MoveTransport(Direction direction) {
+        if (GetLiner() == null) {
+            return;
+        }
+        switch (direction.GetDirect()) {
+            case 1:
+                if (_startPosY - EntityLiner.GetStep() > 0) {
+                    _startPosY -= EntityLiner.GetStep();
+                }
+                break;
+            case 2:
+                if (_startPosY + _linerHeight + EntityLiner.GetStep() < _pictureHeight) {
+                    _startPosY += EntityLiner.GetStep();
+                }
+                break;
+            case 3:
+                if (_startPosX - EntityLiner.GetStep() > 0) {
+                    _startPosX -= EntityLiner.GetStep();
+                }
+                break;
+            case 4:
+                if (_startPosX + _linerWidth + EntityLiner.GetStep() < _pictureWidth) {
+                    _startPosX += EntityLiner.GetStep();
+                }
+                break;
+        }
+    }
+    public void DrawLiner(Graphics g) {
+        if (GetLiner() == null) {
+            return;
+        }
+        if (_startPosX < 0 || _startPosY < 0) {
+            return;
+        }
+        int yDiff = Deck.DrawDeck(Color.YELLOW, g, _startPosX, _startPosY)+20;//+1 основная палуба, желтая по умолчанию для обычног ообьекта
+        Graphics2D g2d = (Graphics2D) g;
+        g2d.setPaint(EntityLiner.GetBottomColor());
+        //корпус
+        int[] xBottom = {_startPosX, _startPosX + 100, _startPosX + 80, _startPosX + 20};
+        int[] yBottom = {_startPosY + yDiff, _startPosY + yDiff, _startPosY + 40 + yDiff, _startPosY + 40 + yDiff};
+        g2d.fillPolygon(xBottom, yBottom, 4);
+        g2d.setPaint(Color.BLACK);
+        g2d.drawPolygon(xBottom, yBottom, 4);
+    }
+    public boolean CanMove(Direction direction) {
+        if (EntityLiner == null) {
+            return false;
+        }
+
+        return switch (direction) {
+            case Left -> _startPosX - EntityLiner.GetStep() > 0;
+            case Up -> _startPosY - EntityLiner.GetStep() > 0;
+            case Right -> _startPosX + _linerWidth + EntityLiner.GetStep() < _pictureWidth;
+            case Down -> _startPosY + _linerHeight + EntityLiner.GetStep() < _pictureHeight;
+        };
+    }
+}

src/LinerHard/Entities/EntityBigLiner.java

@@ -0,0 +1,33 @@
+package LinerHard.Entities;
+
+import java.awt.*;
+
+public class EntityBigLiner extends EntityLiner
+{
+    public Color BodyColor;
+    public Color GetBodyColor(){
+        return BodyColor;
+    }
+    /// <summary>
+    /// Признак (опция) наличия бассейна
+    /// </summary>
+    public boolean SwimmingPool;
+    public boolean GetSwimmingPool(){
+        return SwimmingPool;
+    }
+    /// <summary>
+    /// Признак (опция) наличия доп палубы
+    /// </summary>
+    public boolean Deck;
+    public boolean GetDeck(){
+        return Deck;
+    }
+    public EntityBigLiner(int speed, float weight, Color bodyColor, Color bottomColor, boolean swimmingPool, boolean deck)
+    {
+        super(speed,weight,bottomColor);
+        BodyColor = bodyColor;
+        SwimmingPool = swimmingPool;
+        Deck = deck;
+    }
+}
+

src/LinerHard/Entities/EntityLiner.java

@@ -0,0 +1,46 @@
+package LinerHard.Entities;
+
+import java.awt.*;
+public class EntityLiner
+{
+    /// <summary>
+    /// Скорость
+    /// </summary>
+    private int Speed;
+    public int GetSpeed(){
+        return Speed;
+    }
+    /// <summary>
+    /// Вес
+    /// </summary>
+    private float Weight;
+    public float GetWeight(){
+        return Weight;
+    }
+    /// <summary>
+    /// Основной цвет
+    /// </summary>
+    private Color BottomColor;
+    public Color GetBottomColor(){
+        return BottomColor;
+    }
+    /// <summary>
+    /// Шаг
+    /// </summary>
+    public float GetStep(){
+        return (float)Speed*100 / Weight;
+    }
+    /// <summary>
+    /// Инициализация полей объекта-класса лайнера
+    /// </summary>
+    /// <param name="speed">Скорость</param>
+    /// <param name="weight">Вес лайнера</param>
+    /// <param name="bodyColor">Основной цвет</param>
+    public EntityLiner(int speed, float weight, Color bottomColor)
+    {
+        Speed = speed;
+        Weight = weight;
+        BottomColor = bottomColor;
+    }
+}
+

src/LinerHard/ExtraThings/AdditionalEnum.java

@@ -0,0 +1,15 @@
+package LinerHard.ExtraThings;
+
+public enum AdditionalEnum {
+    One(1),
+    Two(2),
+    Three(3),
+    ;
+    private final int addEnum;
+    AdditionalEnum(int i) {
+        this.addEnum=i;
+    }
+    public int GetAddEnum() {
+        return addEnum;
+    }
+}

src/LinerHard/ExtraThings/DrawingDeck.java

@@ -0,0 +1,46 @@
+package LinerHard.ExtraThings;
+
+import java.awt.*;
+public class DrawingDeck implements IDrawingDeck{
+    private AdditionalEnum deckNumber;
+    @Override
+    public void SetAddEnum(int num){
+        switch (num){
+            case 1:
+                deckNumber = AdditionalEnum.One;
+                break;
+            case 2:
+                deckNumber = AdditionalEnum.Two;
+                break;
+            default:
+                deckNumber = AdditionalEnum.Three;
+        }
+    };
+    @Override
+    public AdditionalEnum GetDeckNumber() {
+        return deckNumber;
+    }
+    @Override
+    public int DrawDeck(Color colorDeck, Graphics g, int _startPosX, int  _startPosY) {
+        Graphics2D g2d = (Graphics2D) g;
+        //Переделана логика вариативной отрисовки для снижения повторяющегося кода
+        int k = deckNumber.GetAddEnum();
+        if(k > 0){
+            DrawNumDeck(g2d,k-1,_startPosX,_startPosY,colorDeck);
+            return (k-1)*20; //20-высота одной палубы
+        }
+        return 0;
+    }
+    public void DrawNumDeck(Graphics2D g2d, int numOfDecks,int _startPosX,int _startPosY,Color colorDeck){
+        int yDiff = numOfDecks * 20;
+        int[] xDeck = {_startPosX + 30, _startPosX + 30 + 60, _startPosX + 30 + 60,  _startPosX+30};
+        int[] yDeck = {_startPosY + yDiff, _startPosY + yDiff, _startPosY + 20 + yDiff, _startPosY + 20 + yDiff};
+        g2d.setPaint(colorDeck);
+        g2d.fillPolygon(xDeck,yDeck,4);
+        g2d.setPaint(Color.BLACK);
+        g2d.drawPolygon(xDeck,yDeck,4);
+        if(numOfDecks > 0){
+            DrawNumDeck(g2d,numOfDecks-1,_startPosX,_startPosY,colorDeck);
+        }
+    }
+}

src/LinerHard/ExtraThings/DrawingOvalDeck.java

@@ -0,0 +1,44 @@
+package LinerHard.ExtraThings;
+
+import java.awt.*;
+public class DrawingOvalDeck implements IDrawingDeck{
+    private AdditionalEnum deckNumber;
+    @Override
+    public void SetAddEnum(int num){
+        switch (num){
+            case 1:
+                deckNumber = AdditionalEnum.One;
+                break;
+            case 2:
+                deckNumber = AdditionalEnum.Two;
+                break;
+            default:
+                deckNumber = AdditionalEnum.Three;
+        }
+    };
+    @Override
+    public AdditionalEnum GetDeckNumber() {
+        return deckNumber;
+    }
+    @Override
+    public int DrawDeck(Color colorDeck, Graphics g, int _startPosX, int  _startPosY) {
+        Graphics2D g2d = (Graphics2D) g;
+        //Переделана логика вариативной отрисовки для снижения повторяющегося кода
+        int k = deckNumber.GetAddEnum();
+        if(k > 0){
+            DrawNumDeck(g2d,k-1,_startPosX,_startPosY,colorDeck);
+            return (k-1)*20; //20-высота одной палубы
+        }
+        return 0;
+    }
+    public void DrawNumDeck(Graphics2D g2d, int numOfDecks,int _startPosX,int _startPosY,Color colorDeck){
+        int yDiff = numOfDecks * 20;
+        g2d.setPaint(colorDeck);
+        g2d.fillOval(_startPosX+10,_startPosY+yDiff,90,20);
+        g2d.setPaint(Color.BLACK);
+        g2d.drawOval(_startPosX+10,_startPosY+yDiff,90,20);
+        if(numOfDecks > 0){
+            DrawNumDeck(g2d,numOfDecks-1,_startPosX,_startPosY,colorDeck);
+        }
+    }
+}

src/LinerHard/ExtraThings/DrawingTriangleDeck.java

@@ -0,0 +1,46 @@
+package LinerHard.ExtraThings;
+
+import java.awt.*;
+public class DrawingTriangleDeck implements IDrawingDeck{
+    private AdditionalEnum deckNumber;
+    @Override
+    public void SetAddEnum(int num){
+        switch (num){
+            case 1:
+                deckNumber = AdditionalEnum.One;
+                break;
+            case 2:
+                deckNumber = AdditionalEnum.Two;
+                break;
+            default:
+                deckNumber = AdditionalEnum.Three;
+        }
+    };
+    @Override
+    public AdditionalEnum GetDeckNumber() {
+        return deckNumber;
+    }
+    @Override
+    public int DrawDeck(Color colorDeck, Graphics g, int _startPosX, int  _startPosY) {
+        Graphics2D g2d = (Graphics2D) g;
+        //Переделана логика вариативной отрисовки для снижения повторяющегося кода
+        int k = deckNumber.GetAddEnum();
+        if(k > 0){
+            DrawNumDeck(g2d,k-1,_startPosX,_startPosY,colorDeck);
+            return (k-1)*20; //20-высота одной палубы
+        }
+        return 0;
+    }
+    public void DrawNumDeck(Graphics2D g2d, int numOfDecks,int _startPosX,int _startPosY,Color colorDeck){
+        int yDiff = numOfDecks * 20;
+        int[] xDeck =  {_startPosX+30,_startPosX+60,_startPosX + 30 + 60};
+        int[] yDeck = {_startPosY + 20 + yDiff,_startPosY+ yDiff,_startPosY + 20 + yDiff};
+        g2d.setPaint(colorDeck);
+        g2d.fillPolygon(xDeck,yDeck,3);
+        g2d.setPaint(Color.BLACK);
+        g2d.drawPolygon(xDeck,yDeck,3);
+        if(numOfDecks > 0){
+            DrawNumDeck(g2d,numOfDecks-1,_startPosX,_startPosY,colorDeck);
+        }
+    }
+}

src/LinerHard/ExtraThings/IDrawingDeck.java

@@ -0,0 +1,7 @@
+package LinerHard.ExtraThings;
+import java.awt.*;
+public interface IDrawingDeck {
+    void SetAddEnum(int num);
+    AdditionalEnum GetDeckNumber();
+    int DrawDeck(Color color, Graphics g,int startPosX, int startPosY);
+}

src/LinerHard/FormLiner.java

@@ -0,0 +1,171 @@
+package LinerHard;
+import javax.swing.*;
+import java.awt.*;
+import java.awt.Graphics;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.util.*;
+import LinerHard.DrawingObjects.*;
+import LinerHard.Entities.*;
+import LinerHard.MovementStrategies.*;
+
+public class FormLiner{
+    private DrawingLiner _drawingLiner;
+    private AbstractStrategy _abstractStrategy;
+    Canvas canv;
+    public void Draw(){
+        canv.repaint();
+    }
+    public FormLiner(){
+        JFrame frame = new JFrame("LinerHard");
+        JButton buttonCreateLiner = new JButton("Создать Лайнер");
+        buttonCreateLiner.setFocusPainted(false);
+        buttonCreateLiner.setContentAreaFilled(false);
+        JButton buttonCreateBigLiner = new JButton("Создать Большой Лайнер");
+        buttonCreateBigLiner.setFocusPainted(false);
+        buttonCreateBigLiner.setContentAreaFilled(false);
+        String[] items = {
+                "Form center",
+                "Form border"
+        };
+        JComboBox comboBoxStrategy = new JComboBox(items);
+        JButton buttonStep = new JButton("Шаг");
+        buttonStep.setFocusPainted(false);
+        buttonStep.setContentAreaFilled(false);
+        JButton buttonUp = new JButton();
+        buttonUp.setFocusPainted(false);
+        buttonUp.setContentAreaFilled(false);
+        buttonUp.setName("up");
+        buttonUp.setIcon(new ImageIcon(((new ImageIcon("src/Images/arrowUp.png")).getImage()).getScaledInstance(35, 35, java.awt.Image.SCALE_SMOOTH)));
+        JButton buttonDown = new JButton();
+        buttonDown.setFocusPainted(false);
+        buttonDown.setContentAreaFilled(false);
+        buttonDown.setName("down");
+        buttonDown.setIcon(new ImageIcon(((new ImageIcon("src/Images/arrowDown.png")).getImage()).getScaledInstance(35, 35, java.awt.Image.SCALE_SMOOTH)));
+        JButton buttonLeft = new JButton();
+        buttonLeft.setFocusPainted(false);
+        buttonLeft.setContentAreaFilled(false);
+        buttonLeft.setName("left");
+        buttonLeft.setIcon(new ImageIcon(((new ImageIcon("src/Images/arrowLeft.png")).getImage()).getScaledInstance(35, 35, java.awt.Image.SCALE_SMOOTH)));
+        JButton buttonRight = new JButton();
+        buttonRight.setFocusPainted(false);
+        buttonRight.setContentAreaFilled(false);
+        buttonRight.setName("right");
+        buttonRight.setIcon(new ImageIcon(((new ImageIcon("src/Images/arrowRight.png")).getImage()).getScaledInstance(35, 35, java.awt.Image.SCALE_SMOOTH)));
+        buttonCreateLiner.addActionListener(
+                e -> {
+                    Random random = new Random();
+                    _drawingLiner = new DrawingLiner(random.nextInt(20) + 10,//для удобства скорость больше
+                            random.nextInt(200)+50,
+                            new Color(random.nextInt(256), random.nextInt(256), random.nextInt(256)),
+                            this.canv.getWidth(), this.canv.getHeight(), 1);// 1 палуба у обычного лайнера
+                    _drawingLiner.SetPosition(random.nextInt(100), random.nextInt(90));
+                    canv._drawingLiner = _drawingLiner;
+                    Draw();
+                }
+        );
+        buttonCreateBigLiner.addActionListener(
+                e -> {
+                    Random random = new Random();
+                    _drawingLiner= new DrawingBigLiner(random.nextInt(20) + 10,//для удобства скорость больше
+                            random.nextInt(200)+50,
+                            new Color(random.nextInt(256), random.nextInt(256), random.nextInt(256)),
+                            this.canv.getWidth(), this.canv.getHeight(),
+                            new Color(random.nextInt(256), random.nextInt(256), random.nextInt(256)),
+                            random.nextBoolean(),random.nextBoolean(), random.nextInt(0,3));
+                    _drawingLiner.SetPosition(random.nextInt(100), random.nextInt(90));
+                    canv._drawingLiner = _drawingLiner;
+                    Draw();
+                }
+        );
+        ActionListener actionListener = e -> {
+            if (_drawingLiner == null){
+                return;
+            }
+            switch ((((JButton)(e.getSource())).getName())){
+                case "up":
+                    _drawingLiner.MoveTransport(Direction.Up);
+                    break;
+                case "down":
+                    _drawingLiner.MoveTransport(Direction.Down);
+                    break;
+                case "left":
+                    _drawingLiner.MoveTransport(Direction.Left);
+                    break;
+                case "right":
+                    _drawingLiner.MoveTransport(Direction.Right);
+                    break;
+            }
+            Draw();
+        };
+        buttonUp.addActionListener(actionListener);
+        buttonDown.addActionListener(actionListener);
+        buttonLeft.addActionListener(actionListener);
+        buttonRight.addActionListener(actionListener);
+        buttonStep.addActionListener(e -> {
+            if (_drawingLiner == null) {
+                return;
+            }
+            if (comboBoxStrategy.isEnabled()) {
+                _abstractStrategy = switch (comboBoxStrategy.getSelectedIndex()) {
+                    case 0 -> new MoveToCenter();
+                    case 1 -> new MoveToBorder();
+                    default -> null;
+                };
+                if (_abstractStrategy == null)
+                {
+                    return;
+                }
+                _abstractStrategy.SetData(new DrawingObjectLiner(_drawingLiner), this.canv.getWidth(), this.canv.getHeight());
+            }
+            if (_abstractStrategy == null)
+            {
+                return;
+            }
+            comboBoxStrategy.setEnabled(false);
+            _abstractStrategy.MakeStep();
+            Draw();
+            if (_abstractStrategy.GetStatus() == Status.Finish)
+            {
+                comboBoxStrategy.setEnabled(true);
+                _abstractStrategy = null;
+            }
+        });
+        frame.setSize(910, 500);
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        frame.setLayout(null);
+        buttonCreateLiner.setBounds(20, 420, 100, 40);
+        buttonCreateBigLiner.setBounds(140, 420, 100, 40);
+        buttonUp.setBounds(800, 380, 40, 40);
+        buttonDown.setBounds(800, 420, 40, 40);
+        buttonLeft.setBounds(760, 420, 40, 40);
+        buttonRight.setBounds(840, 420, 40, 40);
+        comboBoxStrategy.setBounds(800,10,100,50);
+        buttonStep.setBounds(800,80,100,40);
+        canv = new Canvas();
+        canv.setBounds(0, 0, frame.getWidth()-15,frame.getHeight()-38);//отнимаем высоту доп частей фрейма (число выведенно опытным путем)
+        frame.add(canv);
+        frame.add(buttonCreateLiner);
+        frame.add(buttonCreateBigLiner);
+        frame.add(buttonUp);
+        frame.add(buttonDown);
+        frame.add(buttonLeft);
+        frame.add(buttonRight);
+        frame.add(comboBoxStrategy);
+        frame.add(buttonStep);
+        frame.setVisible(true);
+    }
+    class Canvas extends JComponent{
+        public DrawingLiner _drawingLiner;
+        public Canvas(){}
+        public void paintComponent(Graphics g){
+            if (_drawingLiner == null){
+                return;
+            }
+            super.paintComponents(g);
+            Graphics2D g2d = (Graphics2D)g;
+            _drawingLiner.DrawLiner(g2d);
+            super.repaint();
+        }
+    }
+}

src/LinerHard/Main.java

@@ -0,0 +1,6 @@
+package LinerHard;
+public class Main {
+    public static void main(String[] args) {
+        FormLiner fm = new FormLiner();
+    }
+}

src/LinerHard/MovementStrategies/AbstractStrategy.java

@@ -0,0 +1,80 @@
+package LinerHard.MovementStrategies;
+
+import LinerHard.Direction;
+public abstract class AbstractStrategy {
+    private IMoveableObject moveableObject;
+    private Status state = Status.NotInit;
+    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.NotInit;
+            return;
+        }
+        state = Status.InProgress;
+        this.moveableObject = moveableObject;
+        fieldWidth = width;
+        fieldHeight = height;
+    }
+    public void MakeStep() {
+        if (state != Status.InProgress) {
+            return;
+        }
+        if (isTargetDestination()) {
+            state = Status.Finish;
+            return;
+        }
+        MoveToTarget();
+    }
+    protected boolean MoveLeft() {
+        return MoveTo(Direction.Left);
+    }
+    protected boolean MoveRight() {
+        return MoveTo(Direction.Right);
+    }
+    protected boolean MoveUp() {
+        return MoveTo(Direction.Up);
+    }
+    protected boolean MoveDown() {
+        return MoveTo(Direction.Down);
+    }
+    protected ObjectParameters GetObjectParameters() {
+        if (moveableObject == null) {
+            return null;
+        }
+        return moveableObject.GetObjectPosition();
+    }
+    protected Integer  GetStep() {
+        if (state != Status.InProgress) {
+            return null;
+        }
+        return moveableObject.GetStep();
+    }
+
+    protected abstract void MoveToTarget();
+
+    protected abstract boolean isTargetDestination();
+
+    private boolean MoveTo(Direction direction) {
+        if (state != Status.InProgress) {
+            return false;
+        }
+        if (moveableObject == null) {
+            return false;
+        }
+        if (moveableObject.CheckCanMove(direction)) {
+            moveableObject.MoveObject(direction);
+            return true;
+        }
+        return false;
+    }
+}

src/LinerHard/MovementStrategies/DrawingObjectLiner.java

@@ -0,0 +1,37 @@
+package LinerHard.MovementStrategies;
+
+import LinerHard.Direction;
+import LinerHard.DrawingObjects.*;
+
+public class DrawingObjectLiner implements IMoveableObject{
+    private DrawingLiner _drawingLiner = null;
+    public DrawingObjectLiner (DrawingLiner drawingLiner)
+    {
+        _drawingLiner = drawingLiner;
+    }
+    @Override
+    public ObjectParameters GetObjectPosition() {
+        if (_drawingLiner == null || _drawingLiner.EntityLiner == null) {
+            return null;
+        }
+        return new ObjectParameters(_drawingLiner.GetPosX(), _drawingLiner.GetPosY(),
+                _drawingLiner.GetWidth(), _drawingLiner.GetHeight());
+    }
+    @Override
+    public int GetStep() {
+        if (_drawingLiner != null && _drawingLiner.EntityLiner!=null)
+            return (int)(_drawingLiner.EntityLiner.GetStep());
+        return 0;
+    }
+    @Override
+    public boolean CheckCanMove(Direction direction) {
+        if (_drawingLiner != null)
+            return _drawingLiner.CanMove(direction);
+        return false;
+    }
+    @Override
+    public void MoveObject(Direction direction) {
+        if (_drawingLiner != null)
+            _drawingLiner.MoveTransport(direction);
+    }
+}

src/LinerHard/MovementStrategies/IMoveableObject.java

@@ -0,0 +1,11 @@
+package LinerHard.MovementStrategies;
+import LinerHard.Direction;
+public interface IMoveableObject{
+    ObjectParameters GetObjectPosition();
+
+    int GetStep();
+
+    boolean CheckCanMove(Direction direction);
+
+    void MoveObject(Direction direction);
+}

src/LinerHard/MovementStrategies/MoveToBorder.java

@@ -0,0 +1,34 @@
+package LinerHard.MovementStrategies;
+
+public class MoveToBorder extends AbstractStrategy{
+    @Override
+    protected boolean isTargetDestination() {
+        var objParams = GetObjectParameters();
+        if (objParams == null) {
+            return false;
+        }
+        return objParams.RightBorder() <= GetFieldWidth() &&
+                objParams.RightBorder() + GetStep() >= GetFieldWidth() &&
+                objParams.DownBorder() <= GetFieldHeight() &&
+                objParams.DownBorder() + GetStep() >= GetFieldHeight();
+    }
+    @Override
+    protected void MoveToTarget() {
+        var objParams = GetObjectParameters();
+        if (objParams == null) {
+            return;
+        }
+        var diffX = objParams.ObjectMiddleHorizontal() - GetFieldWidth();
+        if (Math.abs(diffX) > GetStep()) {
+            if (diffX < 0) {
+                MoveRight();
+            }
+        }
+        var diffY = objParams.ObjectMiddleVertical() - GetFieldHeight();
+        if (Math.abs(diffY) > GetStep()) {
+            if (diffY < 0) {
+                MoveDown();
+            }
+        }
+    }
+}

src/LinerHard/MovementStrategies/MoveToCenter.java

@@ -0,0 +1,38 @@
+package LinerHard.MovementStrategies;
+
+public class MoveToCenter extends AbstractStrategy{
+    @Override
+    protected boolean isTargetDestination() {
+        var objParams = GetObjectParameters();
+        if (objParams == null) {
+            return false;
+        }
+        return objParams.ObjectMiddleHorizontal() <= GetFieldWidth() / 2 &&
+                objParams.ObjectMiddleHorizontal() + GetStep() >= GetFieldWidth() / 2 &&
+                objParams.ObjectMiddleVertical() <= GetFieldHeight() / 2 &&
+                objParams.ObjectMiddleVertical() + GetStep() >= GetFieldHeight() / 2;
+    }
+    @Override
+    protected void MoveToTarget() {
+        var objParams = GetObjectParameters();
+        if (objParams == null) {
+            return;
+        }
+        var diffX = objParams.ObjectMiddleHorizontal() - GetFieldWidth() / 2;
+        if (Math.abs(diffX) > GetStep()) {
+            if (diffX > 0) {
+                MoveLeft();
+            } else {
+                MoveRight();
+            }
+        }
+        var diffY = objParams.ObjectMiddleVertical() - GetFieldHeight() / 2;
+        if (Math.abs(diffY) > GetStep()) {
+            if (diffY > 0) {
+                MoveUp();
+            } else {
+                MoveDown();
+            }
+        }
+    }
+}

src/LinerHard/MovementStrategies/ObjectParameters.java

@@ -0,0 +1,42 @@
+package LinerHard.MovementStrategies;
+
+public class ObjectParameters {
+    private final int _x;
+
+    private final int _y;
+
+    private final int _width;
+
+    private final int _height;
+
+    public int LeftBorder() {
+        return _x;
+    }
+
+    public int TopBorder() {
+        return _y;
+    }
+
+    public int RightBorder() {
+        return _x + _width;
+    }
+
+    public int DownBorder() {
+        return _y + _height;
+    }
+
+    public int ObjectMiddleHorizontal() {
+        return _x + _width / 2;
+    }
+
+    public int ObjectMiddleVertical() {
+        return _y + _height / 2;
+    }
+
+    public ObjectParameters(int x, int y, int width, int height) {
+        _x = x;
+        _y = y;
+        _width = width;
+        _height = height;
+    }
+}

src/LinerHard/MovementStrategies/Status.java

@@ -0,0 +1,7 @@
+package LinerHard.MovementStrategies;
+
+public enum Status {
+    NotInit,
+    InProgress,
+    Finish
+}