done

.gitignore

@@ -77,3 +77,29 @@ fabric.properties
 # Android studio 3.1+ serialized cache file
 .idea/caches/build_file_checksums.ser
 
+# ---> Java
+# Compiled class file
+*.class
+
+# Log file
+*.log
+
+# BlueJ files
+*.ctxt
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.nar
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+replay_pid*
+

.idea/misc.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="openjdk-18" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/PIbd_23_Valova_A.D._DumpTruck._Hard.iml" filepath="$PROJECT_DIR$/PIbd_23_Valova_A.D._DumpTruck._Hard.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

DumpTruck/DumpTruck.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

DumpTruck/src/Main.java

@@ -0,0 +1,5 @@
+public class Main {
+    public static void main(String[] args) {
+        System.out.println("Hello world!");
+    }
+}

PIbd_23_Valova_A.D._DumpTruck._Hard.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+      <excludeFolder url="file://$MODULE_DIR$/.idea/libraries" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

src/CarCollectionFrame.java

@@ -0,0 +1,116 @@
+import DrawingObjects.DrawingCar;
+import DrawingObjects.DrawingObjectCar;
+import Generics.*;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.text.spi.BreakIteratorProvider;
+
+public class CarCollectionFrame extends JFrame {
+    private CarsGenericCollection<DrawingCar, DrawingObjectCar> _cars;
+
+    public CarCollectionFrame() {
+        this.setSize(800, 600);
+        this.setTitle("Collection");
+        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        this.setResizable(false);
+        this.setLocationRelativeTo(null);
+
+        CollectionPanel panel = new CollectionPanel();
+
+        this.add(panel);
+        this.setVisible(true);
+    }
+
+    public class CollectionPanel extends JPanel {
+
+        static final int SCREEN_W = 800;
+        static final int SCREEN_H = 600;
+        CollectionPanel() {
+            this.setLayout(null);
+            this.setPreferredSize(new Dimension(SCREEN_W, SCREEN_H));
+
+            JTextField textFieldRemove = new JTextField();
+            textFieldRemove.setBounds(600, 200, 150, 30);
+            this.add(textFieldRemove);
+
+            JButton ButtonAddCar = new JButton("Добавить машину");
+            ButtonAddCar.setBounds(600, 150, 150, 30);
+            ButtonAddCar.addActionListener(new ActionListener() {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    GameFrame form = new GameFrame();
+                    if (form.getSelectedCar() != null) {
+                        if (_cars.plus(_cars, form.SelectedCar) != -1) {
+                            JOptionPane.showMessageDialog(null, "Объект добавлен");
+
+                        } else {
+                            JOptionPane.showMessageDialog(null, "Не удалось добавить объект");
+
+                        }
+                    }
+                    repaint();
+                }
+            });
+            this.add(ButtonAddCar);
+
+            JButton ButtonRemoveCar = new JButton("Удалить машину");
+            ButtonRemoveCar.setBounds(600, 250, 150, 30);
+            ButtonRemoveCar.addActionListener(new ActionListener() {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    if (_cars == null) {
+                        return;
+                    }
+                    String tmp = textFieldRemove.getText();
+                    int num;
+
+                    try {
+                        num = Integer.parseInt(tmp);
+                    } catch (Exception ex) {
+                        JOptionPane.showMessageDialog(null, "Введите число", "Информация", JOptionPane.INFORMATION_MESSAGE);
+                        return;
+                    }
+
+                    _cars.minus(_cars, num);
+
+                    JOptionPane.showMessageDialog(null, "Объект удален", "Информация", JOptionPane.INFORMATION_MESSAGE);
+                    repaint();
+
+                }
+            });
+            this.add(ButtonRemoveCar);
+
+            JButton ButtonRefresh = new JButton("Обновить");
+            ButtonRefresh.setBounds(600, 300, 150, 30);
+            ButtonRefresh.addActionListener(new ActionListener() {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    if (_cars == null) {
+                        return;
+                    }
+
+                    repaint();
+                }
+            });
+            this.add(ButtonRefresh);
+
+
+            _cars = new CarsGenericCollection<DrawingCar, DrawingObjectCar>(SCREEN_W, SCREEN_H);
+
+
+        }
+
+        @Override
+        public void paintComponent(Graphics g) {
+            super.paintComponent(g);
+            draw(g);
+        }
+
+        public void draw(Graphics g) {
+            _cars.ShowCars(g);
+        }
+    }
+}

src/Dop/DopClassRect.java

@@ -0,0 +1,44 @@
+package Dop;
+
+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, _startPosY + 35 + 10, 15, 15);
+            g.fillRect(_startPosX + 95, _startPosY + 35 + 10, 15, 15);
+
+        } if (numOfWheels >= 3) {
+            g.fillRect(_startPosX, _startPosY + 35 + 10, 15, 15);
+            g.fillRect(_startPosX + 15, _startPosY + 35 + 10, 15, 15);
+
+        } if (numOfWheels >= 4) {
+            g.fillRect(_startPosX + 95 - 20, _startPosY + 35 + 10, 15, 15);
+
+        }
+    }
+}
+

src/Dop/DopClassTriangle.java

