Done

AbstractStrategy.java

@@ -0,0 +1,70 @@
+public abstract class AbstractStrategy {
+    private IMoveableObject _moveableObject;
+    private Status _state = Status.NotInit;
+    protected int FieldWidth;
+    protected int 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;
+        _moveableObject = moveableObject;
+        FieldWidth = width;
+        FieldHeight = height;
+    }
+    public void MakeStep()
+    {
+        if (_state != Status.InProgress)
+        {
+            return;
+        }
+        if (IsTargetDestinaion())
+        {
+            _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 _moveableObject.GetObjectPosition();
+        }
+        else {
+            return null;
+        }
+    }
+    protected int GetStep()
+    {
+        if (_state != Status.InProgress)
+        {
+            return Integer.parseInt(null);
+        }
+        return _moveableObject.GetStep();
+    }
+    protected abstract void MoveToTarget();
+    protected abstract boolean IsTargetDestinaion();
+    private boolean MoveTo(Direction directionType)
+    {
+        if (_state != Status.InProgress)
+        {
+            return false;
+        }
+        if (_moveableObject.CheckCanMove(directionType))
+        {
+            _moveableObject.MoveObject(directionType);
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+}

Direction.java

@@ -0,0 +1,6 @@
+public enum Direction {
+    Up,
+    Down,
+    Left,
+    Right
+}

DopClassMixed.java

@@ -0,0 +1,34 @@
+import java.awt.*;
+public class DopClassMixed implements IDop{
+    public int numOfWheels;
+    public DopClassMixed(int num){
+        numOfWheels = num;
+    }
+    public void setNumOfWheels(String num){
+        switch (Integer.valueOf(num)){
+            case 2:
+                numOfWheels = NumberOfWheelsEnum.wheel_2.value;
+                break;
+            case 3:
+                numOfWheels = NumberOfWheelsEnum.wheel_3.value;
+                break;
+            case 4:
+                numOfWheels = NumberOfWheelsEnum.wheel_4.value;
+                break;
+            default:
+                numOfWheels = NumberOfWheelsEnum.wheel_2.value;
+        }
+    }
+    public void drawWheels(Graphics g, int _startPosX, int _startPosY, Color c) {
+        g.setColor(c);
+
+        if (numOfWheels >= 2) {
+            g.fillRect(_startPosX+55, _startPosY+20, 20, 15);
+            g.fillRect(_startPosX+55, _startPosY+40, 20, 15);
+        } if (numOfWheels >= 3) {
+            g.fillOval(_startPosX+30, _startPosY+20, 20, 15);
+        } if (numOfWheels >= 4) {
+            g.fillRect(_startPosX+85, _startPosY+20, 20, 15);
+        }
+    }
+}

DopClassRect.java

@@ -0,0 +1,33 @@
+import java.awt.*;
+public class DopClassRect implements IDop{
+    public int numOfWheels;
+    public DopClassRect(int num){
+        numOfWheels = num;
+    }
+    public void setNumOfWheels(String num){
+        switch (Integer.valueOf(num)){
+            case 2:
+                numOfWheels = NumberOfWheelsEnum.wheel_2.value;
+                break;
+            case 3:
+                numOfWheels = NumberOfWheelsEnum.wheel_3.value;
+                break;
+            case 4:
+                numOfWheels = NumberOfWheelsEnum.wheel_4.value;
+                break;
+            default:
+                numOfWheels = NumberOfWheelsEnum.wheel_2.value;
+        }
+    }
+    public void drawWheels(Graphics g, int _startPosX, int _startPosY, Color c) {
+        g.setColor(c);
+        if (numOfWheels >= 2) {
+            g.fillRect(_startPosX+55, _startPosY+15, 20, 15);
+            g.fillRect(_startPosX+55, _startPosY+30, 20, 15);
+        } if (numOfWheels >= 3) {
+            g.fillRect(_startPosX+30, _startPosY+15, 20, 15);
+        } if (numOfWheels >= 4) {
+            g.fillRect(_startPosX + 60, _startPosY + 35, 15, 15);
+        }
+    }
+}

DrawingAdvancedCruiser.java

@@ -0,0 +1,40 @@
+import java.awt.*;
+public class DrawingAdvancedCruiser extends DrawingCruiser{
+    EntityAdvancedCruiser EntityCruiser;
+    public DrawingAdvancedCruiser(int speed, double weight, Color bodyColor, Color additionalColor, boolean helicopterPad, boolean coating, boolean ornamentWheels, int width, int height) {
+        super(speed, weight, bodyColor, width, height, 110, 60);
+        {
+            EntityCruiser = new EntityAdvancedCruiser(speed, weight, bodyColor, additionalColor, helicopterPad, coating);
+        }
+    }
+    @Override
+    public void DrawTransport(Graphics g)
+    {
+        if (!(EntityCruiser instanceof EntityAdvancedCruiser)) {
+            return;
+        }
+        super.DrawTransport(g);
+        EntityAdvancedCruiser advancedCruiser = (EntityAdvancedCruiser) EntityCruiser;
+        if (advancedCruiser == null )
+        {
+            return;
+        }
+        Color addBrush = advancedCruiser.AdditionalColor;
+        Color brush = advancedCruiser.BodyColor;
+        if (advancedCruiser.HelicopterPad)
+        {
+            g.setColor(addBrush);
+            g.drawRect(_startPosX + 35,
+                    _startPosY + 23, 15, 15);
+            g.drawRect(_startPosX + 50,
+                    _startPosY + 19, 30, 25);
+        }
+        if (advancedCruiser.Coating)
+        {
+            g.drawOval(_startPosX + 70,
+                    _startPosY + 29, 20, 20);
+        }
+        if (wheels == null){return;}
+        wheels.drawWheels(g, _startPosX, _startPosY, brush);
+    }
+}

DrawingCruiser.java

@@ -0,0 +1,146 @@
+import java.awt.*;
+
+public class DrawingCruiser {
+    public EntityCruiser EntityCruiser;
+    private int _pictureWidth;
+    private int _pictureHeight;
+    protected int _startPosX;
+    protected int _startPosY;
+    private int _cruiserWidth = 110;
+    private int _cruiserHeight = 60;
+
+    public int GetPosX() {
+        return _startPosX;
+    }
+
+    public int GetPosY() {
+        return _startPosY;
+    }
+
+    public int GetWidth() {
+        return _cruiserWidth;
+    }
+
+    public int GetHeight() {
+        return _cruiserHeight;
+    }
+
+    public IDop wheels;
+
+    public DrawingCruiser(int speed, double weight, Color bodyColor, int width, int height) {
+        if (width < _cruiserWidth || height < _cruiserHeight) {
+            return;
+        }
+        _pictureWidth = width;
+        _pictureHeight = height;
+        EntityCruiser = new EntityCruiser(speed, weight, bodyColor);
+    }
+
+    public EntityCruiser getEntity() {
+        return EntityCruiser;
+    }
+
+    protected DrawingCruiser(int speed, double weight, Color bodyColor, int
+            width, int height, int cruiserWidth, int cruiserHeight) {
+        if (width <= _cruiserWidth || height <= _cruiserHeight) {
+            return;
+        }
+        _pictureWidth = width;
+        _pictureHeight = height;
+        _cruiserWidth = cruiserWidth;
+        _cruiserHeight = cruiserHeight;
+        EntityCruiser = new EntityCruiser(speed, weight, bodyColor);
+    }
+    public DrawingCruiser(EntityCruiser entityCruiser, IDop wheels) {
+        EntityCruiser = entityCruiser;
+        this.wheels = wheels;
+        _pictureWidth = 1000;
+        _pictureHeight = 1000;
+        _cruiserWidth = 110;
+        _cruiserHeight = 60;
+    }
+    public void SetPosition(int x, int y) {
+        if (x < 0 || x + _cruiserWidth > _pictureWidth) {
+            x = Math.max(0, _pictureWidth - _cruiserWidth);
+        }
+        if (y < 0 || y + _cruiserHeight > _pictureHeight) {
+            y = Math.max(0, _pictureHeight - _cruiserHeight);
+        }
+        _startPosX = x;
+        _startPosY = y;
+    }
+    public void MoveTransport(Direction direction) {
+        if (!CanMove(direction) || EntityCruiser == null) {
+            return;
+        }
+        switch (direction) {
+            case Left:
+                if (_startPosX - EntityCruiser.Step() >= 0) {
+                    _startPosX -= (int) EntityCruiser.Step();
+                }
+                break;
+            case Up:
+                if (_startPosY - EntityCruiser.Step() >= 0) {
+                    _startPosY -= (int) EntityCruiser.Step();
+                }
+                break;
+            case Right:
+                if (_startPosX + EntityCruiser.Step() + _cruiserWidth <=  _pictureWidth) {
+                    _startPosX += (int) EntityCruiser.Step();
+                }
+                break;
+            case Down:
+                if (_startPosY + EntityCruiser.Step() + _cruiserHeight <= _pictureHeight) {
+                    _startPosY += (int) EntityCruiser.Step();
+                }
+                break;
+        }
+    }
+    public boolean CanMove(Direction direction) {
+        if (EntityCruiser == null) {
+            return false;
+        }
+        switch (direction) {
+            case Left:
+                return (_startPosX - EntityCruiser.Step()) > 0;
+            case Up:
+                return _startPosY - EntityCruiser.Step() > 0;
+            case Right:
+                return _startPosX + EntityCruiser.Step() + _cruiserWidth < _pictureWidth;
+            case Down:
+                return _startPosY + EntityCruiser.Step() + _cruiserHeight < _pictureHeight;
+            default:
+                return false;
+        }
+    }
+    public void DrawTransport(Graphics g) {
+        if (EntityCruiser == null) {
+            return;
+        }
+        g.setColor(EntityCruiser.BodyColor);
+        g.drawRect(_startPosX + 9, _startPosY + 15, 10, 30);
+        g.drawRect(_startPosX + 90, _startPosY + 15, 10,
+                30);
+        g.drawRect(_startPosX + 20, _startPosY + 4, 70, 52);
+
+        g.fillRect(_startPosX + 10, _startPosY + 15, 10, 30);
+        g.fillRect(_startPosX + 90, _startPosY + 15, 10, 30);
+        g.fillRect(_startPosX + 20, _startPosY + 5, 70, 50);
+        g.fillRect(_startPosX + 10, _startPosY + 15, 10, 30);
+        g.fillRect(_startPosX + 90, _startPosY + 15, 10, 30);
+        g.fillRect(_startPosX + 20, _startPosY + 5, 70, 50);
+
+        Point[] points1 = new Point[3];
+        points1[0] = new Point(_startPosX + 100, _startPosY + 5);
+        points1[1] = new Point(_startPosX + 100, _startPosY + 55);
+        points1[2] = new Point(_startPosX + 150, _startPosY + 30);
+        g.fillPolygon(new int[]{points1[0].x, points1[1].x, points1[2].x},
+                new int[]{points1[0].y, points1[1].y, points1[2].y}, 3);
+        g.fillRect(_startPosX + 5, _startPosY + 15, 10, 10);
+        g.fillRect(_startPosX + 5, _startPosY + 35, 10, 10);
+        if (wheels == null) {
+            return;
+        }
+        wheels.drawWheels(g, _startPosX, _startPosY, EntityCruiser.BodyColor);
+    }
+}

DrawingObjectCruiser.java

@@ -0,0 +1,24 @@
+public class DrawingObjectCruiser implements IMoveableObject {
+    private DrawingCruiser _drawningCruiser = null;
+    public DrawingObjectCruiser(DrawingCruiser drawningCruiser) {
+        _drawningCruiser = drawningCruiser;
+    }
+    public ObjectParameters GetObjectPosition() {
+        if (_drawningCruiser == null || _drawningCruiser.EntityCruiser == null) {
+            return null;
+        }
+        return new ObjectParameters(_drawningCruiser.GetPosX(), _drawningCruiser.GetPosY(), _drawningCruiser.GetWidth(), _drawningCruiser.GetHeight());
+    }
+    public int GetStep() {
+        return (int) (_drawningCruiser.EntityCruiser.Step());
+    }
+    public boolean CheckCanMove(Direction direction) {
+        if (_drawningCruiser.CanMove(direction)){
+            return true;
+        }
+        return false;
+    }
+    public void MoveObject(Direction direction) {
+        _drawningCruiser.MoveTransport(direction);
+    }
+}

EntityAdvancedCruiser.java

@@ -0,0 +1,14 @@
+import java.awt.*;
+public class EntityAdvancedCruiser extends EntityCruiser{
+    public Color AdditionalColor;
+    public boolean HelicopterPad ;
+    public boolean Coating ;
+    public EntityAdvancedCruiser(int speed, double weight, Color bodyColor, Color
+            additionalColor, boolean helicopterPad, boolean coating)
+    {
+        super(speed, weight, bodyColor);
+        AdditionalColor = additionalColor;
+        HelicopterPad = helicopterPad;
+        Coating = coating;
+    }
+}

EntityCruiser.java

@@ -0,0 +1,14 @@
+import java.awt.*;
+public class EntityCruiser {
+    public int Speed;
+    public double Weight;
+    public Color BodyColor;
+    public double Step() {return (double)Speed * 100 / Weight;};
+    public boolean OrnamentWheels;
+    public EntityCruiser(int speed, double weight, Color bodyColor)
+    {
+        Speed = speed;
+        Weight = weight;
+        BodyColor = bodyColor;
+    }
+}

GameFrame.java

@@ -0,0 +1,198 @@
+import javax.swing.*;
+import javax.swing.plaf.basic.BasicArrowButton;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.util.Random;
+
+public class GameFrame extends JFrame {
+
+    GameFrame() {
+        this.setSize(710, 535);
+        this.setTitle("Cruiser");
+        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        this.setResizable(false);
+        this.setLocationRelativeTo(null);
+
+        GamePanel panel = new GamePanel();
+        this.add(panel);
+
+        this.setVisible(true);
+    }
+    public class GamePanel extends JPanel {
+        static final int SCREEN_W = 700;
+        static final int SCREEN_H = 500;
+        int xx = 0;
+        int yy = 0;
+        private DrawingAdvancedCruiser _drawningAdvancedCruiser;
+        private DrawingCruiser _drawningCruiser;
+        private AbstractStrategy _abstractStrategy;
+
+        GamePanel() {
+            this.setLayout(null);
+            this.setPreferredSize(new Dimension(SCREEN_W, SCREEN_H));
+            GridBagConstraints layers = new GridBagConstraints();
+
+            JButton buttonCruiser = new JButton("Создать простой объект");
+            buttonCruiser.addActionListener(new ActionListener() {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    Random random = new Random();
+                    _drawningCruiser = new DrawingCruiser(random.nextInt(100, 300),
+                            random.nextInt(1000, 3000),
+                            Color.getHSBColor(random.nextInt(0, 256), random.nextInt(0, 256),
+                                    random.nextInt(0, 256)),
+                            GamePanel.SCREEN_W, GamePanel.SCREEN_H);
+                    _drawningCruiser.SetPosition(random.nextInt(10, 100), random.nextInt(10,
+                            100));
+
+                    int ornament = random.nextInt(1, 4);
+                    switch (ornament){
+                        case 1:
+                            _drawningCruiser.wheels = new NumberOfWheels(random.nextInt(2, 5));
+                            break;
+                        case 2:
+                            _drawningCruiser.wheels = new DopClassRect(random.nextInt(2, 5));
+                            break;
+                        default:
+                            _drawningCruiser.wheels = new DopClassMixed(random.nextInt(2, 5));
+                            break;
+                    }
+                    repaint();
+                }
+            });
+            buttonCruiser.setBounds(20 + 150, 390, 120, 30);
+            this.add(buttonCruiser);
+
+            JButton buttonAdvancedCruiser = new JButton("Создать продвинутый объект");
+            buttonAdvancedCruiser.addActionListener(new ActionListener() {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    Random random = new Random();
+                    _drawningCruiser = new DrawingAdvancedCruiser(random.nextInt(100, 300),
+                            random.nextInt(1000, 3000),
+                            Color.getHSBColor(random.nextInt(0, 256), random.nextInt(0, 256),
+                                    random.nextInt(0, 256)), Color.getHSBColor(random.nextInt(0, 256), random.nextInt(0, 256),
+                            random.nextInt(0, 256)), random.nextBoolean(),random.nextBoolean(),random.nextBoolean(),
+                            GamePanel.SCREEN_W, GamePanel.SCREEN_H); //TODO
+                    _drawningCruiser.SetPosition(random.nextInt(10, 100), random.nextInt(10,
+                            100));
+
+                    int ornament = random.nextInt(1, 4);
+                    switch (ornament){
+                        case 1:
+                            _drawningCruiser.wheels = new NumberOfWheels(random.nextInt(2, 5));
+                            break;
+                        case 2:
+                            _drawningCruiser.wheels = new DopClassRect(random.nextInt(2, 5));
+                            break;
+                        default:
+                            _drawningCruiser.wheels = new DopClassMixed(random.nextInt(2, 5));
+                            break;
+                    }
+                    repaint();
+                }
+            });
+            buttonAdvancedCruiser.setBounds(  20, 390, 120, 30);
+            this.add(buttonAdvancedCruiser);
+            JTextField textStrategy = new JTextField();
+            textStrategy.setBounds(550, 20, 120, 30);
+            this.add(textStrategy);
+            JButton buttonStep = new JButton("Шаг");
+            buttonStep.addActionListener(new ActionListener() {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    if (_drawningCruiser == null)
+                    {
+                        return;
+                    }
+                    if (textStrategy.getText() != null)
+                    {
+                        switch(textStrategy.getText())
+                        {
+                            case "center":
+
+                                _abstractStrategy = new MoveToCenter();
+                                break;
+                            case "border":
+                                _abstractStrategy = new MoveToBorder();
+                                break;
+                        };
+
+                        if (_abstractStrategy == null)
+                        {
+                            return;
+                        }
+                        _abstractStrategy.SetData(new DrawingObjectCruiser(_drawningCruiser), SCREEN_W, SCREEN_H);
+                    }
+                    if (_abstractStrategy == null)
+                    {
+                        return;
+                    }
+                    _abstractStrategy.MakeStep();
+                    repaint();
+                    if (_abstractStrategy.GetStatus() == Status.Finish)
+                    {
+                        _abstractStrategy = null;
+                    }
+                }
+            });
+            buttonStep.setBounds(550, 60, 70, 30);
+            this.add(buttonStep);
+            JPanel panel = new JPanel(new GridBagLayout());
+            JButton up = new BasicArrowButton(BasicArrowButton.NORTH);
+            up.addActionListener(new ActionListener() {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    _drawningCruiser.MoveTransport(Direction.Up);
+                    repaint();
+                }
+            });
+            JButton left = new BasicArrowButton(BasicArrowButton.WEST);
+            left.addActionListener(new ActionListener() {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    _drawningCruiser.MoveTransport(Direction.Left);
+                    repaint();
+                }
+            });
+            JButton down = new BasicArrowButton(BasicArrowButton.SOUTH);
+            down.addActionListener(new ActionListener() {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    _drawningCruiser.MoveTransport(Direction.Down);
+                    repaint();
+                }
+            });
+            JButton right = new BasicArrowButton(BasicArrowButton.EAST);
+            right.addActionListener(new ActionListener() {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    _drawningCruiser.MoveTransport(Direction.Right);
+                    repaint();
+                }
+            });
+            up.setBounds(570, 350, 30, 30);
+            this.add(up);
+
+            down.setBounds(570, 350 + 40, 30, 30);
+            this.add(down);
+
+            left.setBounds(570 - 40, 350 + 40, 30, 30);
+            this.add(left);
+
+            right.setBounds(570 + 40, 350 + 40, 30, 30);
+            this.add(right);
+        }
+        @Override
+        public void paintComponent(Graphics g) {
+            super.paintComponent(g);
+            draw(g);
+        }
+        public void draw(Graphics g) {
+            if (_drawningCruiser != null) {
+                _drawningCruiser.DrawTransport(g);
+            }
+        }
+    }
+}

