Сдано

.idea/PIbd-23-Salin-O.A.-Monorail-Hard.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>

.idea/misc.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="17" 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$/.idea/PIbd-23-Salin-O.A.-Monorail-Hard.iml" filepath="$PROJECT_DIR$/.idea/PIbd-23-Salin-O.A.-Monorail-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="" vcs="Git" />
+  </component>
+</project>

src/MonorailHard/DrawningObjects/DrawningLocomotive.java

@@ -0,0 +1,67 @@
+package MonorailHard.DrawningObjects;
+
+import MonorailHard.Entities.EntityLocomotive;
+
+import javax.swing.*;
+import java.awt.*;
+
+public class DrawningLocomotive extends DrawningMonorail{
+
+    public DrawningLocomotive(int speed, double weight, Color bodyColor, Color wheelColor, Color tireColor, int wheelNumb,
+                            int width, int height, boolean secondCabine, boolean magniteRail, Color additionalColor){
+        super(speed, weight, bodyColor, wheelColor, tireColor, width, height);
+        if(EntityMonorail() != null){
+            EntityMonorail = new EntityLocomotive(speed, weight, bodyColor, wheelColor, tireColor, wheelNumb, secondCabine,
+                    magniteRail, additionalColor);
+        }
+    }
+
+    public void ChangeAddColor(Color col){
+        ((EntityLocomotive)EntityMonorail).AdditionalColor = col;
+    }
+
+    @Override
+    public void DrawMonorail(Graphics2D g2d){
+        if (!(EntityMonorail instanceof EntityLocomotive))
+        {
+            return;
+        }
+        super.DrawMonorail(g2d);
+        int dif = _monorailWidth / 10;
+        _monorailWidth -= dif;
+        EntityLocomotive _locomotive = (EntityLocomotive) EntityMonorail;
+        //вторая кабина
+        if (_locomotive.SecondCabine()) {
+            int[] pointsSecondCabineX = {_startPosX + _monorailWidth / 20 * 19,
+                    _startPosX + _monorailWidth + dif,
+                    _startPosX + _monorailWidth + dif,
+                    _startPosX + _monorailWidth / 20 * 19};
+            int[] pointsSecondCabineY = {_startPosY + _monorailHeight / 10,
+                    _startPosY + _monorailHeight / 5 * 2,
+                    _startPosY + _monorailHeight / 10 * 7,
+                    _startPosY + _monorailHeight / 10 * 7};
+            g2d.setColor(((EntityLocomotive) EntityMonorail).AdditionalColor());
+            g2d.fillPolygon(pointsSecondCabineX, pointsSecondCabineY, pointsSecondCabineX.length);
+            g2d.setColor(Color.BLACK);
+            g2d.drawPolygon(pointsSecondCabineX, pointsSecondCabineY, pointsSecondCabineX.length);
+            Rectangle Rect = new Rectangle();
+            Rect.x = _startPosX + _monorailWidth / 20 * 19;
+            Rect.y = _startPosY + _monorailHeight / 25 * 4 + _monorailHeight / 50 * 3;
+            Rect.width = _monorailWidth / 120 * 6;
+            Rect.height = _monorailHeight / 50 * 7;
+            g2d.setColor(Color.WHITE);
+            g2d.fillRect(Rect.x, Rect.y, Rect.width, Rect.height);
+            g2d.setColor(Color.BLUE);
+            g2d.drawRect(Rect.x, Rect.y, Rect.width, Rect.height);
+        }
+
+        _monorailWidth+=dif;
+
+        //магнитная линия
+        if (_locomotive.MagniteRail())
+        {
+            g2d.setColor(Color.BLACK);
+            g2d.drawLine(_startPosX, _startPosY + _monorailHeight, _startPosX + _monorailWidth, _startPosY + _monorailHeight);
+        }
+    }
+}

src/MonorailHard/DrawningObjects/DrawningMonorail.java

@@ -1,48 +1,89 @@
-package MonorailHard;
+package MonorailHard.DrawningObjects;
+
+import MonorailHard.DirectionType;
+import MonorailHard.Entities.EntityMonorail;
+import MonorailHard.MovementStrategy.DrawningObjectMonorail;
+import MonorailHard.MovementStrategy.IMoveableObject;
+import com.sun.source.tree.ImportTree;
 
 import javax.swing.*;