@@ -0,0 +1,41 @@
+package Dop;
+
+import java.awt.*;
+
+public class DopClassTriangle implements IDop{
+    public int numOfWheels;
+
+    public DopClassTriangle(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.fillPolygon(new int[]{_startPosX, _startPosX + 15/2, _startPosX + 15}, new int[]{_startPosY + 35 + 10, _startPosY + 35 + 10 + 15/2, _startPosY + 35 + 10}, 3);
+            g.fillPolygon( new int[]{_startPosX + 95, _startPosX + 95 + 15/2, _startPosX + 95 + 15}, new int[]{_startPosY + 35 + 10, _startPosY + 35 + 10 + 15/2, _startPosY + 35 + 10}, 3);
+        } if (numOfWheels >= 3) {
+            g.fillPolygon(new int[]{_startPosX + 15, _startPosX + 15 + 15/2, _startPosX + 15 + 15}, new int[]{_startPosY + 35 + 10, _startPosY + 35 + 10 + 15/2, _startPosY + 35 + 10}, 3);
+        } if (numOfWheels >= 4) {
+            g.fillPolygon(new int[]{_startPosX + 95 - 20, _startPosX + 95 - 20 + 15/2, _startPosX + 95 - 20 + 15}, new int[]{_startPosY + 35 + 10, _startPosY + 35 + 10 + 15/2, _startPosY + 35 + 10}, 3);
+        }
+    }
+}
+

src/Dop/IDop.java

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

src/Dop/NumberOfWheels.java

@@ -0,0 +1,37 @@
+package Dop;
+
+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, _startPosY + 35 + 10, 15, 15);
+            g.fillOval(_startPosX + 95, _startPosY + 35 + 10, 15, 15);
+        } if (numOfWheels >= 3) {
+            g.fillOval(_startPosX + 15, _startPosY + 35 + 10, 15, 15);
+        } if(numOfWheels >= 4){
+            g.fillOval(_startPosX + 95 - 20, _startPosY + 35 + 10, 15, 15);
+        }
+    }
+}

src/Dop/NumberOfWheelsEnum.java

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

src/DrawingObjects/DrawingCar.java

@@ -0,0 +1,183 @@
+package DrawingObjects;
+/*import src.*;
+import src.Dop.DopClassBlack;
+import src.Dop.DopClassWhite;
+import src.Entities.*;
+import src.Dop.IDop;*/
+import Dop.DopClassTriangle;
+import Dop.DopClassRect;
+import Dop.IDop;
+import Entities.EntityCar;
+import MovementStrategy.*;
+
+import java.awt.*;
+import java.util.Random;
+
+public class DrawingCar {
+    public EntityCar EntityCar;
+
+    private int _pictureWidth;
+
+    private int _pictureHeight;
+
+    protected int _startPosX;
+
+    protected int _startPosY;
+
+    private int _carWidth = 110;
+
+    private int _carHeight = 60;
+
+    /// <summary>
+    /// Координата X объекта
+    /// </summary>
+    public int GetPosX(){return _startPosX;};
+    /// <summary>
+    /// Координата Y объекта
+    /// </summary>
+    public int GetPosY(){return _startPosY;}
+    /// <summary>
+    /// Ширина объекта
+    /// </summary>
+    public int GetWidth(){return  _carWidth;};
+    /// <summary>
+    /// Высота объекта
+    /// </summary>
+    public int GetHeight(){return _carHeight;}
+    public IDop wheels;
+
+
+
+
+    public DrawingCar(int speed, double weight, Color bodyColor, int width, int height)
+    {
+        if(width < _carWidth || height < _carHeight)
+        {
+            return;
+        }
+        _pictureWidth = width;
+        _pictureHeight = height;
+
+        EntityCar = new EntityCar(speed, weight, bodyColor);
+
+    }
+    public EntityCar getEntity(){
+        return EntityCar;
+    }
+
+    protected DrawingCar(int speed, double weight, Color bodyColor, int
+            width, int height, int carWidth, int carHeight)
+    {
+        if (width <= _carWidth || height <= _carHeight)
+        {
+            return;
+        }
+        _pictureWidth = width;
+        _pictureHeight = height;
+        _carWidth = carWidth;
+        _carHeight = carHeight;
+        EntityCar = new EntityCar(speed, weight, bodyColor);
+    }
+
+    public DrawingCar(EntityCar entityCar,IDop wheels)
+    {
+        EntityCar = entityCar;
+        this.wheels = wheels;
+        _pictureWidth = 1000;
+        _pictureHeight = 1000;
+        _carWidth = 110;
+        _carHeight = 60;
+    }
+
+    public void SetPosition(int x, int y)
+    {
+        if (x < 0 || x >= _pictureWidth || y < 0 || y >= _pictureHeight)
+        {
+            _startPosX = 0;
+            _startPosY = 0;
+        }
+        _startPosX = x;
+        _startPosY = y;
+    }
+
+    public void MoveTransport(Direction direction)
+    {
+        if (!CanMove(direction) || EntityCar == null)
+        {
+            return;
+        }
+        switch (direction)
+        {
+            //влево
+            case Left:
+                _startPosX -= (int)EntityCar.Step();
+                break;
+            //вверх
+            case Up:
+                _startPosY -= (int)EntityCar.Step();
+                break;
+            // вправо
+            case Right:
+                _startPosX += (int)EntityCar.Step();
+                break;
+            //вниз
+            case Down:
+                _startPosY += (int)EntityCar.Step();
+                break;
+        }
+    }
+
+    public boolean CanMove(Direction direction)
+    {
+        if (EntityCar == null)
+        {
+            return false;
+        }
+        switch (direction)
+        {
+            //влево
+            case Left:
+                return  (_startPosX - EntityCar.Step()) > 0;
+
+                //вверх
+            case Up:
+                return _startPosY - EntityCar.Step() > 0;
+
+                // вправо
+            case Right:
+                return _startPosX + EntityCar.Step() + _carWidth < _pictureWidth;
+
+                //вниз
+            case Down:
+                return _startPosY + EntityCar.Step() + _carHeight < _pictureHeight;
+
+            default:
+                return false;
+
+        }
+    }
+
+
+    public void DrawTransport(Graphics g)
+    {
+
+        if (EntityCar == null)
+        {
+            return;
+        }
+
+        g.setColor(EntityCar.BodyColor);
+
+        //границы автомобиля
+        g.fillRect(_startPosX, _startPosY + 35, 110, 10);
+        g.fillRect( _startPosX + 85, _startPosY, 25, 35);
+        /*g.fillOval( _startPosX, _startPosY + 35 + 10, 15, 15);
+        g.fillOval( _startPosX + 15, _startPosY + 35 + 10, 15, 15);
+        g.fillOval( _startPosX + 95, _startPosY + 35 + 10, 15, 15);*/
+
+        if (wheels == null){return;}
+        wheels.drawWheels(g, _startPosX, _startPosY, EntityCar.BodyColor);
+    }
+    public IMoveableObject GetMoveableObject(){return new DrawingObjectCar(this);}
+
+}