IDop.java

@@ -0,0 +1,5 @@
+import java.awt.*;
+public interface IDop {
+    public void setNumOfWheels(String num);
+    public void drawWheels(Graphics g, int _startPosX, int _startPosY, Color c);
+}

IMoveableObject.java

@@ -0,0 +1,6 @@
+public interface IMoveableObject {
+    public ObjectParameters GetObjectPosition();
+    public int GetStep();
+    boolean CheckCanMove(Direction direction);
+    void MoveObject(Direction direction);
+}

Main.java

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

MoveToBorder.java

@@ -0,0 +1,29 @@
+public class MoveToBorder extends AbstractStrategy {
+
+    protected  boolean IsTargetDestinaion()
+    {
+        var objParams = GetObjectParameters();
+        if (objParams == null) {
+            return false;
+        }
+        return objParams.RightBorder() <= FieldWidth &&
+                objParams.RightBorder() + GetStep() >= FieldWidth &&
+                objParams.DownBorder() <= FieldHeight &&
+                objParams.DownBorder() + GetStep() >= FieldHeight;
+    }
+    protected void MoveToTarget()
+    {
+        var objParams = GetObjectParameters();
+        if (objParams == null) {
+            return;
+        }
+        var diffX = FieldWidth - objParams.ObjectMiddleHorizontal();
+        if (Math.abs(diffX) > GetStep()) {
+            MoveRight();
+        }
+        var diffY = FieldHeight - objParams.ObjectMiddleVertical();
+        if (Math.abs(diffY) > GetStep()) {
+            MoveDown();
+        }
+    }
+}