-import javax.swing.text.html.parser.Entity;
 import java.awt.*;
 import java.util.Random;
 
 public class DrawningMonorail {
 
-    JPanel MonorailPanel;
+    protected EntityMonorail EntityMonorail;
-    private EntityMonorail EntityMonorail;
+    public int _pictureWidth;
-    private int _pictureWidth;
+    public int _pictureHeight;
-    private int _pictureHeight;
+    protected int _startPosX;
-    private int _startPosX = 0;
+    protected int _startPosY;
-    private int _startPosY = 0;
+    public int _monorailWidth = 133;
-    private int _monorailWidth = 133;
+    public int _wheelNumb;
-    private int _monorailHeight = 50;
+    public int _monorailHeight = 50;
-    private DrawningWheels DrawningWheels;
+    protected IDraw DrawningWheels;
 
     protected int wheelSz;
-
-
     public EntityMonorail EntityMonorail(){
         return EntityMonorail;
     }
-    public boolean Init(int speed, double weight, Color bodyColor, Color wheelColor, Color tireColor, int wheelNumb,
+    public DrawningMonorail(int speed, double weight, Color bodyColor, Color wheelColor, Color tireColor,
-                               int width, int height, boolean secondCabine, boolean magniteRail, JPanel monorailPanel){
+                               int width, int height){
         if(width <= _monorailWidth || height <= _monorailHeight)
-            return false;
+            return;
         _startPosY=0;
         _startPosX = 0;
-        monorailPanel.setSize(width, height);
-        MonorailPanel = monorailPanel;
-        monorailPanel.paint(MonorailPanel.getGraphics());
         wheelSz = _monorailHeight - _monorailHeight * 7 / 10;
         _pictureWidth = width;
         _pictureHeight = height;
-        EntityMonorail = new EntityMonorail();
+        EntityMonorail = new EntityMonorail(speed, weight, bodyColor, wheelColor, tireColor);
-        EntityMonorail.Init(speed, weight, bodyColor, wheelColor, tireColor, wheelNumb, secondCabine, magniteRail);
         int dif = _monorailWidth / 10;
-        DrawningWheels = new DrawningWheels();
+        DrawningWheels = new DrawningWheelsCart(_monorailWidth - dif, _monorailHeight,_startPosX,_startPosY,wheelColor,tireColor);
-        DrawningWheels.Init(_monorailWidth - dif, _monorailHeight,_startPosX,_startPosY,wheelColor,tireColor,monorailPanel);
         Random rand = new Random();
+        int variant = rand.nextInt(0, 3);
+        if(variant == 0)
+            DrawningWheels = new DrawningWheels(_monorailWidth - dif, _monorailHeight,_startPosX,_startPosY,wheelColor,tireColor);
+        else if(variant == 1)
+            DrawningWheels = new DrawningWheelsCart(_monorailWidth - dif, _monorailHeight,_startPosX,_startPosY,wheelColor,tireColor);
+        else
+            DrawningWheels = new DrawningWheelsOrn(_monorailWidth - dif, _monorailHeight,_startPosX,_startPosY,wheelColor,tireColor);
         DrawningWheels.ChangeWheelsNumb(rand.nextInt(1, 6));
-        return true;
+    }
+
+    public void ChangeIDraw(IDraw obj){
+        DrawningWheels = obj;
+        obj.ChangeWheelsNumb(_wheelNumb);
+        obj.ChangeWheelsNumb(_wheelNumb);
+        obj.ChangeX(_startPosX);
+        obj.ChangeY(_startPosY);
+    }
+    public void ChangeWheelsNumb(int numb){
+        _wheelNumb = numb;
+        DrawningWheels.ChangeWheelsNumb(numb);
+    }
+    protected DrawningMonorail(int speed, double weight, Color bodyColor, Color wheelColor, Color tireColor,
+                            int width, int height, int monorailWidth, int monorailHeight){
+        if(width <= _monorailWidth || height <= _monorailHeight)
+            return;
+        _startPosY=0;
+        _startPosX = 0;
+        wheelSz = _monorailHeight - _monorailHeight * 7 / 10;
+        _pictureWidth = width;
+        _pictureHeight = height;
+        _monorailWidth = monorailWidth;
+        _monorailHeight = monorailHeight;
+        EntityMonorail = new EntityMonorail(speed, weight, bodyColor, wheelColor, tireColor);
+        int dif = _monorailWidth / 10;
+        Random rand = new Random();
+        int variant = rand.nextInt(0, 3);
+        if(variant == 0)
+            DrawningWheels = new DrawningWheels(_monorailWidth - dif, _monorailHeight,_startPosX,_startPosY,wheelColor,tireColor);
+        else if(variant == 1)
+            DrawningWheels = new DrawningWheelsCart(_monorailWidth - dif, _monorailHeight,_startPosX,_startPosY,wheelColor,tireColor);
+        else
+            DrawningWheels = new DrawningWheelsOrn(_monorailWidth - dif, _monorailHeight,_startPosX,_startPosY,wheelColor,tireColor);
+
+        DrawningWheels.ChangeWheelsNumb(rand.nextInt(1, 6));
+
     }
 
     public void SetPosition(int x, int y){
@@ -50,49 +91,76 @@ public class DrawningMonorail {
             return;
         _startPosX = x;
         _startPosY = y;
-        if(x + _monorailWidth <= _pictureWidth|| y + _monorailHeight <= _pictureHeight){
+        DrawningWheels.ChangeX(_startPosX);
+        DrawningWheels.ChangeY(_startPosY);
+        if(x + _monorailWidth >= _pictureWidth|| y + _monorailHeight >= _pictureHeight || x < 0 || y < 0){
             _startPosX = 0;
             _startPosY = 0;
         }
     }
 
-    public void MoveTransport(DirectionType direction){
+    public int GetPosX(){return _startPosX;}
+    public int GetPosY(){return _startPosY;}
+    public int GetWidth(){return _monorailWidth;}
+    public int GetHeight(){return _monorailHeight;}
+    public boolean CanMove(DirectionType direction)
+    {
         if (EntityMonorail == null)
+            return false;
+        boolean can = false;
+        switch (direction)
+        {
+            case Left:
+                can = _startPosX - EntityMonorail.Step() >= 0;
+                break;
+            case Right:
+                can = _startPosX + EntityMonorail.Step() + _monorailWidth< _pictureWidth;
+                break;
+            case Down:
+                can = _startPosY + EntityMonorail.Step() + _monorailHeight < _pictureHeight;
+                break;
+            case Up:
+                can = _startPosY - EntityMonorail.Step() >= 0;
+                break;
+        };
+        return can;
+    }
+
+    public IMoveableObject GetMoveableObject(){
+        return new DrawningObjectMonorail(this);
+    }
+
+    public void MoveTransport(DirectionType direction){
+        if (!CanMove(direction) || EntityMonorail == null)
             return;
-        MonorailPanel.paint(MonorailPanel.getGraphics());
         switch (direction)
         {
             case Left:
                 if (_startPosX - EntityMonorail.Step() >= 0)
                     _startPosX -= (int)EntityMonorail.Step();
-                else
-                    _startPosX = 0;
                 break;
             case Up:
                 if (_startPosY - EntityMonorail.Step() >= 0)
                     _startPosY -= (int)EntityMonorail.Step();
-                else
-                    _startPosY = 0;
                 break;
             case Right:
-                if (_startPosX + EntityMonorail.Step() + _monorailWidth < _pictureWidth)
+                if (_startPosX + EntityMonorail.Step() + _monorailWidth <=  _pictureWidth)
                     _startPosX += (int)EntityMonorail.Step();
-                else
-                    _startPosX = _pictureWidth - _monorailWidth;
                 break;
             case Down:
-                if (_startPosY + EntityMonorail.Step() + _monorailHeight < _pictureHeight)
+                if (_startPosY + EntityMonorail.Step() + _monorailHeight <= _pictureHeight)
                     _startPosY += (int)EntityMonorail.Step();
-                else
-                    _startPosY = _pictureHeight - _monorailHeight;
                 break;
         }
-        DrawningWheels.CurX = _startPosX;
+        DrawningWheels.ChangeX(_startPosX);
-        DrawningWheels.CurY = _startPosY;
+        DrawningWheels.ChangeY(_startPosY);
     }
 
-    public void DrawMonorail(){
+    public void ChangeColor(Color col){
-        Graphics2D g2d = (Graphics2D)MonorailPanel.getGraphics();
+        EntityMonorail.BodyColor = col;
+    }
+
+    public void DrawMonorail(Graphics2D g2d){
         if (EntityMonorail == null)
             return;
         int dif = _monorailWidth / 10;
@@ -141,25 +209,6 @@ public class DrawningMonorail {
         g2d.setColor(Color.BLACK);
         g2d.drawPolygon(xPointsArrDoor, yPointsArrDoor, xPointsArrDoor.length);
 
-
-//передняя часть тележки
-        int[] xPointsArrFrontCart = { _startPosX + _monorailWidth / 10 * 4, _startPosX + _monorailWidth / 10 * 2,
-                _startPosX, _startPosX + _monorailWidth / 10 * 4,
-                _startPosX + _monorailWidth / 10 * 4};
-        int[] yPointsArrFrontCart = { _startPosY + _monorailHeight / 10 * 7, _startPosY + _monorailHeight / 10 * 7,
-             _startPosY + _monorailHeight / 10 * 9, _startPosY + _monorailHeight / 10 * 9,
-                _startPosY + _monorailHeight / 10 * 7};
-        g2d.setColor(Color.BLACK);
-        g2d.fillPolygon(xPointsArrFrontCart, yPointsArrFrontCart, xPointsArrFrontCart.length);
-
-//задняя часть тележки
-        int[] xPointsArrBackCart = {_startPosX + _monorailWidth / 10 * 6, _startPosX + _monorailWidth / 10 * 9,
-               _startPosX + _monorailWidth, _startPosX + _monorailWidth / 10 * 6};
-        int[] yPointsArrBackCart = { _startPosY + _monorailHeight / 10 * 7, _startPosY + _monorailHeight / 10 * 7,
-                _startPosY + _monorailHeight / 10 * 9, _startPosY + _monorailHeight / 10 * 9};
-
-        g2d.fillPolygon(xPointsArrBackCart, yPointsArrBackCart, xPointsArrBackCart.length);
-
 //левое окно
         Rectangle leftRect = new Rectangle();
         leftRect.x = _startPosX + _monorailWidth / 10 * 2;
@@ -193,43 +242,8 @@ public class DrawningMonorail {
         g2d.fillRect(rightRect.x, rightRect.y, rightRect.width, rightRect.height);
         g2d.setColor(Color.BLUE);
         g2d.drawRect(rightRect.x, rightRect.y, rightRect.width, rightRect.height);
-
+//колеса
-        //вторая кабина
+        DrawningWheels.DrawWheels(g2d);
-        if (EntityMonorail.SecondCabine())
+        _monorailWidth += dif;
-        {
-            int[] pointsSecondCabineX = { _startPosX + _monorailWidth / 20 * 19,
-                   _startPosX + _monorailWidth + dif,
-                    _startPosX + _monorailWidth + dif,
-                    _startPosX + _monorailWidth / 20 * 19};
-            int[] pointsSecondCabineY = { _startPosY + _monorailHeight / 10,
-            _startPosY + _monorailHeight / 5 * 2,
-            _startPosY + _monorailHeight / 10 * 7,
-            _startPosY + _monorailHeight / 10 * 7};
-            g2d.setColor(EntityMonorail.BodyColor());
-            g2d.fillPolygon(pointsSecondCabineX, pointsSecondCabineY, pointsSecondCabineX.length);
-            g2d.setColor(Color.BLACK);
-            g2d.drawPolygon(pointsSecondCabineX, pointsSecondCabineY, pointsSecondCabineX.length);
-            Rectangle Rect = new Rectangle();
-            Rect.x = _startPosX + _monorailWidth / 20 * 19;
-            Rect.y = _startPosY + _monorailHeight / 25 * 4 + _monorailHeight / 50 * 3;
-            Rect.width = _monorailWidth / 120 * 6;
-            Rect.height = _monorailHeight / 50 * 7;
-            g2d.setColor(Color.WHITE);
-            g2d.fillRect(Rect.x, Rect.y, Rect.width, Rect.height);
-            g2d.setColor(Color.BLUE);
-            g2d.drawRect(Rect.x, Rect.y, Rect.width, Rect.height);
-        }
-        DrawningWheels.DrawWheels();
-
-        _monorailWidth+=dif;
-
-        //магнитная линия
-        if (EntityMonorail.MagniteRail())
-        {
-            g2d.setColor(Color.BLACK);
-            g2d.drawLine(_startPosX, _startPosY + _monorailHeight, _startPosX + _monorailWidth, _startPosY + _monorailHeight);
-        }
     }
-
-
 }

src/MonorailHard/DrawningObjects/DrawningWheels.java

@@ -0,0 +1,84 @@
+package MonorailHard.DrawningObjects;
+
+import MonorailHard.NumberType;
+
+import javax.swing.*;
+import java.awt.*;
+
+public class DrawningWheels implements IDraw{
+    private int WheelSz;
+    private NumberType WheelsNumb;
+    private Color WheelColor, TireColor;
+    private int Width, Height;
+    protected int CurX, CurY;
+    public int WheelSz(){
+        return WheelSz;
+    }
+
+    public DrawningWheels(int width, int height, int curX, int curY, Color wheelColor, Color tireColor){
+        Width = width;
+        Height = height;
+        CurX = curX;
+        CurY = curY;
+        WheelColor = wheelColor;
+        TireColor = tireColor;
+        WheelSz = Height - Height * 7 / 10;
+    }
+    public void ChangeX(int x){
+        CurX = x;
+    }
+    public void ChangeY(int y){
+        CurY = y;
+    }
+    public void ChangeWheelsNumb(int x){
+        if(x <= 2)
+            WheelsNumb = NumberType.Two;
+        if(x == 3)
+            WheelsNumb = NumberType.Three;
+        if(x >= 4)
+            WheelsNumb = NumberType.Four;
+    }
+
+    public NumberType WheelsNumb(){
+        return WheelsNumb;
+    }
+
+    public void DrawWheel(Graphics2D g2d, int x, int y){
+        g2d.setColor(WheelColor);
+        g2d.fillOval( x, y , WheelSz, WheelSz);
+        g2d.setColor(TireColor);
+        g2d.drawOval(x, y, WheelSz, WheelSz);
+    }
+
+    public void DrawWheels(Graphics2D g2d){
+        //передняя часть тележки
+        int[] xPointsArrFrontCart = { CurX + Width / 10 * 4, CurX + Width / 10 * 2,
+                CurX, CurX + Width / 10 * 4,
+                CurX + Width / 10 * 4};
+        int[] yPointsArrFrontCart = { CurY + Height / 10 * 7, CurY + Height / 10 * 7,
+                CurY + Height / 10 * 9, CurY + Height / 10 * 9,
+                CurY + Height / 10 * 7};
+        g2d.setColor(Color.BLACK);
+        g2d.fillPolygon(xPointsArrFrontCart, yPointsArrFrontCart, xPointsArrFrontCart.length);
+
+//задняя часть тележки
+        int[] xPointsArrBackCart = {CurX + Width / 10 * 6, CurX + Width / 10 * 9,
+                CurX + Width, CurX + Width / 10 * 6};
+        int[] yPointsArrBackCart = { CurY + Height / 10 * 7, CurY + Height / 10 * 7,
+                CurY + Height / 10 * 9, CurY + Height / 10 * 9};
+
+        g2d.fillPolygon(xPointsArrBackCart, yPointsArrBackCart, xPointsArrBackCart.length);
+
+        DrawWheel(g2d, CurX + Width / 10, CurY + Height / 10 * 7);
+        DrawWheel(g2d, CurX + Width / 10 * 8, CurY + Height / 10 * 7);
+//3 колеса
+        if (WheelsNumb == NumberType.Three || WheelsNumb == NumberType.Four)
+            DrawWheel(g2d,CurX + Width / 10 * 6, CurY + Height / 10 * 7);
+
+//4 колеса
+        if (WheelsNumb == NumberType.Four)
+            DrawWheel(g2d, CurX + Width / 10 * 3, CurY + Height / 10 * 7);
+    }
+
+
+}

src/MonorailHard/DrawningObjects/DrawningWheelsCart.java

@@ -0,0 +1,89 @@
+package MonorailHard.DrawningObjects;
+
+import MonorailHard.NumberType;
+
+import javax.swing.*;
+import java.awt.*;
+
+public class DrawningWheelsCart implements IDraw{
+    private int WheelSz;
+    private NumberType WheelsNumb;
+    private Color WheelColor, TireColor;
+    private int Width, Height;
+    public int CurX, CurY;
+    public int WheelSz(){
+        return WheelSz;
+    }
+
+    public DrawningWheelsCart(int width, int height, int curX, int curY, Color wheelColor, Color tireColor){
+        Width = width;
+        Height = height;
+        CurX = curX;
+        CurY = curY;
+        WheelColor = wheelColor;
+        TireColor = tireColor;
+        WheelSz = Height - Height * 7 / 10;
+    }
+
+    public void ChangeWheelsNumb(int x){
+        if(x <= 2)
+            WheelsNumb = NumberType.Two;
+        if(x == 3)
+            WheelsNumb = NumberType.Three;
+        if(x >= 4)
+            WheelsNumb = NumberType.Four;
+    }
+
+    public NumberType WheelsNumb(){
+        return WheelsNumb;
+    }
+
+    public void ChangeX(int x){
+        CurX = x;
+    }
+    public void ChangeY(int y){
+        CurY = y;
+    }
+    public void DrawWheel(Graphics2D g2d, int x, int y){
+        g2d.setColor(WheelColor);
+        g2d.fillOval( x, y , WheelSz, WheelSz);
+        g2d.setColor(TireColor);
+        g2d.drawOval(x, y, WheelSz, WheelSz);
+    }
+
+    public void DrawWheels(Graphics2D g2d){
+        //передняя часть тележки
+        int[] xPointsArrFrontCart = { CurX + Width / 10 * 4, CurX + Width / 10 * 2,
+                CurX, CurX + Width / 10 * 4,
+                CurX + Width / 10 * 4};
+        int[] yPointsArrFrontCart = { CurY + Height / 10 * 7, CurY + Height / 10 * 7,
+                CurY + Height / 10 * 9, CurY + Height / 10 * 9,
+                CurY + Height / 10 * 7};
+        g2d.setColor(Color.BLACK);
+        g2d.fillPolygon(xPointsArrFrontCart, yPointsArrFrontCart, xPointsArrFrontCart.length);
+        g2d.setColor(Color.WHITE);
+        g2d.drawLine(CurX + Width / 10 * 2, CurY + Height / 10 * 7,CurX + Width / 10 * 4,  CurY + Height / 10 * 9);
+        g2d.drawLine(CurX + Width / 10 * 4, CurY + Height / 10 * 7,CurX + Width / 10 * 2,  CurY + Height / 10 * 9);
+
+//задняя часть тележки
+        int[] xPointsArrBackCart = {CurX + Width / 10 * 6, CurX + Width / 10 * 9,
+                CurX + Width, CurX + Width / 10 * 6};
+        int[] yPointsArrBackCart = { CurY + Height / 10 * 7, CurY + Height / 10 * 7,
+                CurY + Height / 10 * 9, CurY + Height / 10 * 9};
+        g2d.setColor(Color.BLACK);
+        g2d.fillPolygon(xPointsArrBackCart, yPointsArrBackCart, xPointsArrBackCart.length);
+        g2d.setColor(Color.WHITE);
+        g2d.drawLine(CurX + Width / 10 * 6, CurY + Height / 10 * 7,CurX + Width / 10 * 9,  CurY + Height / 10 * 9);
+        g2d.drawLine(CurX + Width / 10 * 9, CurY + Height / 10 * 7,CurX + Width / 10 * 6,  CurY + Height / 10 * 9);
+
+        DrawWheel(g2d, CurX + Width / 10, CurY + Height / 10 * 7);
+        DrawWheel(g2d, CurX + Width / 10 * 8, CurY + Height / 10 * 7);
+//3 колеса
+        if (WheelsNumb == NumberType.Three || WheelsNumb == NumberType.Four)
+            DrawWheel(g2d, CurX + Width / 10 * 6, CurY + Height / 10 * 7);
+
+//4 колеса
+        if (WheelsNumb == NumberType.Four)
+            DrawWheel(g2d, CurX + Width / 10 * 3, CurY + Height / 10 * 7);
+    }
+}

src/MonorailHard/DrawningObjects/DrawningWheelsOrn.java

@@ -0,0 +1,85 @@
+package MonorailHard.DrawningObjects;
+
+import MonorailHard.NumberType;
+
+import javax.swing.*;
+import java.awt.*;
+
+public class DrawningWheelsOrn implements IDraw{
+    private int WheelSz;
+    private NumberType WheelsNumb;
+    private Color WheelColor, TireColor;
+    private int Width, Height;
+    public int CurX, CurY;
+    public int WheelSz(){
+        return WheelSz;
+    }
+
+    public DrawningWheelsOrn(int width, int height, int curX, int curY, Color wheelColor, Color tireColor){
+        Width = width;
+        Height = height;
+        CurX = curX;
+        CurY = curY;
+        WheelColor = wheelColor;
+        TireColor = tireColor;
+        WheelSz = Height - Height * 7 / 10;
+    }
+
+    public void ChangeWheelsNumb(int x){
+        if(x <= 2)
+            WheelsNumb = NumberType.Two;
+        if(x == 3)
+            WheelsNumb = NumberType.Three;
+        if(x >= 4)
+            WheelsNumb = NumberType.Four;
+    }
+
+    public NumberType WheelsNumb(){
+        return WheelsNumb;
+    }
+
+    public void ChangeX(int x){
+        CurX = x;
+    }
+    public void ChangeY(int y){
+        CurY = y;
+    }
+    public void DrawWheel(Graphics2D g2d, int x, int y){
+        g2d.setColor(WheelColor);
+        g2d.fillOval( x, y , WheelSz, WheelSz);
+        g2d.setColor(TireColor);
+        g2d.drawOval(x, y, WheelSz, WheelSz);
+        g2d.drawLine(x, y + WheelSz / 2, x + WheelSz, y + WheelSz / 2);
+        g2d.drawLine(x + WheelSz / 2, y, x + WheelSz / 2, y + WheelSz);
+    }
+
+    public void DrawWheels(Graphics2D g2d){
+        //передняя часть тележки
+        int[] xPointsArrFrontCart = { CurX + Width / 10 * 4, CurX + Width / 10 * 2,
+                CurX, CurX + Width / 10 * 4,
+                CurX + Width / 10 * 4};
+        int[] yPointsArrFrontCart = { CurY + Height / 10 * 7, CurY + Height / 10 * 7,
+                CurY + Height / 10 * 9, CurY + Height / 10 * 9,
+                CurY + Height / 10 * 7};
+        g2d.setColor(Color.BLACK);
+        g2d.fillPolygon(xPointsArrFrontCart, yPointsArrFrontCart, xPointsArrFrontCart.length);
+
+//задняя часть тележки
+        int[] xPointsArrBackCart = {CurX + Width / 10 * 6, CurX + Width / 10 * 9,
+                CurX + Width, CurX + Width / 10 * 6};
+        int[] yPointsArrBackCart = { CurY + Height / 10 * 7, CurY + Height / 10 * 7,
+                CurY + Height / 10 * 9, CurY + Height / 10 * 9};
+
+        g2d.fillPolygon(xPointsArrBackCart, yPointsArrBackCart, xPointsArrBackCart.length);
+
+        DrawWheel(g2d, CurX + Width / 10, CurY + Height / 10 * 7);
+        DrawWheel(g2d,CurX + Width / 10 * 8, CurY + Height / 10 * 7);
+//3 колеса
+        if (WheelsNumb == NumberType.Three || WheelsNumb == NumberType.Four)
+            DrawWheel(g2d,CurX + Width / 10 * 6, CurY + Height / 10 * 7);
+
+//4 колеса
+        if (WheelsNumb == NumberType.Four)
+            DrawWheel(g2d,CurX + Width / 10 * 3, CurY + Height / 10 * 7);
+    }
+}

src/MonorailHard/DrawningObjects/IDraw.java

@@ -0,0 +1,14 @@
+package MonorailHard.DrawningObjects;
+
+import MonorailHard.NumberType;
+
+import java.awt.*;
+
+public interface IDraw {
+    public void ChangeWheelsNumb(int x);
+    public NumberType WheelsNumb();
+    public void DrawWheels(Graphics2D g2d);
+    public void DrawWheel(Graphics2D g2d, int x, int y);
+    public void ChangeX(int x);
+    public void ChangeY(int y);
+}

src/MonorailHard/DrawningWheels.java

@@ -1,73 +0,0 @@
-package MonorailHard;
-
-import javax.swing.*;
-import java.awt.*;
-
-public class DrawningWheels {
-    private int WheelSz;
-    JPanel MonorailPanel;
-    private NumberType WheelsNumb;
-    private Color WheelColor, TireColor;
-    private int Width, Height;
-    public int CurX, CurY;
-    public int WheelSz(){
-        return WheelSz;
-    }
-
-    boolean Init(int width, int height, int curX, int curY, Color wheelColor, Color tireColor, JPanel monorailPanel){
-        Width = width;
-        Height = height;
-        CurX = curX;
-        CurY = curY;
-        WheelColor = wheelColor;
-        TireColor = tireColor;
-        WheelSz = Height - Height * 7 / 10;
-        MonorailPanel = monorailPanel;
-        return true;
-    }
-
-    public void ChangeWheelsNumb(int x){
-        if(x <= 2)
-            WheelsNumb = NumberType.Two;
-        if(x == 3)
-            WheelsNumb = NumberType.Three;
-        if(x >= 4)
-            WheelsNumb = NumberType.Four;
-    }
-
-    public NumberType WheelsNumb(){
-        return WheelsNumb;
-    }
-
-    public void DrawWheels(){
-        Graphics2D g2d = (Graphics2D)MonorailPanel.getGraphics();
-        g2d.setColor(WheelColor);
-        g2d.fillOval( CurX + Width / 10, CurY + Height / 10 * 7, WheelSz, WheelSz);
-        g2d.setColor(TireColor);
-        g2d.drawOval(CurX + Width / 10, CurY + Height / 10 * 7, WheelSz, WheelSz);
-        g2d.setColor(WheelColor);
-        g2d.fillOval(CurX + Width / 10 * 8, CurY + Height / 10 * 7, WheelSz, WheelSz);
-        g2d.setColor(TireColor);
-        g2d.drawOval(CurX + Width / 10 * 8, CurY + Height / 10 * 7, WheelSz, WheelSz);
-
-//3 колеса
-        if (WheelsNumb == NumberType.Three || WheelsNumb == NumberType.Four)
-        {
-            g2d.setColor(WheelColor);
-            g2d.fillOval(CurX + Width / 10 * 6, CurY + Height / 10 * 7, WheelSz, WheelSz);
-            g2d.setColor(TireColor);
-            g2d.drawOval(CurX + Width / 10 * 6, CurY + Height / 10 * 7, WheelSz, WheelSz);
-        }
-
-//4 колеса
-        if (WheelsNumb == NumberType.Four)
-        {
-            g2d.setColor(WheelColor);
-            g2d.fillOval(CurX + Width / 10 * 3, CurY + Height / 10 * 7, WheelSz, WheelSz);
-            g2d.setColor(TireColor);
-            g2d.drawOval(CurX + Width / 10 * 3, CurY + Height / 10 * 7, WheelSz, WheelSz);
-        }
-    }
-
-
-}

src/MonorailHard/Entities/EntityLocomotive.java

@@ -0,0 +1,20 @@
+package MonorailHard.Entities;
+
+import java.awt.*;
+
+public class EntityLocomotive extends EntityMonorail{
+    public Color AdditionalColor;
+    private boolean SecondCabine;
+    private boolean MagniteRail;
+    public Color AdditionalColor(){return AdditionalColor;};
+    public boolean SecondCabine(){return SecondCabine;};
+    public boolean MagniteRail(){return MagniteRail;};
+    public EntityLocomotive(int speed, double weight, Color bodyColor, Color wheelColor, Color tireColor, int wheelNumb,
+                            boolean secondCabine, boolean magniteRail, Color additionalColor) {
+        super(speed, weight, bodyColor, wheelColor, tireColor);
+        AdditionalColor = additionalColor;
+        SecondCabine = secondCabine;
+        MagniteRail = magniteRail;
+    }
+
+}

src/MonorailHard/Entities/EntityMonorail.java

@@ -1,20 +1,15 @@
-package MonorailHard;
+package MonorailHard.Entities;
 import java.awt.*;
 
 public class EntityMonorail {
-    private int Speed, WheelNumb;
+    private int Speed;
     private double Weight, Step;
-    private Color BodyColor, WheelColor, TireColor;
+    public Color BodyColor, WheelColor, TireColor;
-    private boolean MagniteRail;
-    private boolean SecondCabine;
 
     public int Speed(){
         return Speed;
     }
 
-    public int WheelNumb(){
-        return WheelNumb;
-    }
     public double Weight(){
         return Weight;
     }
@@ -30,18 +25,12 @@ public class EntityMonorail {
     public Color TireColor(){
         return TireColor;
     }
-    public boolean SecondCabine(){return SecondCabine;}
+    public EntityMonorail(int speed, double weight, Color bodyColor, Color wheelColor, Color tireColor){
-    public boolean MagniteRail(){return MagniteRail;}
-    public void Init(int speed, double weight, Color bodyColor, Color wheelColor, Color tireColor, int wheelNumb,
-                     boolean secondCabine, boolean magniteRail){
         Speed = speed;
         Weight = weight;
         Step = (double)Speed * 100 / Weight;
         BodyColor = bodyColor;
         WheelColor = wheelColor;
         TireColor = tireColor;
-        WheelNumb = wheelNumb;
-        SecondCabine = secondCabine;
-        MagniteRail = magniteRail;
     }
 }

src/MonorailHard/FormMonorail.java

@@ -0,0 +1,241 @@
+package MonorailHard;
+
+import MonorailHard.DrawningObjects.DrawningLocomotive;
+import MonorailHard.DrawningObjects.DrawningMonorail;
+import MonorailHard.MovementStrategy.*;
+import org.w3c.dom.ranges.DocumentRange;
+
+import javax.swing.*;
+import javax.swing.text.AbstractDocument;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.util.Random;
+
+
+public class FormMonorail{
+
+    private DrawningMonorail DrawningMonorail;
+    private AbstractStrategy _abstractStrategy;
+
+    public JButton buttonSelect;
+
+    public JFrame MonorailFrame;
+
+    Canvas canv;
+    static int pictureBoxWidth = 882;
+    static int pictureBoxHeight = 453;
+
+    public Color ChooseColor(JFrame MonorailFrame){
+        JColorChooser dialog = new JColorChooser();
+        Color res = JColorChooser.showDialog(MonorailFrame, "Выберите цвет", Color.WHITE);
+        return res;
+    }
+
+    public DrawningMonorail SelectedMonorail(){
+        return DrawningMonorail;
+    }
+    public void Draw(){
+        if(DrawningMonorail == null)
+            return;
+        canv.repaint();
+    }
+
+    public void ChangeMonorail(DrawningMonorail newMonorail){
+        newMonorail.SetPosition(0,0);
+        DrawningMonorail = newMonorail;
+        canv.DrawningMonorail = DrawningMonorail;
+
+    }
+
+    public FormMonorail(){
+        MonorailFrame =new JFrame ();
+        JButton buttonCreate = new JButton("Создать");
+        JButton buttonCreateLocomotive = new JButton("Создать локомотив");
+        JButton buttonStep = new JButton("Шаг");
+        buttonSelect = new JButton ("Выбрать");
+        JComboBox comboBoxStrategy = new JComboBox(
+                new String[]{
+                        "Довести до центра",
+                        "Довести до края",
+                });
+        JButton UpButton = new JButton();
+        UpButton.setIcon(new ImageIcon("C:\\Users\\frenk\\IdeaProjects\\PIbd-13-Salin-O.A.-Monorail-Hard\\src\\UpButton.png"));
+        JButton DownButton = new JButton();
+        DownButton.setIcon(new ImageIcon("C:\\Users\\frenk\\IdeaProjects\\PIbd-13-Salin-O.A.-Monorail-Hard\\src\\DownButton.png"));
+        JButton LeftButton = new JButton();
+        LeftButton.setIcon(new ImageIcon("C:\\Users\\frenk\\IdeaProjects\\PIbd-13-Salin-O.A.-Monorail-Hard\\src\\LeftButton.png"));
+        JButton RightButton = new JButton();
+        RightButton.setIcon(new ImageIcon("C:\\Users\\frenk\\IdeaProjects\\PIbd-13-Salin-O.A.-Monorail-Hard\\src\\RightButton.png"));
+        buttonStep.addActionListener(
+                new ActionListener() {
+                    public void actionPerformed(ActionEvent e){
+                        if (DrawningMonorail == null)
+                        {
+                            return;
+                        }
+                        if (comboBoxStrategy.isEnabled())
+                        {
+                            switch (comboBoxStrategy.getSelectedIndex())
+                            {
+                                case 0:
+                                    _abstractStrategy = new MoveToCenter();
+                                    break;
+                                case 1:
+                                    _abstractStrategy = new MoveToBorder();
+                                    break;
+                                default:
+                                    _abstractStrategy = null;
+                                    break;
+                            };
+                            if (_abstractStrategy == null)
+                            {
+                                return;
+                            }
+                            _abstractStrategy.SetData(new
+                                            DrawningObjectMonorail(DrawningMonorail), pictureBoxWidth,
+                                    pictureBoxHeight);
+                            comboBoxStrategy.setEnabled(false);
+                        }
+                        if (_abstractStrategy == null)
+                        {
+                            return;
+                        }
+                        _abstractStrategy.MakeStep();
+                        Draw();
+                        if (_abstractStrategy.GetStatus() == Status.Finish)
+                        {
+                            comboBoxStrategy.setEnabled(true);
+                            _abstractStrategy = null;
+                        }
+                    }
+                }
+        );
+        buttonCreate.addActionListener(
+                new ActionListener() {
+                    @Override
+                    public void actionPerformed(ActionEvent e) {
+                        Random random = new Random();
+                        Color color = new Color(random.nextInt(0, 256), random.nextInt(0, 256), random.nextInt(0, 256));
+                        Color choosen = ChooseColor(MonorailFrame);
+                        if(choosen != null){
+                            color = choosen;
+                        }
+                        DrawningMonorail = new DrawningMonorail(random.nextInt(100, 300), random.nextDouble(1000, 3000),
+                                color,
+                                Color.getHSBColor(random.nextInt(0, 301), random.nextInt(0, 301), random.nextInt(0, 301)),
+                                Color.getHSBColor(random.nextInt(0, 301), random.nextInt(0, 301), random.nextInt(0, 301)),
+                                pictureBoxWidth, pictureBoxHeight);
+                        canv.DrawningMonorail = DrawningMonorail;
+                        comboBoxStrategy.enable(true);
+                        Draw();
+                    }
+                }
+        );
+        buttonCreateLocomotive.addActionListener(
+                new ActionListener() {
+                    public void actionPerformed(ActionEvent e){
+                        Random random = new Random();
+                        Color color = new Color(random.nextInt(0, 256), random.nextInt(0, 256), random.nextInt(0, 256));
+                        Color additionalColor = new Color(random.nextInt(0, 256), random.nextInt(0, 256), random.nextInt(0, 256));
+                        Color choosen = ChooseColor(MonorailFrame);
+                        if(choosen != null){
+                            color = choosen;
+                        }
+                        choosen = ChooseColor(MonorailFrame);
+                        if(choosen != null){
+                            additionalColor = choosen;
+                        }
+                        DrawningMonorail = new DrawningLocomotive(random.nextInt(100, 300), random.nextDouble(1000, 3000),
+                                color,
+                                Color.getHSBColor(random.nextInt(0, 301), random.nextInt(0, 301), random.nextInt(0, 301)),
+                                Color.getHSBColor(random.nextInt(0, 301), random.nextInt(0, 301), random.nextInt(0, 301)),
+                                random.nextInt(1, 6),
+                                pictureBoxWidth, pictureBoxHeight, random.nextBoolean(), random.nextBoolean(),
+                                additionalColor);
+                        canv.DrawningMonorail = DrawningMonorail;
+                        comboBoxStrategy.enable(true);
+                        Draw();
+                    }
+                }
+        );
+
+        RightButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                if(DrawningMonorail.EntityMonorail() == null) {
+                    return;
+                }
+                DrawningMonorail.MoveTransport(DirectionType.Right);
+                Draw();
+            }
+        });
+        LeftButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                if(DrawningMonorail.EntityMonorail() == null)
+                    return;
+                DrawningMonorail.MoveTransport(DirectionType.Left);
+                Draw();
+            }
+        });
+        UpButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                if(DrawningMonorail.EntityMonorail() == null)
+                    return;
+                DrawningMonorail.MoveTransport(DirectionType.Up);
+                Draw();
+            }
+        });
+        DownButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                if(DrawningMonorail.EntityMonorail() == null)
+                    return;
+                DrawningMonorail.MoveTransport(DirectionType.Down);
+                Draw();
+            }
+        });
+
+        MonorailFrame.setSize (900, 500);
+        MonorailFrame.setDefaultCloseOperation (JFrame.DISPOSE_ON_CLOSE);
+        MonorailFrame.setLayout(null);
+        canv = new Canvas();
+        canv.setSize(pictureBoxWidth, pictureBoxHeight);
+        buttonSelect.setBounds(383,401, 180, 40);
+        buttonCreate.setBounds(198, 401, 180, 40);
+        buttonCreateLocomotive.setBounds(12, 401, 180, 40);
+        RightButton.setBounds(840,411,30,30);
+        LeftButton.setBounds(768,411,30,30);
+        UpButton.setBounds(804,375,30,30);
+        DownButton.setBounds(804,411,30,30);
+        comboBoxStrategy.setBounds(719,12,151,28);
+        buttonStep.setBounds(768, 46, 94, 29);
+        MonorailFrame.add(canv);
+        MonorailFrame.add(buttonCreate);
+        MonorailFrame.add(buttonCreateLocomotive);
+        MonorailFrame.add(UpButton);
+        MonorailFrame.add(DownButton);
+        MonorailFrame.add(LeftButton);
+        MonorailFrame.add(RightButton);
+        MonorailFrame.add(comboBoxStrategy);
+        MonorailFrame.add(buttonStep);
+        MonorailFrame.add(buttonSelect);
+        MonorailFrame.setVisible(true);
+    }
+}
+class Canvas extends JComponent{
+    public DrawningMonorail DrawningMonorail;
+    public Canvas(){
+    }
+    public void paintComponent (Graphics g){
+        if (DrawningMonorail == null){
+            return;
+        }
+        super.paintComponents (g) ;
+        Graphics2D g2d = (Graphics2D)g;
+        DrawningMonorail.DrawMonorail(g2d);
+        super.repaint();
+    }
+}