src/DrawingObjects/DrawingDumpTruck.java

@@ -0,0 +1,84 @@
+package DrawingObjects;
+
+
+
+import Dop.*;
+import Entities.*;
+
+import java.awt.*;
+import java.util.Random;
+
+public class DrawingDumpTruck extends DrawingCar{
+    EntityDumpTruck EntityCar;
+
+
+    public DrawingDumpTruck(int speed, double weight, Color bodyColor, Color additionalColor, boolean bodyKit, boolean tent,  boolean ornamentWheels, int width, int height) {
+        super(speed, weight, bodyColor, width, height, 110, 60);
+        {
+                EntityCar = new EntityDumpTruck(speed, weight, bodyColor, additionalColor, bodyKit, tent);
+        }
+    }
+    public DrawingDumpTruck(EntityDumpTruck entityDumpTruck,IDop wheels)
+    {
+        super(entityDumpTruck, wheels);
+        {
+            EntityCar = entityDumpTruck;
+            this.wheels = wheels;
+        }
+    }
+
+
+    public EntityDumpTruck getEntityDumpTruck(){
+        return EntityCar;
+    }
+
+    public void DrawTransport(Graphics g)
+    {
+        EntityDumpTruck dumpTruck;
+        if (EntityCar == null )
+        {
+            return;
+        }
+
+
+        Color addBrush = EntityCar.AdditionalColor;
+        Color brush = EntityCar.BodyColor;
+
+        super.DrawTransport(g);
+        if (EntityCar.Tent)
+        {
+            g.setColor(addBrush);
+            int[] pointsX = new int[3];
+            int[] pointsY = new int[3];
+            pointsX[0] = _startPosX; pointsY[0] = _startPosY + 35;
+            pointsX[1] = _startPosX + 85; pointsY[1] = _startPosY;
+            pointsX[2] = _startPosX + 85; pointsY[2] = _startPosY + 35;
+            g.fillPolygon(pointsX, pointsY, 3);
+
+        }
+
+        if (EntityCar.BodyKit)
+        {
+            g.setColor(addBrush);
+            int[] pointsX = new int[4];
+            int[] pointsY = new int[4];
+            pointsX[0] = _startPosX; pointsY[0] = _startPosY + 35;
+            pointsX[1] = _startPosX; pointsY[1] = _startPosY;
+            pointsX[2] = _startPosX + 85; pointsY[2] = _startPosY;
+            pointsX[3] = _startPosX + 85; pointsY[3] = _startPosY + 35;
+            g.fillPolygon(pointsX, pointsY, 4);
+        }
+
+        if (EntityCar.BodyKit && EntityCar.Tent)
+        {
+            g.setColor(brush);
+            int x = _startPosX;
+            int y = _startPosY - 8;
+            g.fillRect(_startPosX, _startPosY, 95, 3);
+
+        }
+
+        if (wheels == null){return;}
+        wheels.drawWheels(g, _startPosX, _startPosY, brush);
+    }
+}

src/DrawingObjects/DrawingObjectCar.java

@@ -0,0 +1,42 @@
+package DrawingObjects;
+
+import MovementStrategy.Direction;
+import MovementStrategy.IMoveableObject;
+import MovementStrategy.ObjectParameters;
+
+public class DrawingObjectCar implements IMoveableObject{
+    private DrawingCar _drawningCar;
+    public DrawingObjectCar(DrawingCar drawningCar)
+    {
+        _drawningCar = drawningCar;
+    }
+    public ObjectParameters GetObjectPosition()
+    {
+
+
+            if (_drawningCar == null || _drawningCar.EntityCar ==
+                    null)
+            {
+                return null;
+            }
+            return new ObjectParameters(_drawningCar.GetPosX(),
+                    _drawningCar.GetPosY(), _drawningCar.GetWidth(), _drawningCar.GetHeight());
+
+    }
+    public int GetStep() {
+        if(_drawningCar.getEntity() == null)
+            return 0;
+        return (int)_drawningCar.getEntity().Step();
+    }
+    public boolean CheckCanMove(Direction direction){
+        if(_drawningCar == null)
+            return false;
+        return _drawningCar.CanMove(direction);
+    }
+
+    public void MoveObject(Direction direction){
+        if(_drawningCar == null)
+            return;
+        _drawningCar.MoveTransport(direction);
+    }
+}

src/Entities/EntityCar.java