MoveToCenter.java

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

NumberOfWheels.java

@@ -0,0 +1,34 @@
+import java.awt.*;
+
+public class NumberOfWheels implements IDop{
+    public int numOfWheels;
+    public NumberOfWheels(int num){
+        numOfWheels = num;
+    }
+    public void setNumOfWheels(String num){
+        switch (Integer.valueOf(num)){
+            case 2:
+                numOfWheels = NumberOfWheelsEnum.wheel_2.value;
+                break;
+            case 3:
+                numOfWheels = NumberOfWheelsEnum.wheel_3.value;
+                break;
+            case 4:
+                numOfWheels = NumberOfWheelsEnum.wheel_4.value;
+                break;
+            default:
+                numOfWheels = NumberOfWheelsEnum.wheel_2.value;
+        }
+    }
+    public void drawWheels(Graphics g, int _startPosX, int _startPosY, Color c) {
+        g.setColor(c);
+        if (numOfWheels >= 2) {
+            g.fillOval(_startPosX+55, _startPosY+15, 20, 15);
+            g.fillOval(_startPosX+55, _startPosY+30, 20, 15);
+        } if (numOfWheels >= 3) {
+            g.fillOval(_startPosX+30, _startPosY+15, 20, 15);
+        } if(numOfWheels >= 4){
+            g.fillOval(_startPosX+85, _startPosY+15, 20, 15);
+        }
+    }
+}

NumberOfWheelsEnum.java

@@ -0,0 +1,9 @@
+public enum NumberOfWheelsEnum {
+    wheel_2(2),
+    wheel_3(3),
+    wheel_4(4);
+    public int value;
+    NumberOfWheelsEnum(int value) {
+        this.value = value;
+    }
+}

ObjectParameters.java

@@ -0,0 +1,19 @@
+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;
+    }
+}

Status.java

@@ -0,0 +1,5 @@
+public enum Status {
+    NotInit,
+    InProgress,
+    Finish
+}