src/MonorailHard/FormMonorailCollection.java

@@ -0,0 +1,216 @@
+package MonorailHard;
+
+import MonorailHard.DrawningObjects.DrawningMonorail;
+import MonorailHard.Generics.MonorailGenericCollection;
+import MonorailHard.Generics.MonorailGenericStorage;
+import MonorailHard.Generics.MonorailTrashCollection;
+import MonorailHard.MovementStrategy.DrawningObjectMonorail;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.text.Normalizer;
+import java.util.List;
+
+
+public class FormMonorailCollection {
+    private final MonorailGenericStorage _storage;
+
+    private JList<String> listBoxStorages;
+    private DefaultListModel<String> listBoxModel;
+    private int pictureBoxWidth = 605;
+    private int pictureBoxHeight = 426;
+
+    CollectionCanvas canv;
+
+    void Draw(){
+        if(canv == null)
+            return;
+        canv.repaint();
+    }
+
+    private void ReloadObjects(){
+        int index = listBoxStorages.getSelectedIndex();
+        listBoxModel.clear();
+        List<String> keys = _storage.Keys();
+        for(int i = 0; i < keys.size(); i++){
+            listBoxModel.addElement(keys.get(i));
+        }
+        if(listBoxModel.size() > 0 && (index == -1 || index >= listBoxModel.size()))
+            listBoxStorages.setSelectedIndex(0);
+        else if(listBoxModel.size() > 0)
+            listBoxStorages.setSelectedIndex(index);
+    }
+
+    public FormMonorailCollection(){
+        MonorailTrashCollection<DrawningMonorail> _trashCollection = new MonorailTrashCollection<>();
+        JButton callTrashButton = new JButton("мусор");
+        _storage = new MonorailGenericStorage(pictureBoxWidth, pictureBoxHeight);
+        JScrollPane scrollPane = new JScrollPane();
+        canv = new CollectionCanvas();
+        JPanel toolBox = new JPanel();
+        JTextField storageName = new JTextField();
+        JButton addStorageButton = new JButton("Добавить набор");
+        listBoxModel = new DefaultListModel<>();
+        listBoxStorages= new JList<>(listBoxModel);
+        scrollPane.setViewportView(listBoxStorages);
+        JButton delStorageButton = new JButton("Удалить набор");
+        toolBox.setBounds(623,12, 227, 80);
+        JFrame collectionFrame = new JFrame();
+        collectionFrame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
+        collectionFrame.setSize(880,497);
+        toolBox.setBounds(623, 12, 227, 426);
+        canv.setBounds(12,12,pictureBoxWidth,pictureBoxHeight);
+        JButton addButton = new JButton("Добавить");
+        JButton removeButton = new JButton("Удалить");
+        JButton refreshButton = new JButton("Обновить");
+        JTextField monorailNumb = new JTextField();
+        GridLayout lay = new GridLayout(9,1);
+        toolBox.add(storageName);
+        toolBox.add(addStorageButton);
+        toolBox.add(scrollPane);
+        toolBox.add(delStorageButton);
+        toolBox.setLayout(lay);
+        toolBox.add(addButton);
+        toolBox.add(monorailNumb);
+        toolBox.add(removeButton);
+        toolBox.add(refreshButton);
+        toolBox.add(callTrashButton);
+        collectionFrame.add(toolBox);
+        collectionFrame.add(canv);
+        collectionFrame.setVisible(true);
+        canv._storage = _storage;
+        canv.listBoxStorages = listBoxStorages;
+
+        addStorageButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                if(storageName.getText() == null)
+                    return;
+                _storage.AddSet(storageName.getText());
+                ReloadObjects();
+            }
+        });
+
+        delStorageButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                if(listBoxStorages.getSelectedIndex() == -1) {
+                    return;
+                }
+                _storage.DelSet(listBoxStorages.getSelectedValue());
+                ReloadObjects();
+            }
+        });
+
+        callTrashButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                if(_trashCollection.GetSize() == 0)
+                    return;
+                FormMonorail form = new FormMonorail();
+                form.ChangeMonorail(_trashCollection.GetTop());
+                _trashCollection.Pop();
+            }
+        });
+
+        addButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                if(listBoxStorages.getSelectedIndex() == -1) {
+                    return;
+                }
+                MonorailGenericCollection<DrawningMonorail, DrawningObjectMonorail> _monorails = _storage.Get(listBoxStorages.getSelectedValue());
+                FormMonorailConfig form = new FormMonorailConfig();
+                form.addButton.addActionListener(new ActionListener() {
+                    @Override
+                    public void actionPerformed(ActionEvent e) {
+                        if (_monorails.Insert(form._monorail))
+                        {
+                            JOptionPane.showMessageDialog(null, "Объект добавлен", "Информация", JOptionPane.INFORMATION_MESSAGE);
+                            form._monorail._pictureWidth = pictureBoxWidth;
+                            form._monorail._pictureHeight = pictureBoxHeight;
+                            Draw();
+                        }
+                        else
+                        {
+                            JOptionPane.showMessageDialog(null, "Не удалось добавить объект", "Информация", JOptionPane.INFORMATION_MESSAGE);
+                        }
+                        form.frameConfig.dispose();
+                        Draw();
+                    }
+                });
+                form.cancelButton.addActionListener(new ActionListener() {
+                    @Override
+                    public void actionPerformed(ActionEvent e) {
+                        form.frameConfig.dispose();
+                        Draw();
+                    }
+                });
+            }
+        });
+        removeButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                if(listBoxStorages.getSelectedIndex() == -1) {
+                    return;
+                }
+                MonorailGenericCollection<DrawningMonorail, DrawningObjectMonorail> _monorails = _storage.Get(listBoxStorages.getSelectedValue());
+                if(_monorails == null) {
+                    return;
+                }
+                String tmp = monorailNumb.getText();
+                int numb;
+
+                try{
+                    numb = Integer.parseInt(tmp);
+                }
+                catch(Exception ex){
+                    JOptionPane.showMessageDialog(null, "Введите число", "Информация", JOptionPane.INFORMATION_MESSAGE);
+                    return;
+                }
+                DrawningMonorail curMonorail = _monorails.Get(numb);
+                _trashCollection.Push(curMonorail);
+                _monorails.Remove(numb);
+                _monorails.ShowMonorails();
+                JOptionPane.showMessageDialog(null, "Объект удален", "Информация", JOptionPane.INFORMATION_MESSAGE);
+                Draw();
+            }
+        });
+
+        refreshButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                if(listBoxStorages.getSelectedIndex() == -1) {
+                    return;
+                }
+                MonorailGenericCollection<DrawningMonorail, DrawningObjectMonorail> _monorails = _storage.Get(listBoxStorages.getSelectedValue());
+                if(_monorails == null) {
+                    return;
+                }
+                _monorails.ShowMonorails();
+                Draw();
+            }
+        });
+    }
+}
+
+class CollectionCanvas extends JComponent {
+    public MonorailGenericStorage _storage;
+    public JList<String> listBoxStorages;
+
+
+    public CollectionCanvas(){
+    }
+    @Override
+    public void paintComponent (Graphics g){
+        if (listBoxStorages == null || listBoxStorages.getSelectedIndex() == -1){
+            return;
+        }
+        super.paintComponents (g) ;
+        Graphics2D g2d = (Graphics2D)g;
+        g2d.drawImage(_storage.Get(listBoxStorages.getSelectedValue()).ShowMonorails(), 0, 0, this);
+        super.repaint();
+    }
+}