@@ -0,0 +1,40 @@
+package Entities;
+
+import java.awt.*;
+
+
+public class EntityCar
+    {
+        /// <summary>
+        /// Скорость
+        /// </summary>
+        public int Speed ;
+        /// <summary>
+        /// Вес
+        /// </summary>
+        public double Weight;
+        /// <summary>
+        /// Основной цвет
+        /// </summary>
+        public Color BodyColor;
+        /// <summary>
+        /// Шаг перемещения автомобиля
+        /// </summary>
+        public double Step() {return (double)Speed * 100 / Weight;};
+        public boolean OrnamentWheels;
+        /// <summary>
+        /// Конструктор с параметрами
+        /// </summary>
+        /// <param name="speed">Скорость</param>
+        /// <param name="weight">Вес автомобиля</param>
+        /// <param name="bodyColor">Основной цвет</param>
+        public EntityCar(int speed, double weight, Color bodyColor)
+        {
+            Speed = speed;
+            Weight = weight;
+            BodyColor = bodyColor;
+
+        }
+
+    }
+

src/Entities/EntityDumpTruck.java

@@ -0,0 +1,35 @@
+package Entities;
+
+import java.awt.*;
+
+public class EntityDumpTruck extends EntityCar{
+
+
+        /// <summary>
+        /// Дополнительный цвет (для опциональных элементов)
+        /// </summary>
+        public Color AdditionalColor;
+
+        /// <summary>
+        /// Признак (опция) наличия кузова
+        /// </summary>
+        public boolean BodyKit ;
+
+        /// <summary>
+        /// Признак (опция) наличия tent
+        /// </summary>
+        public boolean Tent ;
+
+
+        public EntityDumpTruck(int speed, double weight, Color bodyColor, Color
+        additionalColor, boolean bodyKit, boolean tent)
+        {
+            super(speed, weight, bodyColor);
+            AdditionalColor = additionalColor;
+            BodyKit = bodyKit;
+            Tent = tent;
+
+        }
+    }
+
+

src/GameFrame.java

@@ -0,0 +1,273 @@
+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;
+
+import Dop.DopClassRect;
+import Dop.DopClassTriangle;
+import Dop.NumberOfWheels;
+import Entities.*;
+import DrawingObjects.*;
+import MovementStrategy.*;
+
+public class GameFrame extends JDialog {
+    protected DrawingCar SelectedCar;
+
+    GameFrame() {
+        this.setSize(710, 535);
+        this.setTitle("DumpTruck");
+        this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
+        this.setModalExclusionType(ModalExclusionType.APPLICATION_EXCLUDE);
+        this.setModalityType(ModalityType.APPLICATION_MODAL);
+        this.setResizable(false);
+        this.setLocationRelativeTo(null);
+
+        GamePanel panel = new GamePanel();
+        this.add(panel);
+
+        this.setVisible(true);
+    }
+    public DrawingCar getSelectedCar(){
+        return SelectedCar;
+    }
+
+    public class GamePanel extends JPanel {
+        static final int SCREEN_W = 700;
+        static final int SCREEN_H = 500;
+        int xx = 0;
+        int yy = 0;
+        private DrawingCar _drawningCar;
+        private AbstractStrategy _abstractStrategy;
+        JColorChooser dialogColor = new JColorChooser();
+
+
+        GamePanel() {
+            this.setLayout(null);
+            this.setPreferredSize(new Dimension(SCREEN_W, SCREEN_H));
+            GridBagConstraints layers = new GridBagConstraints();
+
+            JButton buttonCar = new JButton("Создать грузовик");
+            buttonCar.addActionListener(new ActionListener() {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    Random random = new Random();
+                    Color color = Color.BLACK;
+
+                    Color choosenColor = JColorChooser.showDialog(getParent(), "Выберите цвет", Color.WHITE);
+                    if(choosenColor != null){
+                        color = choosenColor;
+                    }
+
+                    _drawningCar = new DrawingCar(random.nextInt(100, 300),
+                            random.nextInt(1000, 3000),
+                            color,
+                            GamePanel.SCREEN_W, GamePanel.SCREEN_H);
+                    _drawningCar.SetPosition(random.nextInt(10, 100), random.nextInt(10,
+                            100));
+
+                    int ornament = random.nextInt(1, 4);
+                    switch (ornament){
+                        case 1:
+                            _drawningCar.wheels = new NumberOfWheels(random.nextInt(2, 5));
+                            break;
+                        case 2:
+                            _drawningCar.wheels = new DopClassRect(random.nextInt(2, 5));
+                            break;
+                        default:
+                            _drawningCar.wheels = new DopClassTriangle(random.nextInt(2, 5));
+                            break;
+                    }
+                    repaint();
+                }
+            });
+            buttonCar.setBounds(20 + 150, 390, 120, 30);
+            this.add(buttonCar);
+
+            JButton buttonDumpCar = new JButton("Создать самосвал");
+            buttonDumpCar.addActionListener(new ActionListener() {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    Random random = new Random();
+                    Color color = Color.BLACK; Color colorAdd = Color.WHITE;
+
+                    Color choosenColor = JColorChooser.showDialog(getParent(), "Выберите цвет", Color.WHITE);
+                    Color choosenAddColor = JColorChooser.showDialog(getParent(), "Выберите цвет", Color.WHITE);
+
+                    if(choosenColor != null){
+                        color = choosenColor;
+                    }
+                    if(choosenAddColor != null){
+                        colorAdd = choosenAddColor;
+                    }
+
+                    _drawningCar = new DrawingDumpTruck(random.nextInt(100, 300),
+                            random.nextInt(1000, 3000),
+                            color, colorAdd, random.nextBoolean(),random.nextBoolean(),random.nextBoolean(),
+                            GamePanel.SCREEN_W, GamePanel.SCREEN_H); //TODO
+                    _drawningCar.SetPosition(random.nextInt(10, 100), random.nextInt(10,
+                            100));
+
+                    int ornament = random.nextInt(1, 4);
+                    switch (ornament){
+                        case 1:
+                            _drawningCar.wheels = new NumberOfWheels(random.nextInt(2, 5));
+                            break;
+                        case 2:
+                            _drawningCar.wheels = new DopClassRect(random.nextInt(2, 5));
+                            break;
+                        default:
+                            _drawningCar.wheels = new DopClassTriangle(random.nextInt(2, 5));
+                            break;
+                    }
+
+
+                    repaint();
+                }
+            });
+            buttonDumpCar.setBounds(  20, 390, 120, 30);
+            this.add(buttonDumpCar);
+
+            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 (_drawningCar == 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((IMoveableObject) _drawningCar, SCREEN_W, SCREEN_H);
+                        //textStrategy.setText();
+                    }
+                    if (_abstractStrategy == null)
+                    {
+
+                        return;
+                    }
+                    System.out.println("step");
+                    _abstractStrategy.MakeStep();
+                    repaint();
+                    if (_abstractStrategy.GetStatus() == Status.Finish)
+                    {
+                        //comboBoxStrategy.Enabled = true;
+                        _abstractStrategy = null;
+                    }
+                }
+            });
+            buttonStep.setBounds(550, 60, 70, 30);
+            this.add(buttonStep);
+
+            JButton up = new BasicArrowButton(BasicArrowButton.NORTH);
+            up.addActionListener(new ActionListener() {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    _drawningCar.MoveTransport(Direction.Up);
+                    repaint();
+                }
+            });
+            JButton left = new BasicArrowButton(BasicArrowButton.WEST);
+            left.addActionListener(new ActionListener() {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    _drawningCar.MoveTransport(Direction.Left);
+                    repaint();
+                }
+            });
+            JButton down = new BasicArrowButton(BasicArrowButton.SOUTH);
+            down.addActionListener(new ActionListener() {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    _drawningCar.MoveTransport(Direction.Down);
+                    repaint();
+                }
+            });
+            JButton right = new BasicArrowButton(BasicArrowButton.EAST);
+            right.addActionListener(new ActionListener() {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    _drawningCar.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);
+
+            JButton buttonSelectedCar = new JButton("Выбрать машину");
+
+            buttonSelectedCar.addActionListener(new ActionListener() {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    SelectedCar = _drawningCar;
+                    dispose();
+
+                }
+            });
+            buttonSelectedCar.setBounds(510, 100, 150, 30);
+            this.add(buttonSelectedCar);
+        }
+        private void Draw()
+        {
+            if (_drawningCar == null)
+            {
+                return;
+            }
+
+            Graphics gr =new DebugGraphics();
+            _drawningCar.DrawTransport(gr);
+
+        }
+        @Override
+        public void paintComponent(Graphics g) {
+            super.paintComponent(g);
+            draw(g);
+        }
+
+        public void draw(Graphics g) {
+            if (_drawningCar != null) {
+                _drawningCar.DrawTransport(g);
+            }
+        }
+
+    }
+    public Color ChooseColor(JFrame MonorailFrame){
+        JColorChooser dialog = new JColorChooser();
+        Color res = JColorChooser.showDialog(MonorailFrame, "Выберите цвет", Color.WHITE);
+        return res;
+    }
+}
+
+