src/MonorailHard/FormMonorailConfig.java

@@ -0,0 +1,472 @@
+package MonorailHard;
+
+import MonorailHard.DrawningObjects.*;
+
+import java.awt.*;
+import java.awt.datatransfer.DataFlavor;
+import java.awt.datatransfer.StringSelection;
+import java.awt.datatransfer.Transferable;
+import java.awt.datatransfer.UnsupportedFlavorException;
+import java.util.*;
+import javax.swing.*;
+import javax.swing.border.Border;
+
+import java.awt.event.*;
+import java.io.IOException;
+
+import static java.lang.Integer.parseInt;
+
+
+public class FormMonorailConfig {
+    private class LabelTransferHandler extends TransferHandler {
+        @Override
+        public int getSourceActions(JComponent c) {
+            return TransferHandler.COPY;
+        }
+
+        @Override
+        protected Transferable createTransferable(JComponent c) {
+            return new StringSelection(((JLabel)c).getText());
+        }
+    }
+
+    private class ColorTransferable implements Transferable {
+        private Color color;
+        private static final DataFlavor colorDataFlavor = new DataFlavor(Color.class, "Color");
+
+        public ColorTransferable(Color color) {
+            this.color = color;
+        }
+
+        @Override
+        public DataFlavor[] getTransferDataFlavors() {
+            return new DataFlavor[]{colorDataFlavor};
+        }
+
+        @Override
+        public boolean isDataFlavorSupported(DataFlavor flavor) {
+            return colorDataFlavor.equals(flavor);
+        }
+
+        @Override
+        public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
+            if (isDataFlavorSupported(flavor)) {
+                return color;
+            } else {
+                throw new UnsupportedFlavorException(flavor);
+            }
+        }
+    }
+
+    private class iDrawTransferable implements Transferable {
+        private IDraw iDrawObject;
+        private static final DataFlavor iDrawDataFlavor = new DataFlavor(IDraw.class, "IDraw");
+
+
+
+        public iDrawTransferable(IDraw iDrawObject) {
+            this.iDrawObject = iDrawObject;
+        }
+
+        @Override
+        public DataFlavor[] getTransferDataFlavors() {
+            return new DataFlavor[]{iDrawDataFlavor};
+        }
+
+        @Override
+        public boolean isDataFlavorSupported(DataFlavor flavor) {
+            return iDrawDataFlavor.equals(flavor);
+        }
+
+        @Override
+        public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
+            if (isDataFlavorSupported(flavor)) {
+                return iDrawObject;
+            } else {
+                throw new UnsupportedFlavorException(flavor);
+            }
+        }
+    }
+
+    private class PanelTransferHandler extends TransferHandler {
+        @Override
+        public int getSourceActions(JComponent c) {
+            return TransferHandler.COPY;
+        }
+
+        @Override
+        protected Transferable createTransferable(JComponent c) {
+            return new ColorTransferable(((JPanel)c).getBackground());
+        }
+    }
+
+    private class LabelMouseAdapter extends MouseAdapter{
+        @Override
+        public void mousePressed(MouseEvent e) {
+            ((JLabel)e.getComponent()).getTransferHandler().exportAsDrag(((JLabel)e.getComponent()), e, TransferHandler.COPY);
+        }
+    }
+
+
+    private class PanelMouseAdapter extends MouseAdapter{
+        @Override
+        public void mousePressed(MouseEvent e) {
+            ((JPanel)e.getComponent()).getTransferHandler().exportAsDrag(((JPanel)e.getComponent()), e, TransferHandler.COPY);
+        }
+    }
+
+    private class IDrawComponent extends JComponent{
+        public IDraw obj;
+
+        public IDrawComponent(IDraw obj){
+            this.obj = obj;
+            this.addMouseListener(
+                    new  MouseAdapter(){
+                        @Override
+                        public void mousePressed(MouseEvent e) {
+                                ((IDrawComponent)e.getComponent()).getTransferHandler().exportAsDrag(((IDrawComponent)e.getComponent()), e, TransferHandler.COPY);
+                        }
+                    }
+            );
+            this.setTransferHandler(
+                    new TransferHandler(){
+                        @Override
+                        public int getSourceActions(JComponent c) {
+                            return TransferHandler.COPY;
+                        }
+
+                        @Override
+                        protected Transferable createTransferable(JComponent c) {
+                            return new iDrawTransferable(((IDrawComponent)c).obj);
+                        }
+                    }
+            );
+        }
+
+    }
+
+    public JFrame frameConfig;
+
+    public JButton addButton;
+    public JButton cancelButton;
+    public DrawningMonorail _monorail;
+    int _pictureBoxWidth = 218;
+    int _pictureBoxHeight = 190;
+
+    public FormMonorailConfig(){
+        frameConfig = new JFrame();
+        addButton = new JButton("Добавить");
+        cancelButton = new JButton("Отмена");
+        addButton.setBounds(555,262,94,29);
+        cancelButton.setBounds(679,262,94,29);
+        Canvas canv = new Canvas();
+        canv.setBorder(BorderFactory.createLineBorder(Color.BLACK, 2));
+        canv.setBounds(555, 65, _pictureBoxWidth, _pictureBoxHeight);
+        JLabel iDrawLabel = new JLabel("Орнамент");
+        JLabel colorLabel = new JLabel("Цвет");
+        DrawningMonorail toGetSize = new DrawningMonorail(0,0, null, null, null, 0, 0);
+        IDrawComponent cartComp = new IDrawComponent(new DrawningWheelsCart(toGetSize._monorailWidth - toGetSize._monorailWidth / 10,
+                toGetSize._monorailHeight,
+                _pictureBoxWidth / 2 -toGetSize._monorailWidth / 2,
+                _pictureBoxHeight / 2 -toGetSize._monorailHeight / 2, Color.GRAY, Color.BLACK));
+        IDrawComponent ornComp = new IDrawComponent(new DrawningWheelsOrn(toGetSize._monorailWidth - toGetSize._monorailWidth / 10,
+                toGetSize._monorailHeight,
+                _pictureBoxWidth / 2 -toGetSize._monorailWidth / 2,
+                _pictureBoxHeight / 2 -toGetSize._monorailHeight / 2, Color.GRAY, Color.BLACK));
+        IDrawComponent baseComp = new IDrawComponent(new DrawningWheels(toGetSize._monorailWidth - toGetSize._monorailWidth / 10,
+                toGetSize._monorailHeight,
+                _pictureBoxWidth / 2 -toGetSize._monorailWidth / 2,
+                _pictureBoxHeight / 2 -toGetSize._monorailHeight / 2, Color.GRAY, Color.BLACK));
+        cartComp.setLayout(new GridLayout(1,1));
+        ornComp.setLayout(new GridLayout(1,1));
+        baseComp.setLayout(new GridLayout(1,1));
+        iDrawLabel.setHorizontalAlignment(SwingConstants.CENTER);
+        iDrawLabel.setVerticalAlignment(SwingConstants.CENTER);
+        colorLabel.setHorizontalAlignment(SwingConstants.CENTER);
+        colorLabel.setVerticalAlignment(SwingConstants.CENTER);
+        JLabel cartLabel = new JLabel("На тележке");
+        JLabel ornLabel = new JLabel("На колесах");
+        JLabel baseLabel = new JLabel("Без");
+        cartLabel.setHorizontalAlignment(SwingConstants.CENTER);
+        cartLabel.setVerticalAlignment(SwingConstants.CENTER);
+        ornLabel.setHorizontalAlignment(SwingConstants.CENTER);
+        ornLabel.setVerticalAlignment(SwingConstants.CENTER);
+        baseLabel.setHorizontalAlignment(SwingConstants.CENTER);
+        baseLabel.setVerticalAlignment(SwingConstants.CENTER);
+
+        cartComp.add(cartLabel);
+        ornComp.add(ornLabel);
+        baseComp.add(baseLabel);
+        cartComp.setBorder(BorderFactory.createLineBorder(Color.BLACK, 2));
+        ornComp.setBorder(BorderFactory.createLineBorder(Color.BLACK, 2));
+        baseComp.setBorder(BorderFactory.createLineBorder(Color.BLACK, 2));
+        JLabel addColorLabel = new JLabel("Доп цвет");
+        addColorLabel.setHorizontalAlignment(SwingConstants.CENTER);
+        addColorLabel.setVerticalAlignment(SwingConstants.CENTER);
+        colorLabel.setBounds(555, 20, 70, 33);
+        addColorLabel.setBounds(629, 20, 70, 33);
+        iDrawLabel.setBounds(703, 20, 70, 33);
+        colorLabel.setBorder(BorderFactory.createLineBorder(Color.BLACK, 2));
+        addColorLabel.setBorder(BorderFactory.createLineBorder(Color.BLACK, 2));
+        iDrawLabel.setBorder(BorderFactory.createLineBorder(Color.BLACK, 2));
+        JCheckBox checkSecondCabine = new JCheckBox("Наличие 2 кабины");
+        JCheckBox checkMagniteRail = new JCheckBox("Наличие магнитной рельсы");
+        checkSecondCabine.setBounds(6, 132, 159, 24);
+        checkMagniteRail.setBounds(6, 162, 145, 24);
+        JLabel simpleLabel = new JLabel("Простой");
+        JLabel advancedLabel = new JLabel("Продвинутый");
+        simpleLabel.setBorder(BorderFactory.createLineBorder(Color.BLACK, 2));
+        advancedLabel.setBorder(BorderFactory.createLineBorder(Color.BLACK, 2));
+        simpleLabel.setBounds(171,169, 120, 50);
+        simpleLabel.setHorizontalAlignment(SwingConstants.CENTER);
+        simpleLabel.setVerticalAlignment(SwingConstants.CENTER);
+        advancedLabel.setBounds(297,169, 120, 50);
+        advancedLabel.setHorizontalAlignment(SwingConstants.CENTER);
+        advancedLabel.setVerticalAlignment(SwingConstants.CENTER);
+        cartComp.setBounds(171,229, 120, 50);
+        ornComp.setBounds(297,229, 120, 50);
+        baseComp.setBounds(423,229, 120, 50);
+        JLabel speedLabel = new JLabel ("Скорость");
+        JLabel weightLabel = new JLabel ("Вес");
+        JPanel colorPanel = new JPanel();
+        colorPanel.setBounds(171, 23, 234,143);
+        SpinnerNumberModel speedSpinnerModel = new SpinnerNumberModel(100.0, 100.0, 1000.0, 1.0);
+        SpinnerNumberModel weightSpinnerModel = new SpinnerNumberModel(100.0, 100.0, 1000.0, 1.0);
+        SpinnerNumberModel wheelNumbSpinnerModel = new SpinnerNumberModel(2, 2, 4, 1.0);
+        JSpinner wheelNumbSpinner = new JSpinner(wheelNumbSpinnerModel);
+        JSpinner speedSpinner = new JSpinner(speedSpinnerModel);
+        JSpinner weightSpinner = new JSpinner(weightSpinnerModel);
+        speedSpinner.setBounds(6, 46, 150, 27);
+        speedLabel.setBounds(6, 23, 73, 20);
+        weightSpinner.setBounds(6, 99, 150, 27);
+        weightLabel.setBounds(6, 76, 33, 20);
+        wheelNumbSpinner.setBounds(6, 200, 150, 27);
+
+        JPanel redPanel = new JPanel();
+        JPanel greenPanel = new JPanel();
+        JPanel bluePanel = new JPanel();
+        JPanel yellowPanel = new JPanel();
+        JPanel whitePanel = new JPanel();
+        JPanel grayPanel = new JPanel();
+        JPanel blackPanel = new JPanel();
+        JPanel purplePanel = new JPanel();
+
+        redPanel.setTransferHandler(new PanelTransferHandler());
+        greenPanel.setTransferHandler(new PanelTransferHandler());
+        bluePanel.setTransferHandler(new PanelTransferHandler());
+        yellowPanel.setTransferHandler(new PanelTransferHandler());
+        whitePanel.setTransferHandler(new PanelTransferHandler());
+        grayPanel.setTransferHandler(new PanelTransferHandler());
+        blackPanel.setTransferHandler(new PanelTransferHandler());
+        purplePanel.setTransferHandler(new PanelTransferHandler());
+
+        redPanel.addMouseListener(new PanelMouseAdapter());
+        greenPanel.addMouseListener(new PanelMouseAdapter());
+        bluePanel.addMouseListener(new PanelMouseAdapter());
+        yellowPanel.addMouseListener(new PanelMouseAdapter());
+        whitePanel.addMouseListener(new PanelMouseAdapter());
+        grayPanel.addMouseListener(new PanelMouseAdapter());
+        blackPanel.addMouseListener(new PanelMouseAdapter());
+        purplePanel.addMouseListener(new PanelMouseAdapter());
+
+        redPanel.setName("Красный");
+        greenPanel.setName("Зелёный");
+        bluePanel.setName("Синий");
+        yellowPanel.setName("Жёлтый");
+        whitePanel.setName("Белый");
+        grayPanel.setName("Серый");
+        blackPanel.setName("Чёрный");
+        purplePanel.setName("Фиолетовый");
+
+
+        simpleLabel.setTransferHandler(new LabelTransferHandler());
+        simpleLabel.addMouseListener(new LabelMouseAdapter());
+
+        advancedLabel.setTransferHandler(new LabelTransferHandler());
+        advancedLabel.addMouseListener(new LabelMouseAdapter());
+
+
+
+        redPanel.setBackground(Color.RED);
+        greenPanel.setBackground(Color.GREEN);
+        bluePanel.setBackground(Color.BLUE);
+        yellowPanel.setBackground(Color.YELLOW);
+        whitePanel.setBackground(Color.WHITE);
+        grayPanel.setBackground(Color.GRAY);
+        blackPanel.setBackground(Color.BLACK);
+        purplePanel.setBackground(Color.PINK);
+
+        colorPanel.setLayout(new GridLayout(2, 4));
+
+        colorPanel.add(redPanel);
+        colorPanel.add(greenPanel);
+        colorPanel.add(bluePanel);
+        colorPanel.add(yellowPanel);
+        colorPanel.add(whitePanel);
+        colorPanel.add(grayPanel);
+        colorPanel.add(blackPanel);
+        colorPanel.add(purplePanel);
+
+
+        frameConfig.add(colorLabel);
+        frameConfig.add(addColorLabel);
+        frameConfig.add(iDrawLabel);
+        frameConfig.setLayout(null);
+        frameConfig.setSize(818, 350);
+        frameConfig.add(speedLabel);
+        frameConfig.add(speedSpinner);
+        frameConfig.add(weightLabel);
+        frameConfig.add(weightSpinner);
+        frameConfig.add(simpleLabel);
+        frameConfig.add(advancedLabel);
+        frameConfig.add(checkSecondCabine);
+        frameConfig.add(checkMagniteRail);
+        frameConfig.add(canv);
+        frameConfig.add(addButton);
+        frameConfig.add(cancelButton);
+        frameConfig.add(wheelNumbSpinner);
+
+        frameConfig.setVisible(true);
+        frameConfig.add(colorPanel);
+        frameConfig.add(cartComp);
+        frameConfig.add(ornComp);
+        frameConfig.add(baseComp);
+        colorPanel.setVisible(true);
+        cartComp.setVisible(true);
+        ornComp.setVisible(true);
+        baseComp.setVisible(true);
+
+        canv.setTransferHandler(
+                new TransferHandler(){
+                    @Override
+                    public boolean canImport(TransferHandler.TransferSupport support) {
+                        return support.isDataFlavorSupported(DataFlavor.stringFlavor);
+                    }
+
+                    @Override
+                    public boolean importData(TransferHandler.TransferSupport support) {
+                        if (canImport(support)) {
+                            try {
+                                Object speedObj = speedSpinner.getValue();
+                                Number speedNumb = (Number) speedObj;
+                                int speed = speedNumb.intValue();
+
+                                Object weightObj = weightSpinner.getValue();
+                                Number weightNumb = (Number) weightObj;
+                                int weight = weightNumb.intValue();
+
+                                Object wheelNumbObj = wheelNumbSpinner.getValue();
+                                Number wheelNumbNumb = (Number) wheelNumbObj;
+                                int wheelNumb = wheelNumbNumb.intValue();
+
+                                String data = (String) support.getTransferable().getTransferData(DataFlavor.stringFlavor);
+                                switch (data) {
+                                    case "Простой":
+
+                                        _monorail = new DrawningMonorail(speed, weight, Color.WHITE,
+                                                Color.GRAY, Color.BLACK, _pictureBoxWidth, _pictureBoxHeight);
+                                        _monorail.ChangeWheelsNumb(wheelNumb);
+                                        break;
+                                    case "Продвинутый":
+                                        _monorail = new DrawningLocomotive(speed, weight, Color.WHITE, Color.GRAY, Color.BLACK,
+                                                wheelNumb, _pictureBoxWidth, _pictureBoxHeight,
+                                                checkSecondCabine.isSelected(), checkMagniteRail.isSelected(), Color.GRAY);
+                                        _monorail.ChangeWheelsNumb(wheelNumb);
+                                        break;
+                                }
+                                _monorail.SetPosition(_pictureBoxWidth / 2 -_monorail._monorailWidth / 2,
+                                        _pictureBoxHeight / 2 -_monorail._monorailHeight / 2);
+
+                                canv.DrawningMonorail = _monorail;
+                                canv.repaint();
+                                return true;
+                            } catch (UnsupportedFlavorException | IOException e) {
+                                e.printStackTrace();
+                            }
+                        }
+                        return false;
+                    }
+                }
+        );
+
+        iDrawLabel.setTransferHandler(
+                new TransferHandler(){
+                    @Override
+                    public boolean canImport(TransferHandler.TransferSupport support) {
+                        return support.isDataFlavorSupported(iDrawTransferable.iDrawDataFlavor);
+                    }
+                    @Override
+                    public boolean importData(TransferHandler.TransferSupport support) {
+                        if (canImport(support)) {
+                            try {
+                                IDraw obj = (IDraw) support.getTransferable().getTransferData(iDrawTransferable.iDrawDataFlavor);
+                                if (_monorail == null)
+                                    return false;
+                                _monorail.ChangeIDraw(obj);
+                                canv.repaint();
+                                return true;
+                            } catch (UnsupportedFlavorException | IOException e) {
+                                e.printStackTrace();
+                            }
+                        }
+                        return false;
+                    }
+                }
+        );
+
+        colorLabel.setTransferHandler(
+                new TransferHandler(){
+                    @Override
+                    public boolean canImport(TransferHandler.TransferSupport support) {
+                        return support.isDataFlavorSupported(ColorTransferable.colorDataFlavor);
+                    }
+                    @Override
+                    public boolean importData(TransferHandler.TransferSupport support) {
+                        if (canImport(support)) {
+                            try {
+                                Color color = (Color) support.getTransferable().getTransferData(ColorTransferable.colorDataFlavor);
+                                if (_monorail == null)
+                                    return false;
+                                _monorail.ChangeColor(color);
+                                canv.repaint();
+                                return true;
+                            } catch (UnsupportedFlavorException | IOException e) {
+                                e.printStackTrace();
+                            }
+                        }
+                        return false;
+                    }
+                }
+        );
+
+        addColorLabel.setTransferHandler(
+                new TransferHandler(){
+                    @Override
+                    public boolean canImport(TransferHandler.TransferSupport support) {
+                        return support.isDataFlavorSupported(ColorTransferable.colorDataFlavor);
+                    }
+                    @Override
+                    public boolean importData(TransferHandler.TransferSupport support) {
+                        if (canImport(support)) {
+                            try {
+                                Color color = (Color) support.getTransferable().getTransferData(ColorTransferable.colorDataFlavor);
+                                if (_monorail == null || !(_monorail instanceof DrawningLocomotive))
+                                    return false;
+                                ((DrawningLocomotive)_monorail).ChangeAddColor(color);
+                                canv.repaint();
+                                return true;
+                            } catch (UnsupportedFlavorException | IOException e) {
+                                e.printStackTrace();
+                            }
+                        }
+                        return false;
+                    }
+                }
+        );
+    }
+
+
+
+
+}
+

src/MonorailHard/Generics/HardGeneric.java

@@ -0,0 +1,61 @@
+package MonorailHard.Generics;
+
+import MonorailHard.DrawningObjects.DrawningMonorail;
+import MonorailHard.DrawningObjects.IDraw;
+import MonorailHard.Entities.EntityMonorail;
+
+import java.util.Random;
+
+public class HardGeneric <T extends EntityMonorail,U extends IDraw>{
+    T[] arrFirst;
+    U[] arrSecond;
+
+    private int curSz;
+    private int CountFirst;
+    private int CountSecond;
+
+    private int pictureBoxWidth;
+
+    private int pictureBoxHeight;
+
+    public HardGeneric(int countFirst, int countSecond, int width, int height){
+        curSz = 0;
+        CountFirst = countFirst;
+        CountSecond = countSecond;
+        arrFirst = (T[]) new EntityMonorail[CountFirst];
+        arrSecond = (U[]) new IDraw[CountSecond];
+        pictureBoxHeight = height;
+        pictureBoxWidth = width;
+    }
+
+    public int InsertFirst(T entityMonorail){
+        if(arrFirst[CountFirst-1] != null)
+            return -1;
+        for(int i = curSz -1; i>= 0; i--) {
+            arrFirst[i + 1] = arrFirst[i];
+            arrSecond[i + 1] = arrSecond[i];
+        }
+        curSz++;
+        arrFirst[0] = entityMonorail;
+
+        return 0;
+    }
+
+    public int InsertSecond(U inter){
+        if(arrSecond[CountSecond-1] != null)
+            return -1;
+        arrSecond[0] = inter;
+        return 0;
+    }
+
+    public DrawningMonorail MakeObject(){
+        Random rand = new Random();
+        int indFirst = rand.nextInt(0, curSz);
+        int indSecond = rand.nextInt(0,curSz);
+        EntityMonorail entity = arrFirst[indFirst];
+        IDraw inter = arrSecond[indSecond];
+        DrawningMonorail monorail = new DrawningMonorail(entity.Speed(), entity.Weight(), entity.BodyColor(),
+                entity.WheelColor(), entity.TireColor(), pictureBoxWidth, pictureBoxHeight);
+        return monorail;
+    }
+}