src/Generics/CarsGenericCollection.java

@@ -0,0 +1,90 @@
+package Generics;
+
+import DrawingObjects.DrawingCar;
+import MovementStrategy.IMoveableObject;
+
+import java.awt.*;
+
+public class CarsGenericCollection<T extends DrawingCar, U extends IMoveableObject> {
+    private int _pictureWidth;
+
+    private int _pictureHeight;
+
+    private int _placeSizeWidth = 210;
+
+    private int _placeSizeHeight = 90;
+
+    private SetGeneric<T> _collection;
+    public CarsGenericCollection(int picWidth, int picHeight)
+    {
+        int width = picWidth / _placeSizeWidth;
+        int height = picHeight / _placeSizeHeight;
+        _pictureWidth = picWidth;
+        _pictureHeight = picHeight;
+        _collection = new SetGeneric<T>(width * height);
+    }
+    public int plus(CarsGenericCollection<T, U> collect, T obj)
+    {
+        if (obj == null)
+        {
+            return -1;
+        }
+        return collect._collection.Insert(obj);
+    }
+    public boolean minus(CarsGenericCollection<T, U> collect, int pos)
+    {
+        T obj = collect._collection.Get(pos);
+        if (obj != null)
+        {
+            collect._collection.Remove(pos);
+        }
+        return true;
+    }
+    public U GetU(int pos)
+    {
+        T ans = _collection.Get(pos);
+        if(ans == null)
+            return null;
+        return (U)ans.GetMoveableObject();
+    }
+
+    public void ShowCars(Graphics gr)
+    {
+        DrawBackground(gr);
+        DrawObjects(gr);
+    }
+    private void DrawBackground(Graphics g)
+    {
+        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(Graphics g)
+    {
+        DrawingCar car;
+        int numPlacesInRow = _pictureWidth / _placeSizeWidth;
+        for (int i = 0; i < _collection.Count(); i++)
+        {
+            // TODO получение объекта
+            // TODO установка позиции
+            // TODO прорисовка объекта
+            car = _collection.Get(i);
+            if (car != null)
+            {
+                car.SetPosition((i % numPlacesInRow) * _placeSizeWidth + _placeSizeWidth / 20, _placeSizeHeight * (i / numPlacesInRow) + _placeSizeHeight / 10);
+                car.DrawTransport(g);
+
+            }
+        }
+    }
+
+}

src/Generics/GenericCreate.java

@@ -0,0 +1,78 @@
+package Generics;
+import Dop.*;
+import Entities.*;
+import DrawingObjects.*;
+
+import javax.swing.*;
+import java.awt.*;
+import java.util.Random;
+import java.util.ArrayList;
+
+public class GenericCreate<T extends EntityCar, U extends IDop> {
+        ArrayList<T> _EntityCar;
+        ArrayList<U> _Wheels;
+        int pointerCars = 0;
+        int pointerWheels = 0;
+        public ArrayList<T> getEntities(){
+                return _EntityCar;
+        }
+
+        public ArrayList<U> getWheels(){
+                return _Wheels;
+        }
+        public GenericCreate(int countEntities,int countWheels){
+                _EntityCar=new ArrayList<>(countEntities);
+                _Wheels=new ArrayList<>(countWheels);
+        }
+        public int Add(T car){
+                if(pointerCars <= _EntityCar.size()){
+                        _EntityCar.add(car);
+                        pointerCars++;
+                        return pointerCars;
+                }
+                return -1;
+        }
+        public int Add(U wheels){
+                if(pointerWheels <= _Wheels.size()){
+                        _Wheels.add(wheels);
+                        pointerWheels++;
+                        return pointerWheels;
+
+                }
+                return -1;
+        }
+        public DrawingCar DrawingGeneratedCar()
+        {
+                Random rand=new Random();
+                if (_EntityCar.size() == 0 || _Wheels.size() == 0){
+                        return null;
+                }
+                T entity = (_EntityCar.get(rand.nextInt(pointerCars)));
+                U wheel = (_Wheels.get(rand.nextInt(pointerWheels)));
+                if(entity instanceof EntityDumpTruck){
+                        return new DrawingDumpTruck((EntityDumpTruck)entity, wheel);
+                }
+                return new DrawingCar(entity, wheel);
+        }
+        public DrawingCar[] DrawEntitiesCars(Graphics g, int startX, int startY) {
+                DrawingCar[] drawingCars = new DrawingCar[_EntityCar.size()];
+                int height = 70;
+                DrawingCar car;
+                DrawingDumpTruck truck;
+                for (int i = 0; i < _EntityCar.size(); i++) {
+                        if (_EntityCar.get(i) instanceof EntityDumpTruck) {
+                                truck = new DrawingDumpTruck((EntityDumpTruck) _EntityCar.get(i), null);
+                                truck.SetPosition(startX , startY + i * height);
+                                truck.DrawTransport(g);
+                        } else {
+                                car = new DrawingCar(_EntityCar.get(i), null);
+                                car.SetPosition(startX , startY + i * height);
+                                car.DrawTransport(g);
+                        }
+
+                }
+                return drawingCars;
+
+        }
+
+}

src/Generics/SetGeneric.java

@@ -0,0 +1,56 @@
+package Generics;
+
+public class SetGeneric<T extends Object> {
+    private Object[] _places;
+
+    public int Count() {
+        return _places.length;
+    }
+
+    public SetGeneric(int count)
+    {
+        _places = new Object[count];
+    }
+
+    public int Insert(T car)
+    {
+        return Insert(car,0);
+    }
+
+    public int Insert(T car, int position)
+    {
+        if (!(position >= 0 && position < Count()))
+            return -1;
+        if (_places[position] != null)
+        {
+            int indexEnd = position + 1;
+            while (_places[indexEnd] != null)
+            {
+                indexEnd++;
+            }
+            for (int i = indexEnd + 1; i > position; i--)
+            {
+                _places[i] = _places[i - 1];
+            }
+
+        }
+        _places[position] = car;
+        return position;
+    }
+
+    public boolean Remove(int position)
+    {
+        if (position < Count() && position >= 0)
+        {
+            _places[position] = null;
+            return true;
+        }
+        return false;
+    }
+
+    public T Get(int position)
+    {
+        if (position < Count() && position >= 0) { return (T)_places[position]; }
+        return null;
+    }
+}

src/Main.java

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

src/MovementStrategy/AbstractStrategy.java

@@ -0,0 +1,108 @@
+package MovementStrategy;
+
+public abstract class AbstractStrategy {
+    /// <summary>
+    /// Перемещаемый объект
+    /// </summary>
+    private IMoveableObject _moveableObject;
+    /// <summary>
+    /// Статус перемещения
+    /// </summary>
+    private Status _state = Status.NotInit;
+    /// <summary>
+    /// Ширина поля
+    /// </summary>
+    protected int FieldWidth;
+    /// <summary>
+    /// Высота поля
+    /// </summary>
+    protected int FieldHeight;
+    /// <summary>
+    /// Статус перемещения
+    /// </summary>
+    public Status GetStatus() { return _state; }
+    /// <summary>
+    /// Установка данных
+    /// </summary>
+    /// <param name="moveableObject">Перемещаемый объект</param>
+    /// <param name="width">Ширина поля</param>
+    /// <param name="height">Высота поля</param>
+    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;
+    }
+    /// <summary>
+    /// Шаг перемещения
+    /// </summary>
+    public void MakeStep()
+    {
+
+        if (_state != Status.InProgress)
+        {
+            return;
+        }
+        if (IsTargetDestinaion())
+        {
+            _state = Status.Finish;
+            return;
+        }
+        MoveToTarget();
+    }
+    /// <summary>
+    /// Перемещение влево
+    /// </summary>
+    /// <returns>Результат перемещения (true - удалось переместиться, false - неудача)</returns>
+    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(){ return _moveableObject.GetObjectPosition();}
+    protected int GetStep()
+    {
+        if (_state != Status.InProgress)
+        {
+            return Integer.parseInt(null);
+        }
+        return _moveableObject.GetStep();
+    }
+    /// <summary>
+    /// Перемещение к цели
+    /// </summary>
+    protected abstract void MoveToTarget();
+    /// <summary>
+    /// Достигнута ли цель
+    /// </summary>
+    /// <returns></returns>
+    protected abstract boolean IsTargetDestinaion();
+    /// <summary>
+    /// Попытка перемещения в требуемом направлении
+    /// </summary>
+    /// <param name="directionType">Направление</param>
+    /// <returns>Результат попытки (true - удалось переместиться, false - неудача)</returns>
+    private boolean MoveTo(Direction directionType)
+    {
+        if (_state != Status.InProgress)
+        {
+            return false;
+        }
+        if (_moveableObject.CheckCanMove(directionType))
+        {
+            _moveableObject.MoveObject(directionType);
+            return true;
+        }
+        else {
+            return false;
+        }
+
+    }
+}
+