src/MonorailHard/Generics/MonorailGenericCollection.java

@@ -0,0 +1,92 @@
+package MonorailHard.Generics;
+
+import MonorailHard.DrawningObjects.DrawningMonorail;
+import MonorailHard.MovementStrategy.IMoveableObject;
+
+import java.awt.*;
+import java.awt.image.BufferedImage;
+
+public class MonorailGenericCollection<T extends DrawningMonorail, U extends IMoveableObject> {
+    private final int _pictureWidth;
+
+    private final int _pictureHeight;
+
+    private final int _placeSizeWidth = 133;
+
+    private final int _placeSizeHeight = 50;
+
+    private final SetGeneric<T> _collection;
+
+    public MonorailGenericCollection(int picWidth, int picHeight){
+        int width = picWidth / _placeSizeWidth;
+        int height = picHeight / _placeSizeHeight;
+        _pictureWidth = picWidth;
+        _pictureHeight = picHeight;
+        _collection = new SetGeneric<T>(width * height);
+    }
+
+    public int Size(){
+        return _collection.Count;
+    }
+    public boolean Insert(T obj){
+        if (obj == null)
+        {
+            return false;
+        }
+        return _collection.Insert(obj);
+    }
+
+    public boolean Remove(int position){
+        return _collection.Remove(position);
+    }
+    public U GetU(int pos){
+        T ans = _collection.Get(pos);
+        if(ans == null)
+            return null;
+        return (U)ans.GetMoveableObject();
+    }
+
+    public T Get(int position){
+        if(position < 0 || position >= _collection.Count)
+            return null;
+        return _collection.Get(position);
+    }
+    private void DrawBackground(Graphics g)
+    {
+        g.setColor(Color.BLACK);
+        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)
+    {
+        for (int i = 0; i < _collection.Count; i++)
+        {
+            DrawningMonorail monorail = _collection.Get(i);
+            if (monorail != null)
+            {
+                int inRow = _pictureWidth / _placeSizeWidth;
+                monorail.SetPosition(i % inRow * _placeSizeWidth, _pictureHeight - _pictureHeight % _placeSizeHeight - (i / inRow + 1) * _placeSizeHeight);
+                monorail.DrawMonorail((Graphics2D) g);
+            }
+        }
+    }
+    public BufferedImage ShowMonorails()
+    {
+        BufferedImage bmp = new BufferedImage(_pictureWidth, _pictureHeight, BufferedImage.TYPE_4BYTE_ABGR);
+        Graphics gr = bmp.createGraphics();
+        DrawBackground(gr);
+        DrawObjects(gr);
+        return bmp;
+    }
+}

src/MonorailHard/Generics/MonorailGenericStorage.java

@@ -0,0 +1,49 @@
+package MonorailHard.Generics;
+
+import MonorailHard.DrawningObjects.DrawningMonorail;
+import MonorailHard.MovementStrategy.DrawningObjectMonorail;
+
+import java.util.Dictionary;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Queue;
+import java.util.stream.Collectors;
+
+public class MonorailGenericStorage {
+    final HashMap<String, MonorailGenericCollection<DrawningMonorail, DrawningObjectMonorail>> _monorailStorages;
+    public List<String> Keys(){
+        if(_monorailStorages == null)
+            return null;
+        return _monorailStorages.keySet().stream().collect(Collectors.toList());
+    }
+    private final int _pictureWidth;
+    private final int _pictureHeight;
+
+    public MonorailGenericStorage(int pictureWidth, int pictureHeight){
+        _monorailStorages = new HashMap<>();
+        _pictureWidth = pictureWidth;
+        _pictureHeight = pictureHeight;
+    }
+
+    public void AddSet(String name){
+        if(_monorailStorages.containsKey(name))
+            return;
+        _monorailStorages.put(name, new MonorailGenericCollection<>(_pictureWidth, _pictureHeight));
+    }
+
+    public void DelSet(String name){
+        if(!_monorailStorages.containsKey(name))
+            return;
+        _monorailStorages.remove(name);
+    }
+
+    public MonorailGenericCollection<DrawningMonorail, DrawningObjectMonorail> Get(String name){
+        if(!_monorailStorages.containsKey(name))
+            return null;
+        return _monorailStorages.get(name);
+    }
+
+    public DrawningMonorail Get(String collectionName, int position){
+        return _monorailStorages.get(collectionName).Get(position);
+    }
+}

src/MonorailHard/Generics/MonorailTrashCollection.java

@@ -0,0 +1,32 @@
+package MonorailHard.Generics;
+
+import MonorailHard.DrawningObjects.DrawningMonorail;
+
+import java.util.ArrayDeque;
+import java.util.Queue;
+
+public class MonorailTrashCollection <T extends DrawningMonorail> {
+    Queue <T> _queue;
+
+    public MonorailTrashCollection(){
+        _queue = new ArrayDeque<>();
+    }
+
+    public void Push(T monorail){
+        _queue.add(monorail);
+    }
+
+    public int GetSize(){
+        return _queue.size();
+    }
+
+    public void Pop(){
+        if(_queue.size() ==0)
+            return;
+        _queue.remove();
+    }
+
+    public T GetTop(){
+        return _queue.peek();
+    }
+}

src/MonorailHard/Generics/SetGeneric.java

@@ -0,0 +1,56 @@
+package MonorailHard.Generics;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class SetGeneric <T extends Object>{
+    private final List<T> _places;
+
+    public int Count;
+
+    private final int _maxCount;
+
+    public SetGeneric(int count){
+        _maxCount = count;
+        _places = new ArrayList<>();
+    }
+
+    public boolean Insert(T monorail){
+        if(_places.size() == _maxCount)
+            return false;
+        Insert(monorail, 0);
+        return true;
+    }
+
+    public boolean Insert(T monorail, int position){
+        if (!(position >= 0 && position <= _places.size() && _places.size() < _maxCount))
+            return false;
+        _places.add(position, monorail);
+        Count++;
+        return true;
+    }
+
+    public boolean Remove(int position){
+        if(!(position >= 0 && position < _places.size()))
+            return false;
+        _places.remove(position);
+        Count--;
+        return true;
+    }
+
+    public T Get(int position){
+        if(!(position >= 0 && position < Count))
+            return null;
+        return (T)_places.get(position);
+    }
+
+    public ArrayList<T> GetMonorails(int maxMonorails){
+        ArrayList<T> toRet = new ArrayList<>();
+        for(int i = 0; i < _places.size(); i++){
+            toRet.add(_places.get(i));
+            if(i == maxMonorails)
+                return toRet;
+        }
+        return toRet;
+    }
+}

src/MonorailHard/HardForm.java