src/MovementStrategy/Direction.java

@@ -0,0 +1,11 @@
+package MovementStrategy;
+
+public enum Direction {
+
+        Up,
+        Down,
+        Left,
+        Right
+
+}
+

src/MovementStrategy/DrawingObjectCar.java

@@ -0,0 +1,34 @@
+package MovementStrategy;
+
+import DrawingObjects.DrawingCar;
+import Entities.*;
+
+public class DrawingObjectCar implements IMoveableObject {
+    private DrawingCar _drawningCar = null;
+
+    public DrawingObjectCar(DrawingCar drawningCar) {
+        _drawningCar = drawningCar;
+    }
+
+    public ObjectParameters GetObjectPosition() {
+        if (_drawningCar == null || _drawningCar.EntityCar == null) {
+            return null;
+        }
+        return new ObjectParameters(_drawningCar.GetPosX(), _drawningCar.GetPosY(), _drawningCar.GetWidth(), _drawningCar.GetHeight());
+    }
+
+    public int GetStep() {
+        return (int) (_drawningCar.EntityCar.Step());
+    }
+
+    public boolean CheckCanMove(Direction direction) {
+        if (_drawningCar.CanMove(direction)){
+            return true;
+        }
+        return false;
+    }
+
+    public void MoveObject(Direction direction) {
+        _drawningCar.MoveTransport(direction);
+    }
+}