@@ -0,0 +1,77 @@
+package MonorailHard;
+
+import MonorailHard.DrawningObjects.DrawningMonorail;
+import MonorailHard.DrawningObjects.DrawningWheels;
+import MonorailHard.DrawningObjects.IDraw;
+import MonorailHard.Entities.EntityMonorail;
+import MonorailHard.Generics.HardGeneric;
+
+import javax.swing.*;
+import javax.swing.text.html.parser.Entity;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.util.Random;
+
+public class HardForm {
+    private Canvas canv;
+
+    private int pictureBoxWidth;
+    private int pictureBoxHeight;
+
+    private EntityMonorail makeEntity(){
+        Random rand = new Random();
+        return new EntityMonorail(rand.nextInt(100, 300), rand.nextDouble(1000,3000),
+                Color.getHSBColor(rand.nextInt(0, 301), rand.nextInt(0, 301), rand.nextInt(0, 301)),
+                Color.getHSBColor(rand.nextInt(0, 301), rand.nextInt(0, 301), rand.nextInt(0, 301)),
+                Color.getHSBColor(rand.nextInt(0, 301), rand.nextInt(0, 301), rand.nextInt(0, 301)));
+    }
+    void Draw(){
+        if(canv == null)
+            return;
+        canv.repaint();
+    }
+    private IDraw makeIDraw(EntityMonorail entity){
+        Random rand = new Random();
+        return new DrawningWheels(pictureBoxWidth, pictureBoxHeight, 0, 0, entity.WheelColor(), entity.TireColor());
+    }
+    public HardForm(){
+        Random rand = new Random();
+        int sz = rand.nextInt(1, 10);
+
+
+        JFrame HardFrame = new JFrame();
+        HardFrame.setSize(700, 400);
+        HardFrame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
+        canv = new Canvas();
+        canv.setBounds(0,0,pictureBoxWidth,pictureBoxHeight);
+        JButton makeObject = new JButton("Создать");
+        makeObject.setBounds(0, 0, 100, 40);
+        canv.add(makeObject);
+        HardFrame.setContentPane(canv);
+        HardFrame.setVisible(true);
+        pictureBoxHeight = canv.getHeight();
+        pictureBoxWidth = canv.getWidth();
+        HardGeneric<EntityMonorail, IDraw> toDraw= new HardGeneric<>(sz,
+                sz, pictureBoxWidth, pictureBoxHeight);
+        for(int i = 0; i < sz; i++){
+            EntityMonorail ent = makeEntity();
+            toDraw.InsertFirst(ent);
+            toDraw.InsertSecond(makeIDraw(ent));
+        }
+        makeObject.addActionListener(
+                new ActionListener() {
+                    @Override
+                    public void actionPerformed(ActionEvent e) {
+                        DrawningMonorail DrawningMonorail = toDraw.MakeObject();
+                        DrawningMonorail.SetPosition(pictureBoxWidth / 2 - DrawningMonorail.GetWidth()/2,
+                                pictureBoxHeight / 2 - DrawningMonorail.GetHeight()/2);
+                        canv.DrawningMonorail = DrawningMonorail;
+                        Draw();
+                    }
+                }
+        );
+
+    }
+}
+

src/MonorailHard/Main.java

@@ -1,4 +1,8 @@
 package MonorailHard;
+import MonorailHard.DrawningObjects.DrawningLocomotive;
+import MonorailHard.DrawningObjects.DrawningMonorail;
+import MonorailHard.MovementStrategy.*;
+
 import java.awt.*;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
@@ -11,86 +15,6 @@ import javax.swing.*;
 
 public class Main {
     public static void main(String[] args) throws IOException {
-        JFrame MonorailFrame = new JFrame();
+        FormMonorailCollection form = new FormMonorailCollection();
-        JPanel MonorailPanel = new JPanel();
-        MonorailFrame.setLayout(new BorderLayout());
-        MonorailFrame.setSize(900, 500);
-        MonorailFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
-        MonorailFrame.setLayout(new BorderLayout(1,1));
-        DrawningMonorail DrawningMonorail = new DrawningMonorail();
-        MonorailPanel.setLayout(null);
-        BufferedImage RightIcon = ImageIO.read(new File("RightButton.png"));
-        BufferedImage LeftIcon = ImageIO.read(new File("LeftButton.png"));
-        BufferedImage UpIcon = ImageIO.read(new File("UpButton.png"));
-        BufferedImage DownIcon = ImageIO.read(new File("DownButton.png"));
-
-        JButton RightButton = new JButton(new ImageIcon(RightIcon));
-        JButton LeftButton = new JButton(new ImageIcon(LeftIcon));
-        JButton UpButton = new JButton(new ImageIcon(UpIcon));
-        JButton DownButton = new JButton(new ImageIcon(DownIcon));
-        JButton CreateButton = new JButton();
-        CreateButton.setText("Создать");
-        CreateButton.setBounds(12, 401, 90, 40);
-        RightButton.setBounds(840,411,30,30);
-        LeftButton.setBounds(768,411,30,30);
-        UpButton.setBounds(804,375,30,30);
-        DownButton.setBounds(804,411,30,30);
-        MonorailPanel.add(CreateButton);
-        MonorailPanel.add(RightButton);
-        MonorailPanel.add(LeftButton);
-        MonorailPanel.add(UpButton);
-        MonorailPanel.add(DownButton);
-        MonorailFrame.add(MonorailPanel, BorderLayout.CENTER);
-        Random random = new Random();
-        CreateButton.addActionListener(new ActionListener() {
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                DrawningMonorail.Init(random.nextInt(100, 300), random.nextDouble(1000, 3000),
-                        Color.getHSBColor(random.nextInt(0, 301), random.nextInt(0, 301), random.nextInt(0, 301)),
-                        Color.getHSBColor(random.nextInt(0, 301), random.nextInt(0, 301), random.nextInt(0, 301)),
-                        Color.getHSBColor(random.nextInt(0, 301), random.nextInt(0, 301), random.nextInt(0, 301)),
-                        random.nextInt(2, 5),
-                        MonorailPanel.getWidth(), MonorailPanel.getHeight(), random.nextBoolean(), random.nextBoolean(), MonorailPanel);
-                DrawningMonorail.DrawMonorail();
-            }
-        });
-        RightButton.addActionListener(new ActionListener() {
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                if(DrawningMonorail.EntityMonorail() == null)
-                    return;
-                DrawningMonorail.MoveTransport(DirectionType.Right);
-                DrawningMonorail.DrawMonorail();
-            }
-        });
-        LeftButton.addActionListener(new ActionListener() {
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                if(DrawningMonorail.EntityMonorail() == null)
-                    return;
-                DrawningMonorail.MoveTransport(DirectionType.Left);
-                DrawningMonorail.DrawMonorail();
-            }
-        });
-        UpButton.addActionListener(new ActionListener() {
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                if(DrawningMonorail.EntityMonorail() == null)
-                    return;
-                DrawningMonorail.MoveTransport(DirectionType.Up);
-                DrawningMonorail.DrawMonorail();
-            }
-        });
-        DownButton.addActionListener(new ActionListener() {
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                if(DrawningMonorail.EntityMonorail() == null)
-                    return;
-                DrawningMonorail.MoveTransport(DirectionType.Down);
-                DrawningMonorail.DrawMonorail();
-            }
-        });
-
-        MonorailFrame.setVisible(true);
     }
 }

src/MonorailHard/MovementStrategy/AbstractStrategy.java

@@ -0,0 +1,75 @@
+package MonorailHard.MovementStrategy;
+
+import MonorailHard.DirectionType;
+
+public abstract class AbstractStrategy {
+    private IMoveableObject _moveableObject;
+    private Status _state = Status.NotInit;
+    private int FieldWidth;
+    protected int FieldWidth(){return FieldWidth;}
+    private int FieldHeight;
+    protected int FieldHeight(){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;
+        _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(DirectionType.Left);}
+    protected boolean MoveRight() {return MoveTo(DirectionType.Right);}
+    protected boolean MoveUp() {return MoveTo(DirectionType.Up);}
+    protected boolean MoveDown() {return MoveTo(DirectionType.Down);}
+    protected ObjectParameters GetObjectParameters(){
+        if(_moveableObject != null)
+            return _moveableObject.GetObjectParameters();
+        else return null;
+    }
+
+    protected Integer GetStep()
+    {
+        if (_state != Status.InProgress)
+        {
+            return null;
+        }
+        return _moveableObject.GetStep();
+    }
+
+    protected abstract void MoveToTarget();
+
+    protected abstract boolean IsTargetDestination();
+
+    private boolean MoveTo(DirectionType directionType) {
+        if (_state != Status.InProgress)
+        {
+            return false;
+        }
+        if (_moveableObject.CheckCanMove(directionType))
+        {
+            _moveableObject.MoveObject(directionType);
+            return true;
+        }
+        return false;
+    }
+
+}

src/MonorailHard/MovementStrategy/DrawningObjectMonorail.java

@@ -0,0 +1,36 @@
+package MonorailHard.MovementStrategy;
+
+import MonorailHard.DirectionType;
+import MonorailHard.DrawningObjects.DrawningMonorail;
+
+public class DrawningObjectMonorail implements IMoveableObject{
+    private final DrawningMonorail _drawningMonorail;
+    public DrawningObjectMonorail(DrawningMonorail drawningMonorail){
+        _drawningMonorail = drawningMonorail;
+    }
+
+    public ObjectParameters GetObjectParameters(){
+        if(_drawningMonorail == null || _drawningMonorail.EntityMonorail() == null)
+            return null;
+        return new ObjectParameters(_drawningMonorail.GetPosX(), _drawningMonorail.GetPosY(),
+                _drawningMonorail.GetWidth(), _drawningMonorail.GetHeight());
+    }
+
+    public int GetStep(){
+        if(_drawningMonorail.EntityMonorail() == null)
+            return 0;
+        return (int)_drawningMonorail.EntityMonorail().Step();
+    }
+
+    public boolean CheckCanMove(DirectionType direction){
+        if(_drawningMonorail == null)
+            return false;
+        return _drawningMonorail.CanMove(direction);
+    }
+
+    public void MoveObject(DirectionType direction){
+        if(_drawningMonorail == null)
+            return;
+        _drawningMonorail.MoveTransport(direction);
+    }
+}

src/MonorailHard/MovementStrategy/IMoveableObject.java

@@ -0,0 +1,10 @@
+package MonorailHard.MovementStrategy;
+
+import MonorailHard.DirectionType;
+
+public interface IMoveableObject {
+    public ObjectParameters GetObjectParameters();
+    public int GetStep();
+    boolean CheckCanMove(DirectionType direction);
+    void MoveObject(DirectionType direction);
+}

src/MonorailHard/MovementStrategy/MoveToBorder.java

@@ -0,0 +1,36 @@
+package MonorailHard.MovementStrategy;
+
+public class MoveToBorder extends AbstractStrategy {
+    @Override
+    protected boolean IsTargetDestination() {
+        var objParams = GetObjectParameters();
+        if (objParams == null) {
+            return false;
+        }
+        int a = FieldWidth();
+        int b = FieldHeight();
+        int q = GetStep();
+        return objParams.RightBorder <= FieldWidth() && objParams.RightBorder + GetStep() >= FieldWidth() &&
+                objParams.DownBorder <= FieldHeight() && objParams.DownBorder + GetStep() >= FieldHeight();
+    }
+    @Override
+    protected void MoveToTarget() {
+        var objParams = GetObjectParameters();
+        if (objParams == null) {
+            return;
+        }
+        var diffX = objParams.RightBorder - FieldWidth();
+        if (Math.abs(diffX) >= GetStep()) {
+            if (diffX < 0) {
+                MoveRight();
+            }
+        }
+        var diffY = objParams.DownBorder - FieldHeight();
+        if (Math.abs(diffY) >= GetStep()) {
+            if (diffY < 0) {
+                MoveDown();
+            }
+        }
+    }
+}
+

src/MonorailHard/MovementStrategy/MoveToCenter.java

@@ -0,0 +1,53 @@
+package MonorailHard.MovementStrategy;
+
+public class MoveToCenter extends AbstractStrategy{
+    @Override
+    protected boolean IsTargetDestination(){
+        var objParams = GetObjectParameters();
+        if(objParams == null)
+            return false;
+        return ((objParams.ObjectMiddleHorizontal <= FieldWidth() / 2 &&
+                objParams.ObjectMiddleHorizontal + GetStep() >= FieldWidth() / 2)
+                ||(objParams.ObjectMiddleHorizontal >= FieldWidth() / 2 &&
+                objParams.ObjectMiddleHorizontal - GetStep() <= FieldWidth() / 2)) &&
+
+                ((objParams.ObjectMiddleVertical <= FieldHeight() / 2 &&
+                objParams.ObjectMiddleVertical + GetStep() >= FieldHeight() / 2) ||
+                (objParams.ObjectMiddleVertical >= FieldHeight() / 2 &&
+                        objParams.ObjectMiddleVertical - GetStep() <= FieldHeight() / 2));
+    }
+
+    @Override
+    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/MonorailHard/MovementStrategy/ObjectParameters.java

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

src/MonorailHard/MovementStrategy/Status.java

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