src/MovementStrategy/EntityDumpTruck.java

@@ -0,0 +1,4 @@
+package MovementStrategy;
+
+public class EntityDumpTruck {
+}

src/MovementStrategy/IMoveableObject.java

@@ -0,0 +1,21 @@
+package MovementStrategy;
+
+
+public interface IMoveableObject {
+    /// <summary>
+    /// Получение координаты X объекта
+    /// </summary>
+    public ObjectParameters GetObjectPosition();
+    /// <summary>
+    /// Шаг объекта
+    /// </summary>
+    public int GetStep();
+
+    boolean CheckCanMove(Direction direction);
+    /// <summary>
+    /// Изменение направления пермещения объекта
+    /// </summary>
+    /// <param name="direction">Направление</param>
+    void MoveObject(Direction direction);
+}
+

src/MovementStrategy/MoveToBorder.java

@@ -0,0 +1,40 @@
+package MovementStrategy;
+
+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();
+
+            }
+        }
+
+    }
+

src/MovementStrategy/MoveToCenter.java

@@ -0,0 +1,46 @@
+package MovementStrategy;
+
+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();
+            }
+        }
+    }
+
+}
+
+

src/MovementStrategy/ObjectParameters.java

@@ -0,0 +1,51 @@
+package MovementStrategy;
+
+public class ObjectParameters {
+
+        private final int _x;
+        private final int _y;
+        private final int _width;
+        private final int _height;
+
+
+        /// <summary>
+        /// Левая граница
+        /// </summary>
+        public int LeftBorder(){return _x;}
+
+    /// <summary>
+        /// Верхняя граница
+        /// </summary>
+        public int TopBorder(){return _y;}
+        /// <summary>
+        /// Правая граница
+        /// </summary>
+        public int RightBorder(){return _x + _width;}
+        /// <summary>
+        /// Нижняя граница
+        /// </summary>
+        public int DownBorder(){return  _y + _height;}
+        /// <summary>
+        /// Середина объекта
+        /// </summary>
+        public int ObjectMiddleHorizontal(){return _x + _width / 2;}
+        /// <summary>
+        /// Середина объекта
+        /// </summary>
+        public int ObjectMiddleVertical(){return  _y + _height / 2;}
+        /// <summary>
+        /// Конструктор
+        /// </summary>
+        /// <param name="x">Координата X</param>
+        /// <param name="y">Координата Y</param>
+        /// <param name="width">Ширина</param>
+        /// <param name="height">Высота</param>
+        public ObjectParameters(int x, int y, int width, int height)
+        {
+            _x = x;
+            _y = y;
+            _width = width;
+            _height = height;
+        }
+    }
+

src/MovementStrategy/Status.java

@@ -0,0 +1,10 @@
+package MovementStrategy;
+
+public enum Status {
+
+
+        NotInit,
+        InProgress,
+        Finish
+
+}

src/RandomFrame.java

@@ -0,0 +1,189 @@
+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.Arrays;
+import java.util.Random;
+
+import Dop.DopClassRect;
+import Dop.DopClassTriangle;
+import Dop.IDop;
+import Dop.NumberOfWheels;
+import Entities.*;
+import DrawingObjects.*;
+import Entities.EntityDumpTruck;
+import Generics.GenericCreate;
+import MovementStrategy.*;
+
+public class RandomFrame extends JFrame {
+    RandomPanel panel = new RandomPanel();
+    RandomFrame() {
+        this.setSize(710, 535);
+        this.setTitle("DumpTruckRandom");
+        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        this.setResizable(false);
+        this.setLocationRelativeTo(null);
+
+
+        this.add(panel);
+
+        this.setVisible(true);
+    }
+
+    public class RandomPanel extends JPanel {
+        static final int SCREEN_W = 700;
+        static final int SCREEN_H = 500;
+        GenericCreate<EntityCar, IDop> _genericCreate = new GenericCreate<>(10, 10);
+
+        ComponentsPanel entitiesPanel = new ComponentsPanel();
+        ComponentsPanel wheelsPanel = new ComponentsPanel();
+        DrawingCar generatedCar;
+        RandomPanel() {
+            this.setLayout(null);
+            this.setPreferredSize(new Dimension(SCREEN_W, SCREEN_H));
+
+
+
+            JButton buttonCar = new JButton("Создать грузовик");
+            buttonCar.setBounds(20, 20, 130, 30);
+            buttonCar.addActionListener(new ActionListener() {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+
+                    GameFrame dialogWindow = new GameFrame();
+                    if (dialogWindow.getSelectedCar() != null){
+                        if (dialogWindow.getSelectedCar() instanceof DrawingDumpTruck) {
+                            _genericCreate.Add(((DrawingDumpTruck) dialogWindow.getSelectedCar()).getEntityDumpTruck());
+                        }
+                        else {
+                            _genericCreate.Add(dialogWindow.getSelectedCar().EntityCar);
+                        }
+                        repaint();}
+
+                        else{
+                        System.out.println("Selected car is null!");
+                        }
+
+
+                    }
+
+                });
+            this.add(buttonCar);
+
+            JButton buttonIDop = new JButton("Создать колеса");
+            buttonIDop.addActionListener(new ActionListener() {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    Random random = new Random();
+                    IDop interWheels;
+                    switch(random.nextInt(1, 4)){
+                        case 1:
+                            interWheels = new NumberOfWheels(random.nextInt(2, 5));
+                            break;
+                        case 2:
+                            interWheels = new DopClassRect(random.nextInt(2, 5));
+                            break;
+                        default:
+                            interWheels = new DopClassTriangle(random.nextInt(2, 5));
+                            break;
+                    }
+
+                    _genericCreate.Add(interWheels);
+                    repaint();
+
+                }
+            });
+            buttonIDop.setBounds(20 + 130 + 20, 20, 130, 30);
+            this.add(buttonIDop);
+
+            JButton buttonCreateRandomCar = new JButton("Сгенерировать машину");
+            buttonCreateRandomCar.addActionListener(new ActionListener() {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    generatedCar = _genericCreate.DrawingGeneratedCar();
+                    if (generatedCar != null) {
+                        generatedCar.SetPosition(430, 160);
+                    }
+                    repaint();
+
+                }
+            });
+            buttonCreateRandomCar.setBounds(20 + 130 + 20 + 235, 20 + 80, 190, 30);
+            this.add(buttonCreateRandomCar);
+
+
+            /*entitiesPanel.setLocation(20, 20 + 50);
+            this.add(entitiesPanel);*/
+
+            /*wheelsPanel.setLocation(20 + 150, 20 + 50);
+            this.add(wheelsPanel);*/
+
+            /*CarRandomPanel carRandomPanel = new CarRandomPanel();
+            carRandomPanel.setLocation(400, 150);
+            this.add(carRandomPanel);*/
+
+        }
+        @Override
+        public void paintComponent(Graphics g) {
+            super.paintComponent(g);
+            draw(g);
+        }
+
+        public void draw(Graphics g) {
+            int startX = 20 ;
+            int startY = 70;
+
+            int startXForWheels = 170;
+            int startYForWheels = 30;
+            int height = 70;
+            int width = 110;
+            _genericCreate.DrawEntitiesCars(g, startX, startY);
+
+            for (int i=0; i < _genericCreate.getWheels().size(); i++) {
+                _genericCreate.getWheels().get(i).drawWheels(g, startXForWheels, startYForWheels + i * 30, Color.black);
+            }
+
+            if (generatedCar != null){
+                generatedCar.DrawTransport(g);
+            }
+        }
+    }
+
+    public class ComponentsPanel extends JPanel {
+        static final int SCREEN_W = 130;
+        static final int SCREEN_H = 400;
+
+        ComponentsPanel() {
+            this.setSize(SCREEN_W, SCREEN_H);
+            //this.setBackground(Color.WHITE);
+        }
+        @Override
+        public void paintComponent(Graphics g) {
+            super.paintComponent(g);
+
+        }
+
+        public void draw(Graphics g) {
+
+        }
+    }
+    public class CarRandomPanel extends JPanel {
+        static final int SCREEN_W = 200;
+        static final int SCREEN_H = 200;
+
+        CarRandomPanel() {
+            this.setSize(SCREEN_W, SCREEN_H);
+            this.setBackground(Color.LIGHT_GRAY);
+        }
+        @Override
+        public void paintComponent(Graphics g) {
+            super.paintComponent(g);
+            draw(g);
+        }
+
+        public void draw(Graphics g) {
+
+        }
+    }
+    }