reload

DoubleDeckerBus/pom.xml

@@ -69,7 +69,7 @@
                         <!-- Default configuration for running with: mvn clean javafx:run -->
                         <id>default-cli</id>
                         <configuration>
-                            <mainClass>com.example.doubledeckerbus/com.example.doubledeckerbus.FormBus
+                            <mainClass>com.example.doubledeckerbus/com.example.doubledeckerbus.Form
                             </mainClass>
                             <launcher>app</launcher>
                             <jlinkZipName>app</jlinkZipName>

DoubleDeckerBus/src/main/java/com/example/doubledeckerbus/AbstractMap.java

@@ -0,0 +1,119 @@
+package com.example.doubledeckerbus;
+
+import javafx.scene.canvas.GraphicsContext;
+
+import java.util.Random;
+
+public abstract class AbstractMap {
+    private IDrawingObject _drawingObject = null;
+    protected int[][] _map = null;
+    protected int _width;
+    protected int _height;
+    protected float _size_x;
+    protected float _size_y;
+    protected final Random _random = new Random();
+    protected final int _freeRoad = 0;
+    protected final int _barrier = 1;
+
+    protected GraphicsContext gc;
+
+    public void CreateMap(int width, int height, IDrawingObject drawingObject, GraphicsContext gc)
+    {
+        _width = width;
+        _height = height;
+        _drawingObject = drawingObject;
+        this.gc = gc;
+        GenerateMap();
+        while (!SetObjectOnMap())
+        {
+            GenerateMap();
+        }
+        DrawMapWithObject();
+    }
+
+    private boolean SetObjectOnMap()
+    {
+        if (_drawingObject == null || _map == null)
+        {
+            return false;
+        }
+        int x = _random.nextInt(0, 10);
+        int y = _random.nextInt(0, 10);
+        _drawingObject.SetObject(x, y, _width, _height);
+        return !CheckCollision();
+    }
+
+    private void DrawMapWithObject()
+    {
+        if (_drawingObject == null || _map == null)
+        {
+            return;
+        }
+
+        for (int i = 0; i < _map.length; ++i)
+        {
+            for (int j = 0; j < _map[0].length; ++j)
+            {
+                if (_map[i][j] == _freeRoad)
+                {
+                    DrawRoadPart(i, j);
+                }
+                    else if (_map[i][j] == _barrier)
+                {
+                    DrawBarrierPart(i, j);
+                }
+            }
+        }
+        _drawingObject.DrawingObject(gc);
+    }
+
+    public void MoveObject(Direction direction)
+    {
+        _drawingObject.MoveObject(direction);
+        if (CheckCollision()) {
+            switch (direction) {
+                case Left -> _drawingObject.MoveObject(Direction.Right);
+                case Right -> _drawingObject.MoveObject(Direction.Left);
+                case Up -> _drawingObject.MoveObject(Direction.Down);
+                case Down -> _drawingObject.MoveObject(Direction.Up);
+            }
+
+        }
+        DrawMapWithObject();
+    }
+
+    private boolean CheckCollision() {
+        var pos = _drawingObject.GetCurrentPosition();
+        int startX = (int)((pos.Left) / _size_x);
+        int endX = (int)((pos.Right) / _size_x);
+        int startY = (int)((pos.Top) / _size_y);
+        int endY = (int)((pos.Bottom) / _size_y);
+
+        if (startX < 0 || startY < 0 || endX > _map[0].length || endY > _map.length) {
+            return false;
+        }
+
+        for (int y = startY; y <= endY + 1; y++)
+        {
+            for (int x = startX; x <= endX + 1; x++)
+            {
+                try {
+                    if (_map[x][y] == _barrier)
+                    {
+                        return true;
+                    }
+                }
+                catch (ArrayIndexOutOfBoundsException e) {
+                    continue;
+                }
+            }
+        }
+
+        return false;
+    }
+
+
+    protected abstract void GenerateMap();
+    protected abstract void DrawRoadPart(int i, int j);
+    protected abstract void DrawBarrierPart(int i, int j);
+}

DoubleDeckerBus/src/main/java/com/example/doubledeckerbus/BusComparatorByColor.java

@@ -0,0 +1,76 @@
+package com.example.doubledeckerbus;
+
+import java.util.Comparator;
+
+public class BusComparatorByColor implements Comparator<IDrawingObject> {
+    @Override
+    public int compare(IDrawingObject o1, IDrawingObject o2) {
+        if (o1 == null && o2 == null)
+        {
+            return 0;
+        }
+        if (o1 == null)
+        {
+            return 1;
+        }
+        if (o2 == null)
+        {
+            return -1;
+        }
+
+        if (!(o1 instanceof DrawingObjectBus bus1) || !(o2 instanceof DrawingObjectBus bus2))
+        {
+            if (!(o1 instanceof DrawingObjectBus) && !(o2 instanceof DrawingObjectBus))
+            {
+                return 0;
+            }
+            else if (!(o1 instanceof DrawingObjectBus))
+            {
+                return 1;
+            }
+            else
+            {
+                return -1;
+            }
+        }
+
+        String col1 = bus1.getBus().Bus.getBodyColor().toString();
+        String col2 = bus2.getBus().Bus.getBodyColor().toString();
+        var col = col1.compareTo(col2);
+        if (col != 0)
+        {
+            return col;
+        }
+
+        if (bus1.getBus().Bus instanceof EntityDDB DDB1 && bus2.getBus().Bus instanceof EntityDDB DDB2)
+        {
+            String extra1 = DDB1.ExtraColor.toString();
+            String extra2 = DDB2.ExtraColor.toString();
+            var extra = extra1.compareTo(extra2);
+            if (extra != 0)
+            {
+                return extra;
+            }
+        }
+
+        String doors1 = bus1.getBus().Doors.getClass().getSimpleName();
+        String doors2 = bus2.getBus().Doors.getClass().getSimpleName();
+        var res = doors1.compareTo(doors2);
+        if (res != 0)
+        {
+            return res;
+        }
+
+        if (bus1.getBus()._countOfDoors - bus2.getBus()._countOfDoors != 0)
+        {
+            return bus1.getBus()._countOfDoors - bus2.getBus()._countOfDoors;
+        }
+
+        if (bus1.getBus()._speed - bus2.getBus()._speed != 0)
+        {
+            return bus1.getBus()._speed - bus2.getBus()._speed;
+        }
+
+        return (int) (bus1.getBus()._weight - bus2.getBus()._weight);
+    }
+}

DoubleDeckerBus/src/main/java/com/example/doubledeckerbus/BusComparatorByType.java

@@ -0,0 +1,65 @@
+package com.example.doubledeckerbus;
+
+import java.util.Comparator;
+
+public class BusComparatorByType implements Comparator<IDrawingObject> {
+    @Override
+    public int compare(IDrawingObject o1, IDrawingObject o2) {
+        if (o1 == null && o2 == null)
+        {
+            return 0;
+        }
+        if (o1 == null)
+        {
+            return 1;
+        }
+        if (o2 == null)
+        {
+            return -1;
+        }
+
+        if (!(o1 instanceof DrawingObjectBus bus1) || !(o2 instanceof DrawingObjectBus bus2))
+        {
+            if (!(o1 instanceof DrawingObjectBus) && !(o2 instanceof DrawingObjectBus))
+            {
+                return 0;
+            }
+            else if (!(o1 instanceof DrawingObjectBus))
+            {
+                return 1;
+            }
+            else
+            {
+                return -1;
+            }
+        }
+
+        if (!bus1.getBus().getClass().getSimpleName().equals(bus2.getBus().getClass().getSimpleName()))
+        {
+            if (bus1.getBus().getClass().getSimpleName().equals("DrawingBus"))
+            {
+                return -1;
+            }
+            return 1;
+        }
+        String doors1 = bus1.getBus().Doors.getClass().getSimpleName();
+        String doors2 = bus2.getBus().Doors.getClass().getSimpleName();
+        var res = doors1.compareTo(doors2);
+        if (res != 0)
+        {
+            return res;
+        }
+
+        if (bus1.getBus()._countOfDoors - bus2.getBus()._countOfDoors != 0)
+        {
+            return bus1.getBus()._countOfDoors - bus2.getBus()._countOfDoors;
+        }
+
+        if (bus1.getBus()._speed - bus2.getBus()._speed != 0)
+        {
+            return bus1.getBus()._speed - bus2.getBus()._speed;
+        }
+
+        return (int) (bus1.getBus()._weight - bus2.getBus()._weight);
+    }
+}

DoubleDeckerBus/src/main/java/com/example/doubledeckerbus/BusNotFoundException.java

@@ -0,0 +1,24 @@
+package com.example.doubledeckerbus;
+
+public class BusNotFoundException extends Exception {
+    public BusNotFoundException(int num)
+    {
+        super("Object not found by position " + num);
+    }
+    public BusNotFoundException()
+    {
+        super();
+    }
+    public BusNotFoundException(String message)
+    {
+        super(message);
+    }
+    public BusNotFoundException(String message, Throwable cause)
+    {
+        super(message, cause);
+    }
+    public BusNotFoundException(Throwable cause)
+    {
+        super(cause);
+    }
+}

DoubleDeckerBus/src/main/java/com/example/doubledeckerbus/ControllerBus.java

@@ -4,53 +4,70 @@ import javafx.beans.InvalidationListener;
 import javafx.collections.FXCollections;
 import javafx.collections.ObservableList;
 import javafx.event.ActionEvent;
+import javafx.event.Event;
+import javafx.event.EventHandler;
 import javafx.fxml.FXML;
+import javafx.fxml.FXMLLoader;
+import javafx.scene.Scene;
 import javafx.scene.canvas.Canvas;
 import javafx.scene.canvas.GraphicsContext;
-import javafx.scene.control.Button;
-import javafx.scene.control.ChoiceBox;
-import javafx.scene.control.Label;
+import javafx.scene.control.*;
 import javafx.scene.layout.AnchorPane;
 import javafx.scene.paint.Color;
 
+import java.io.IOException;
+import java.util.Optional;
 import java.util.Random;
 
+import static com.example.doubledeckerbus.ControllerMapWithSetBus._mapBusesCollectionGeneric;
+
 public class ControllerBus {
 
-    private DrawingBus _bus;
-    ObservableList<Integer> countOfDoors = FXCollections.observableArrayList(3, 4, 5);
+    public static DrawingBus _bus;
+    public DrawingBus SelectedBus;
+    protected ObservableList<Integer> countOfDoors = FXCollections.observableArrayList(3, 4, 5);
     @FXML
-    private Button buttonCreate;
+    protected Button buttonCreate;
 
     @FXML
-    private Button buttonDown;
+    protected Button buttonSelectBus;
 
     @FXML
-    private Button buttonLeft;
+    protected Button buttonDown;
 
     @FXML
-    private Button buttonRight;
+    protected Button buttonLeft;
 
     @FXML
-    private Button buttonUp;
+    protected Button buttonRight;
 
     @FXML
-    private Canvas canvasBus;
+    protected Button buttonUp;
 
     @FXML
-    private AnchorPane pictureBoxBus;
+    protected Canvas canvasBus;
 
     @FXML
-    private Label statusColor;
+    protected AnchorPane pictureBoxBus;
 
     @FXML
-    private Label statusSpeed;
+    protected Label statusColor;
 
     @FXML
-    private Label statusWeight;
+    protected Label statusSpeed;
 
     @FXML
-    private ChoiceBox<Integer> choiceDoors;
+    protected Label statusWeight;
+
+    @FXML
+    protected ChoiceBox<Integer> choiceDoors;
+
+    @FXML
+    private ColorPicker bodyColorPicker;
+
+    @FXML
+    private ColorPicker extraColorPicker;
+
 
     @FXML
     void ButtonCreate_Click(ActionEvent event) {
@@ -58,18 +75,28 @@ public class ControllerBus {
         pictureBoxBus.heightProperty().addListener(listener);
 
         Random rnd = new Random();
-        _bus = new DrawingBus();
-        _bus.Init(rnd.nextInt(100, 300), rnd.nextFloat(1000, 2000),
-                Color.rgb(rnd.nextInt(0, 256), rnd.nextInt(0, 256), rnd.nextInt(0, 256)), choiceDoors.getValue());
-        _bus.SetPosition(rnd.nextInt(10, 100), rnd.nextInt(10, 100), (int) pictureBoxBus.getWidth(), (int) pictureBoxBus.getHeight());
+
+        _bus = new DrawingBus(rnd.nextInt(100, 300), rnd.nextFloat(1000, 2000),
+                bodyColorPicker.getValue(), choiceDoors.getValue());
+        _bus.SetPosition(rnd.nextInt(10, 100), rnd.nextInt(10, 100),
+                (int) pictureBoxBus.getWidth(), (int) pictureBoxBus.getHeight());
+        BorderChanged();
+    }
+
+    void SetData() {
+        Random rnd = new Random();
+        _bus.SetPosition(rnd.nextInt(10, 100), rnd.nextInt(10, 100),
+                (int) pictureBoxBus.getWidth(), (int) pictureBoxBus.getHeight());
         statusSpeed.setText("Скорость: %s".formatted(_bus.Bus.Speed));
         statusWeight.setText("Вес: %s".formatted(_bus.Bus.Weight));
         statusColor.setText("Цвет: %s".formatted(_bus.Bus.BodyColor));
-        BorderChanged();
     }
 
     @FXML
     void ButtonMove_Click(ActionEvent event) {
+        pictureBoxBus.widthProperty().addListener(listener);
+        pictureBoxBus.heightProperty().addListener(listener);
+
         if (_bus == null) return;
         String name = ((Button) event.getSource()).getId();
         switch (name) {
@@ -85,13 +112,18 @@ public class ControllerBus {
     public void initialize() {
         choiceDoors.setItems(countOfDoors);
         choiceDoors.setValue(3);
-    }
+        if (_bus != null) {
+            Draw();
+        }
 
+    }
     InvalidationListener listener = o -> BorderChanged();
 
     private void Draw()
     {
         GraphicsContext gc = canvasBus.getGraphicsContext2D();
+        gc.setFill(Color.WHITE);
+        gc.fillRect(0, 0, pictureBoxBus.getWidth(), pictureBoxBus.getHeight());
         _bus.DrawTransport(gc);
     }
 
@@ -102,4 +134,49 @@ public class ControllerBus {
         Draw();
     }
 
+    @FXML
+    private void ButtonCreateExtra_Click(ActionEvent event) {
+        pictureBoxBus.widthProperty().addListener(listener);
+        pictureBoxBus.heightProperty().addListener(listener);
+        Random rnd = new Random();
+        _bus = new DrawingDDB(rnd.nextInt(300), rnd.nextInt(2000),
+                bodyColorPicker.getValue(), choiceDoors.getValue(),
+                extraColorPicker.getValue(), rnd.nextBoolean(), rnd.nextBoolean());
+        SetData();
+        BorderChanged();
+    }
+    @FXML
+    private void ButtonSelectBus_Click(ActionEvent event) throws IOException, StorageOverflowException {
+        SelectedBus = _bus;
+
+        if (SelectedBus == null) {
+            Alert alert = new Alert(Alert.AlertType.INFORMATION);
+            alert.setTitle("SelectBus");
+            alert.setContentText("Вы не создали объект");
+            Optional<ButtonType> option = alert.showAndWait();
+        }
+        else {
+
+            DrawingObjectBus bus = new DrawingObjectBus(SelectedBus);
+
+            if (ControllerMapWithSetBus.AddNewBus(bus) != -1) {
+                Alert alert = new Alert(Alert.AlertType.INFORMATION);
+                alert.setTitle("SelectBus");
+                alert.setContentText("Вы создали объект");
+                Optional<ButtonType> option = alert.showAndWait();
+            } else {
+                Alert alert = new Alert(Alert.AlertType.INFORMATION);
+                alert.setTitle("SelectBus");
+                alert.setContentText("Не удалось добавить объект");
+                Optional<ButtonType> option = alert.showAndWait();
+            }
+        }
+
+        _bus = null;
+        FXMLLoader fxmlLoader = new FXMLLoader(Form.class.getResource("FormMapWithSetBus.fxml"));
+        Scene scene = new Scene(fxmlLoader.load());
+        Form.myStage.setTitle("DoubleDeckerBus");
+        Form.myStage.setScene(scene);
+        Form.myStage.show();
+    }
 }

DoubleDeckerBus/src/main/java/com/example/doubledeckerbus/ControllerBusConfig.java

@@ -0,0 +1,187 @@
+package com.example.doubledeckerbus;
+
+import javafx.event.ActionEvent;
+import javafx.fxml.FXML;
+import javafx.scene.canvas.Canvas;
+import javafx.scene.canvas.GraphicsContext;
+import javafx.scene.control.Button;
+import javafx.scene.control.CheckBox;
+import javafx.scene.control.Label;
+import javafx.scene.control.Spinner;
+import javafx.scene.input.*;
+import javafx.scene.layout.Background;
+import javafx.scene.layout.Region;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.Paint;
+import javafx.stage.Stage;
+
+import java.util.function.Consumer;
+
+public class ControllerBusConfig {
+    DataFormat colorFormat = DataFormat.lookupMimeType("SerializableColor");
+    DataFormat additionalElementFormat = DataFormat.lookupMimeType("IDrawningAdditionalElement");
+    private Stage _stage;
+    private DrawingBus _bus = null;
+
+    private Event<DrawingBus> addBus;
+
+    public void SetStage(Stage stage)
+    {
+        _stage = stage;
+    }
+
+    public void AddEvent(Consumer<DrawingBus> ev)
+    {
+        addBus.AddListener(ev);
+    }
+
+    private void DrawBus()
+    {
+        GraphicsContext gc = canvasObject.getGraphicsContext2D();
+        gc.clearRect(0, 0, canvasObject.getWidth(), canvasObject.getHeight());
+        if (_bus == null)
+        {
+            return;
+        }
+        _bus.SetPosition(5, 5, (int)canvasObject.getWidth(), (int)canvasObject.getHeight());
+        _bus.DrawTransport(gc);
+    }
+
+    @FXML
+    private Canvas canvasObject;
+
+    @FXML
+    private CheckBox checkBoxSecondStage;
+
+    @FXML
+    private CheckBox checkBoxLadder;
+
+    @FXML
+    private Spinner<Integer> spinnerSpeed = new Spinner<>();
+
+    @FXML
+    private Spinner<Integer> spinnerDoors = new Spinner<>();
+
+    @FXML
+    private Spinner<Integer> spinnerWeight = new Spinner<>();
+
+    @FXML
+    public void initialize()
+    {
+        if (colorFormat == null)
+        {
+            colorFormat = new DataFormat("SerializableColor");
+        }
+        if (additionalElementFormat == null)
+        {
+            additionalElementFormat = new DataFormat("IDrawningAdditionalElement");
+        }
+        addBus = new Event<>();
+    }
+
+    @FXML
+    void ButtonOk_Click(ActionEvent event) {
+        if (_bus != null)
+        {
+            addBus.Broadcast(_bus);
+        }
+        if (_stage != null)
+        {
+            _stage.close();
+        }
+    }
+
+    @FXML
+    void CanvasObject_OnDragDropped(DragEvent event) {
+        Dragboard db = event.getDragboard();
+        switch (db.getString())
+        {
+            case "labelSimpleObject" -> _bus = new DrawingBus(spinnerSpeed.getValue(),
+                    spinnerWeight.getValue(), Color.WHITE, spinnerDoors.getValue());
+            case "labelModifiedObject" -> _bus = new DrawingDDB(spinnerSpeed.getValue(),
+                    spinnerWeight.getValue(), Color.WHITE, spinnerDoors.getValue(), Color.BLACK,
+                    checkBoxSecondStage.isSelected(), checkBoxLadder.isSelected());
+            case "labelTriangle" -> _bus.ChangeDoor(new DrawingTriangleDoors());
+            case "labelOval" -> _bus.ChangeDoor(new DrawingEllipsoidDoors());
+            case "labelRect" -> _bus.ChangeDoor(new DrawingDoors());
+        }
+        DrawBus();
+        event.consume();
+
+    }
+
+    @FXML
+    void CanvasObject_OnDragOver(DragEvent event) {
+        if (event.getDragboard().hasString())
+        {
+            event.acceptTransferModes(TransferMode.COPY_OR_MOVE);
+        }
+        event.consume();
+    }
+
+    @FXML
+    void LabelBaseColor_OnDragDropped(DragEvent event) {
+        if (_bus == null)
+        {
+            return;
+        }
+
+        Dragboard db = event.getDragboard();
+
+        _bus.Bus.BodyColor = ((SerializableColor)(db.getContent(colorFormat))).getFXColor();
+        event.consume();
+        DrawBus();
+    }
+
+    @FXML
+    void LabelColor_OnDragOver(DragEvent event) {
+        if (event.getDragboard().hasContent(colorFormat))
+        {
+            event.acceptTransferModes(TransferMode.COPY_OR_MOVE);
+        }
+        event.consume();
+    }
+
+    @FXML
+    void LabelDopColor_OnDragDropped(DragEvent event) {
+        if (_bus == null || !(_bus.Bus instanceof EntityDDB ddb))
+        {
+            return;
+        }
+
+        Dragboard db = event.getDragboard();
+
+        ddb.ExtraColor = ((SerializableColor)(db.getContent(colorFormat))).getFXColor();
+        event.consume();
+        DrawBus();
+    }
+
+    @FXML
+    void LabelObject_OnDragDetected(MouseEvent event) {
+        Label labelObject = (Label)(event.getSource());
+        Dragboard db = labelObject.startDragAndDrop(TransferMode.ANY);
+
+        ClipboardContent content = new ClipboardContent();
+        content.putString(((Label)(event.getSource())).getId());
+        db.setContent(content);
+
+        event.consume();
+    }
+
+    @FXML
+    void RegionColor_OnDragDetected(MouseEvent event) {
+        Region region = (Region)(event.getSource());
+        Dragboard db = region.startDragAndDrop(TransferMode.ANY);
+
+        Background regionBackground = region.getBackground();
+        Paint regionPaint = regionBackground.getFills().get(0).getFill();
+        if (regionPaint instanceof Color)
+        {
+            ClipboardContent content = new ClipboardContent();
+            content.put(colorFormat, new SerializableColor((Color)regionPaint));
+            db.setContent(content);
+        }
+        event.consume();
+    }
+
+}

DoubleDeckerBus/src/main/java/com/example/doubledeckerbus/ControllerMapWithSetBus.java

@@ -0,0 +1,468 @@
+package com.example.doubledeckerbus;
+
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.event.ActionEvent;
+import javafx.fxml.FXML;
+import javafx.fxml.FXMLLoader;
+import javafx.scene.Scene;
+import javafx.scene.canvas.Canvas;
+import javafx.scene.canvas.GraphicsContext;
+import javafx.scene.control.*;
+import javafx.scene.layout.AnchorPane;
+import javafx.scene.paint.Color;
+import javafx.stage.FileChooser;
+import javafx.stage.Stage;
+
+import java.io.*;
+import java.util.*;
+
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+
+public class ControllerMapWithSetBus {
+    static MapWithSetBusesGeneric<DrawingObjectBus, AbstractMap> _mapBusesCollectionGeneric;
+    private final HashMap<String, AbstractMap> _mapsDict = new HashMap<>();
+    {
+        _mapsDict.put("Простая карта", new SimpleMap());
+        _mapsDict.put("Водная карта", new WaterMap());
+    }
+    AbstractMap map = new SimpleMap();
+    private final Logger _logger = LogManager.getLogger(ControllerMapWithSetBus.class);
+
+    public static int AddNewBus (DrawingObjectBus bus) throws StorageOverflowException {
+        return _mapsCollection.GetId(selected).add(bus);
+    }
+    static public MapsCollection _mapsCollection;
+
+    static String selected;
+
+    static String map_name = "Простая карта";
+    protected ObservableList<String> countOfMap = FXCollections.observableArrayList("Простая карта", "Водная карта");
+
+    @FXML
+    private Canvas canvasBus;
+
+    @FXML
+    private Button buttonLeft;
+
+    @FXML
+    private ChoiceBox<String> comboBoxSelectorMap;
+
+    @FXML
+    private AnchorPane pictureBoxBus;
+
+    @FXML
+    private TextField textBoxPosition;
+
+    @FXML
+    private ListView<String> listViewMaps;
+
+    @FXML
+    private TextField TextFieldMap;
+
+    @FXML
+    private void initialize() throws FileNotFoundException {
+        gc = canvasBus.getGraphicsContext2D();
+        if (selected != null) {
+            showStorage();
+        }
+        Properties prop = new Properties();
+//        InputStream = new FileInputStream("/home/user/IdeaProjects/PIbd-21_Zaharchenko_M.I._DoubleDeckerBus._Hard/DoubleDeckerBus/src/main/resources/com/example/doubledeckerbus/log4j2.xml");
+        
+        Logger log = LogManager.getLogger(ControllerMapWithSetBus.class);
+        if (_mapsCollection == null)
+            _mapsCollection = new MapsCollection((int) canvasBus.getWidth(), (int) canvasBus.getHeight());
+        comboBoxSelectorMap.setItems(countOfMap);
+        comboBoxSelectorMap.setValue(map_name);
+        listViewMaps.getSelectionModel().selectedItemProperty()
+                .addListener((observableValue, s, t1) -> {
+                    selected = t1;
+                    _logger.info("Another Map has been chosen");
+                    showStorage();
+                });
+        listViewMaps.setItems(_mapsCollection.toObserveList());
+    }
+
+    GraphicsContext gc;
+    private void FirstIncome() {
+        if (!Objects.equals(comboBoxSelectorMap.getValue(), map_name)) {
+            map_name = comboBoxSelectorMap.getValue();
+            switch (map_name) {
+                case "Простая карта" -> map = new SimpleMap();
+                case "Водная карта" -> map = new WaterMap();
+            }
+        }
+    }
+
+    private void ReloadMaps()
+    {
+        int index = listViewMaps.getSelectionModel().getSelectedIndex();
+
+        ObservableList<String> listMaps = FXCollections.observableArrayList();
+
+        listMaps.addAll(_mapsCollection.Keys());
+        listViewMaps.setItems(listMaps);
+
+        if (listMaps.size() > 0 && (index == -1 || index >= listMaps.size()))
+        {
+            listViewMaps.getSelectionModel().select(0);
+        }
+        else if (listMaps.size() > 0 && index > -1)
+        {
+            listViewMaps.getSelectionModel().select(index);
+        }
+    }
+
+    @FXML
+    private void ButtonAddBus_Click(ActionEvent event) throws IOException {
+        if (listViewMaps.getSelectionModel().selectedItemProperty().isNull().get())
+        {
+            return;
+        }
+        Stage busStage = new Stage();
+        FXMLLoader fxmlLoader = new FXMLLoader(Form.class.getResource("FormBusConfig.fxml"));
+        Scene sceneBus = new Scene(fxmlLoader.load());
+
+        busStage.setScene(sceneBus);
+        busStage.show();
+
+        ControllerBusConfig controllerBusConfig = fxmlLoader.getController();
+        controllerBusConfig.AddEvent(this::AddBus);
+        controllerBusConfig.SetStage(busStage);
+
+        FirstIncome();
+    }
+
+    private void AddBus(DrawingBus bus) {
+        if (listViewMaps.getSelectionModel().selectedItemProperty().isNull().get())
+        {
+            return;
+        }
+        DrawingObjectBus objectBus = new DrawingObjectBus(bus);
+        String selectedMapName = listViewMaps.getSelectionModel().getSelectedItem();
+
+        Alert alert;
+        try {
+            if (selectedMapName != null && selectedMapName.length() != 0 && _mapsCollection.get(selectedMapName).add(objectBus) != -1)
+            {
+                alert = new Alert(Alert.AlertType.INFORMATION, "Объект добавлен", ButtonType.OK);
+                _mapsCollection.get(selectedMapName).ShowSet(gc);
+                _logger.info("Bus added");
+            }
+            else
+            {
+                alert = new Alert(Alert.AlertType.ERROR, "Не удалось добавить объект", ButtonType.OK);
+                _logger.warn("Bus not added");
+            }
+        } catch (StorageOverflowException e) {
+            _logger.warn("StorageOverFlow");
+            alert = new Alert(Alert.AlertType.ERROR, "Хранилище переполнено");
+        }
+        catch (IllegalArgumentException e) {
+            _logger.warn("The same bus");
+            alert = new Alert(Alert.AlertType.ERROR, "Такой автобус был");
+        }
+        showStorage();
+        alert.showAndWait();
+    }
+
+    @FXML
+    private void ButtonAddMap_Click(ActionEvent event)
+    {
+        if ((Objects.equals(TextFieldMap.getText(), "")))
+        {
+            Alert alert = new Alert(Alert.AlertType.INFORMATION);
+            alert.setTitle("SelectMap");
+            alert.setContentText("Не все данные заполнены");
+            Optional<ButtonType> option = alert.showAndWait();
+            return;
+        }
+        if (!_mapsDict.containsKey(comboBoxSelectorMap.getValue()))
+        {
+            Alert alert = new Alert(Alert.AlertType.INFORMATION);
+            alert.setTitle("SelectMap");
+            alert.setContentText("Нет такой карты");
+            Optional<ButtonType> option = alert.showAndWait();
+            return;
+        }
+        _mapsCollection.AddMap(TextFieldMap.getText(), _mapsDict.get(comboBoxSelectorMap.getValue()));
+        ReloadMaps();
+        showStorage();
+    }
+    @FXML
+    private void ButtonDeleteMap_Click(ActionEvent event)
+    {
+        if (listViewMaps.getSelectionModel().selectedItemProperty().isNull().get())
+        {
+            return;
+        }
+        _mapsCollection.DelMap(listViewMaps.getSelectionModel().getSelectedItem());
+        _logger.info("Map was deleted");
+        ReloadMaps();
+        showStorage();
+    }
+
+    @FXML
+    private void ButtonDeleteEditBus_Click(ActionEvent event) throws IOException {
+        if (selected == null)
+        {
+            return;
+        }
+        DrawingObjectBus deleteBus = (DrawingObjectBus) _mapsCollection.get(selected).getDeletedBus();
+        if (deleteBus != null) {
+            ControllerBus._bus = deleteBus.getBus();
+            FXMLLoader fxmlLoader = new FXMLLoader(Form.class.getResource("FormBus.fxml"));
+            Scene scene = new Scene(fxmlLoader.load());
+            Form.myStage.setTitle("DoubleDeckerBus");
+            Form.myStage.setScene(scene);
+            Form.myStage.show();
+        }
+        _logger.info("Bus Edited");
+    }
+
+    @FXML
+    private void ButtonRemoveBus_Click(ActionEvent event)
+    {
+        FirstIncome();
+        if (Objects.equals(textBoxPosition.getText(), ""))
+        {
+            return;
+        }
+        Alert alert = new Alert(Alert.AlertType.CONFIRMATION);
+        alert.setTitle("RemoveBus");
+        alert.setHeaderText("Вы действительно хотите удалить объект?");
+
+        Optional<ButtonType> option = alert.showAndWait();
+        if (option.get() == ButtonType.CANCEL) {
+            return;
+        }
+
+        int pos;
+        try {
+            pos = Integer.parseInt(textBoxPosition.getText());
+
+            if (pos < 1 || pos > _mapsCollection.GetId(selected).getCount()) return;
+
+            if (_mapsCollection.GetId(selected).remove(pos) != null)
+            {
+                alert = new Alert(Alert.AlertType.WARNING);
+                alert.setTitle("RemoveBus");
+                alert.setContentText("Вы удалили объект");
+                option = alert.showAndWait();
+                _logger.info("Bus removed");
+            }
+            else
+            {
+                alert = new Alert(Alert.AlertType.WARNING);
+                alert.setTitle("RemoveBus");
+                alert.setContentText("Не удалось удалить объект");
+                option = alert.showAndWait();
+            }
+            showStorage();
+        }
+        catch (BusNotFoundException e) {
+            alert = new Alert(Alert.AlertType.WARNING);
+            alert.setTitle("RemoveBus");
+            alert.setContentText("Не удалось удалить объект");
+            option = alert.showAndWait();
+            _logger.warn("bus not found");
+        }
+        catch (Exception e) {
+            alert = new Alert(Alert.AlertType.WARNING);
+            alert.setTitle("RemoveBus");
+            alert.setContentText("Не удалось удалить объект");
+            option = alert.showAndWait();
+            _logger.warn("strange error");
+        }
+
+
+    }
+
+    @FXML
+    private void ButtonShowStorage_Click(ActionEvent event)
+    {
+        FirstIncome();
+        showStorage();
+        _logger.info("show storage");
+    }
+
+    @FXML
+    private void ButtonSortByType_Click(ActionEvent event)
+    {
+        if (listViewMaps.getSelectionModel().getSelectedIndex() == -1)
+        {
+            return;
+        }
+        String selectedMapName = listViewMaps.getSelectionModel().getSelectedItem();
+        if (selectedMapName != null)
+        {
+            _mapsCollection.get(selectedMapName).Sort(new BusComparatorByType());
+            _mapsCollection.get(selectedMapName).ShowSet(gc);
+            showStorage();
+        }
+    }
+
+    @FXML
+    private void ButtonSortByColor_Click(ActionEvent event)
+    {
+        if (listViewMaps.getSelectionModel().getSelectedIndex() == -1)
+        {
+            return;
+        }
+        String selectedMapName = listViewMaps.getSelectionModel().getSelectedItem();
+        if (selectedMapName != null)
+        {
+            _mapsCollection.get(selectedMapName).Sort(new BusComparatorByColor());
+            _mapsCollection.get(selectedMapName).ShowSet(gc);
+            showStorage();
+        }
+    }
+
+    @FXML
+    private void ButtonShowOnMap_Click(ActionEvent event) throws StorageOverflowException, BusNotFoundException {
+        FirstIncome();
+        if (selected == null) {
+            return;
+        }
+        gc.setFill(Color.WHITE);
+        gc.fillRect(0, 0, canvasBus.getWidth(), canvasBus.getHeight());
+        _mapsCollection.GetId(selected).ShowOnMap(gc);
+        _logger.info("show on map");
+    }
+
+    @FXML
+    private void ButtonMove_Click(ActionEvent event)
+    {
+        if (selected == null)
+        {
+            return;
+        }
+
+        String name = ((Button) event.getSource()).getId();
+        Direction dir = Direction.None;
+        switch (name) {
+            case "buttonUp" -> dir = Direction.Up;
+            case "buttonDown" -> dir = Direction.Down;
+            case "buttonLeft" -> dir = Direction.Left;
+            case "buttonRight" -> dir = Direction.Right;
+        }
+        _mapsCollection.GetId(selected).MoveObject(dir);
+        _logger.info("Button move click");
+    }
+
+    @FXML
+    private void ButtonSave_Click(ActionEvent event) throws IOException {
+        Alert infoAlert;
+        Stage stage = (Stage)(canvasBus.getScene().getWindow());
+        FileChooser fileChooser = new FileChooser();
+        fileChooser.setTitle("Save");
+
+        FileChooser.ExtensionFilter fileExtensions = new FileChooser.ExtensionFilter("TEXT files (*.txt)",
+                "*.txt");
+        fileChooser.getExtensionFilters().add(fileExtensions);
+
+        File selectedDirectory = fileChooser.showSaveDialog(stage);
+        if (selectedDirectory != null)
+        {
+            try {
+                String filepath = selectedDirectory.getPath();
+                _mapsCollection.SaveData(filepath);
+                infoAlert = new Alert(Alert.AlertType.INFORMATION, "Save was successful", ButtonType.OK);
+                _logger.info("Save was successful");
+            }
+            catch (Exception e) {
+                infoAlert = new Alert(Alert.AlertType.INFORMATION, "Exception " + e.getMessage(), ButtonType.OK);
+                _logger.warn("Save wasnt successful");
+            }
+        }
+        else
+        {
+            infoAlert = new Alert(Alert.AlertType.INFORMATION, "The file was not saved", ButtonType.OK);
+            _logger.info("Not saved");
+        }
+        infoAlert.showAndWait();
+    }
+
+    @FXML
+    private void ButtonLoad_Click(ActionEvent event) throws IOException, StorageOverflowException {
+        Alert infoAlert;
+        Stage stage = (Stage)(buttonLeft.getScene().getWindow());
+        FileChooser fileChooser = new FileChooser();
+        fileChooser.setTitle("Load");
+
+        FileChooser.ExtensionFilter fileExtensions = new FileChooser.ExtensionFilter("TEXT files (*.txt)", "*.txt");
+        fileChooser.getExtensionFilters().add(fileExtensions);
+
+        File selectedDirectory = fileChooser.showOpenDialog(stage);
+        if (selectedDirectory != null)
+        {
+            try {
+                String filepath = selectedDirectory.getPath();
+                _mapsCollection.LoadData(filepath);
+                infoAlert = new Alert(Alert.AlertType.INFORMATION, "Load was successful", ButtonType.OK);
+                _logger.info("Load was successful");
+                ReloadMaps();
+            } catch (Exception e) {
+                infoAlert = new Alert(Alert.AlertType.ERROR, "StrangeException: " + e.getMessage(), ButtonType.OK);
+                _logger.warn("StrangeException");
+            }
+        }
+        else
+        {
+            infoAlert = new Alert(Alert.AlertType.INFORMATION, "The file was not loaded", ButtonType.OK);
+            _logger.info("The file was not loaded");
+        }
+        infoAlert.showAndWait();
+    }
+
+    @FXML
+    private void ButtonSaveStorage_Click(ActionEvent event) throws IOException {
+        Alert infoAlert;
+        Stage stage = (Stage)(canvasBus.getScene().getWindow());
+        FileChooser fileChooser = new FileChooser();
+        fileChooser.setTitle("Save");
+
+        FileChooser.ExtensionFilter fileExtensions = new FileChooser.ExtensionFilter("TEXT files (*.txt)",
+                "*.txt");
+        fileChooser.getExtensionFilters().add(fileExtensions);
+
+        File selectedDirectory = fileChooser.showSaveDialog(stage);
+        if (selectedDirectory != null)
+        {
+            try {
+                String filepath = selectedDirectory.getPath();
+                _mapsCollection.SaveStorage(filepath, listViewMaps.getSelectionModel().getSelectedItem());
+                infoAlert = new Alert(Alert.AlertType.INFORMATION, "Save was successful", ButtonType.OK);
+                _logger.info("Save storage was successful");
+            }
+            catch (Exception e) {
+                infoAlert = new Alert(Alert.AlertType.INFORMATION, "Exseption " + e.getMessage() , ButtonType.OK);
+                _logger.warn("Save storage wasnt successful");
+            }
+        }
+        else
+        {
+            infoAlert = new Alert(Alert.AlertType.INFORMATION, "The file was not saved", ButtonType.OK);
+            _logger.info("Save storage wasnt successful");
+        }
+        infoAlert.showAndWait();
+    }
+
+    private void showStorage() {
+        if (selected == null)
+        {
+            return;
+        }
+        gc.setFill(Color.WHITE);
+        gc.fillRect(0, 0, pictureBoxBus.getWidth(), pictureBoxBus.getHeight());
+        _mapsCollection.GetId(selected).ShowSet(gc);
+        _logger.info("showStorage");
+    }
+
+
+}
+
+

DoubleDeckerBus/src/main/java/com/example/doubledeckerbus/ControllerPolymorph.java

@@ -0,0 +1,165 @@
+package com.example.doubledeckerbus;
+
+import javafx.beans.InvalidationListener;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.event.ActionEvent;
+import javafx.fxml.FXML;
+import javafx.fxml.FXMLLoader;
+import javafx.scene.Scene;
+import javafx.scene.canvas.Canvas;
+import javafx.scene.canvas.GraphicsContext;
+import javafx.scene.control.*;
+import javafx.scene.layout.AnchorPane;
+import javafx.scene.paint.Color;
+
+import java.io.IOException;
+import java.util.Optional;
+import java.util.Random;
+
+import static com.example.doubledeckerbus.ControllerMapWithSetBus._mapBusesCollectionGeneric;
+
+public class ControllerPolymorph {
+    protected DrawingBus _bus;
+    protected DrawingPolymorphBus<EntityBus, IDrawingDoors> polymorphBus;
+    public DrawingBus SelectedBus;
+    protected ObservableList<Integer> countOfDoors = FXCollections.observableArrayList(3, 4, 5);
+
+    @FXML
+    protected Button buttonCreate;
+
+    @FXML
+    protected Canvas canvasBus;
+
+    @FXML
+    protected AnchorPane pictureBoxBus;
+
+    @FXML
+    protected Label statusColor;
+
+    @FXML
+    protected Label statusSpeed;
+
+    @FXML
+    protected Label statusWeight;
+
+    @FXML
+    protected ChoiceBox<Integer> choiceDoors;
+
+    @FXML
+    void ButtonCreate_Click(ActionEvent event) {
+        pictureBoxBus.widthProperty().addListener(listener);
+        pictureBoxBus.heightProperty().addListener(listener);
+
+        Random rnd = new Random();
+        IDrawingDoors door = null;
+        switch (rnd.nextInt(3)) {
+            case (0) -> door = new DrawingDoors();
+            case (1) -> door = new DrawingEllipsoidDoors();
+            case (2) -> door = new DrawingTriangleDoors();
+        }
+        door.setCountOfDoors(choiceDoors.getValue());
+
+        EntityBus bus = new EntityBus(rnd.nextInt(300), rnd.nextInt(2000),
+                Color.rgb(rnd.nextInt(256), rnd.nextInt(256), rnd.nextInt(256)));
+
+        polymorphBus.AddDoors(door);
+        polymorphBus.AddEntity(bus);
+
+        _bus = polymorphBus.CreateBus();
+        SetData();
+        BorderChanged();
+    }
+
+    void SetData() {
+        Random rnd = new Random();
+        _bus.SetPosition(rnd.nextInt(10, 100), rnd.nextInt(10, 100), (int) pictureBoxBus.getWidth(), (int) pictureBoxBus.getHeight());
+        statusSpeed.setText("Скорость: %s".formatted(_bus.Bus.Speed));
+        statusWeight.setText("Вес: %s".formatted(_bus.Bus.Weight));
+        statusColor.setText("Цвет: %s".formatted(_bus.Bus.BodyColor));
+    }
+
+    @FXML
+    public void initialize() {
+        polymorphBus = new DrawingPolymorphBus<>(100, 100);
+        choiceDoors.setItems(countOfDoors);
+        choiceDoors.setValue(3);
+
+    }
+    InvalidationListener listener = o -> BorderChanged();
+
+    private void Draw()
+    {
+        GraphicsContext gc = canvasBus.getGraphicsContext2D();
+        gc.setFill(Color.WHITE);
+        gc.fillRect(0, 0, pictureBoxBus.getWidth(), pictureBoxBus.getHeight());
+        _bus.DrawTransport(gc);
+    }
+
+    void BorderChanged() {
+        canvasBus.setWidth(pictureBoxBus.getWidth());
+        canvasBus.setHeight(pictureBoxBus.getHeight());
+        _bus.ChangeBorders((int) pictureBoxBus.getWidth(), (int) pictureBoxBus.getHeight());
+        Draw();
+    }
+
+    @FXML
+    private void ButtonCreateExtra_Click(ActionEvent event) {
+        pictureBoxBus.widthProperty().addListener(listener);
+        pictureBoxBus.heightProperty().addListener(listener);
+        Random rnd = new Random();
+        IDrawingDoors door = null;
+        switch (rnd.nextInt(3)) {
+            case (0) -> door = new DrawingDoors();
+            case (1) -> door = new DrawingEllipsoidDoors();
+            case (2) -> door = new DrawingTriangleDoors();
+        }
+        door.setCountOfDoors(choiceDoors.getValue());
+
+        EntityDDB ddb_bus = new EntityDDB(rnd.nextInt(300), rnd.nextInt(2000),
+                Color.rgb(rnd.nextInt(256), rnd.nextInt(256), rnd.nextInt(256)),
+                Color.rgb(rnd.nextInt(256), rnd.nextInt(256), rnd.nextInt(256)),
+                rnd.nextBoolean(), rnd.nextBoolean());
+
+        polymorphBus.AddDoors(door);
+        polymorphBus.AddEntity(ddb_bus);
+
+        _bus = polymorphBus.CreateBus();
+        SetData();
+        BorderChanged();
+    }
+    @FXML
+    private void ButtonSelectBus_Click(ActionEvent event) throws IOException, StorageOverflowException {
+        SelectedBus = _bus;
+
+        if (SelectedBus == null) {
+            Alert alert = new Alert(Alert.AlertType.INFORMATION);
+            alert.setTitle("SelectBus");
+            alert.setContentText("Вы не создали объект");
+            Optional<ButtonType> option = alert.showAndWait();
+        }
+        else {
+
+            DrawingObjectBus bus = new DrawingObjectBus(SelectedBus);
+
+            if (_mapBusesCollectionGeneric.add(bus) != -1) {
+                Alert alert = new Alert(Alert.AlertType.INFORMATION);
+                alert.setTitle("SelectBus");
+                alert.setContentText("Вы создали объект");
+                Optional<ButtonType> option = alert.showAndWait();
+            } else {
+                Alert alert = new Alert(Alert.AlertType.INFORMATION);
+                alert.setTitle("SelectBus");
+                alert.setContentText("Не удалось добавить объект");
+                Optional<ButtonType> option = alert.showAndWait();
+            }
+        }
+
+        FXMLLoader fxmlLoader = new FXMLLoader(Form.class.getResource("FormMapWithSetBus.fxml"));
+        Scene scene = new Scene(fxmlLoader.load());
+        Form.myStage.setTitle("DoubleDeckerBus");
+        Form.myStage.setScene(scene);
+        Form.myStage.show();
+
+    }
+}

DoubleDeckerBus/src/main/java/com/example/doubledeckerbus/Direction.java

@@ -1,6 +1,7 @@
 package com.example.doubledeckerbus;
 
 public enum Direction {
+    None(0),
     Up(1),
     Down(2),
     Left(3),

DoubleDeckerBus/src/main/java/com/example/doubledeckerbus/DrawingBus.java

@@ -3,36 +3,78 @@ package com.example.doubledeckerbus;
 import javafx.scene.canvas.GraphicsContext;
 import javafx.scene.paint.Color;
 
+import java.util.Random;
+
 public class DrawingBus {
     public EntityBus Bus;
 
-    public DrawingDoors Doors;
-
-    public EntityBus getBus() {
-        return Bus;
-    }
+    public IDrawingDoors Doors;
+    int _speed;
+    float _weight;
+    Color _bodyColor;
+    int _countOfDoors = 3;
 
     private static final int _null = -1000;
-    private float _startPosX;
-    private float _startPosY;
+    protected float _startPosX;
+    protected float _startPosY;
     private int _pictureWidth;
     private int _pictureHeight;
     private static final int _busWidth = 100;
     private static final int _busHeight = 50;
 
-    public void Init(int speed, float weight, Color bodyColor, int countOfDoors) {
-        Bus = new EntityBus();
-        Bus.Init(speed, weight, bodyColor);
-        Doors = new DrawingDoors();
+    public DrawingBus(int speed, float weight, Color bodyColor, int countOfDoors) {
+        Bus = CreateBus(speed, weight, bodyColor, countOfDoors);
+    }
+
+    public DrawingBus(int speed, float weight, Color bodyColor, int countOfDoors, IDrawingDoors TypeDoors) {
+        _speed = speed;
+        _weight = weight;
+        _bodyColor = bodyColor;
+        _countOfDoors = countOfDoors;
+        EntityBus bus = new EntityBus(speed, weight, bodyColor);
+        Doors = TypeDoors;
         Doors.setCountOfDoors(countOfDoors);
+        Bus = bus;
+    }
+
+    private EntityBus CreateBus(int speed, float weight, Color bodyColor, int countOfDoors) {
+        _speed = speed;
+        _weight = weight;
+        _bodyColor = bodyColor;
+        _countOfDoors = countOfDoors;
+        EntityBus bus = new EntityBus(speed, weight, bodyColor);
+        switch (new Random().nextInt(3)) {
+            case 0 -> Doors = new DrawingTriangleDoors();
+            case 1 -> Doors = new DrawingDoors();
+            case 2 -> Doors = new DrawingEllipsoidDoors();
+        }
+        Doors.setCountOfDoors(countOfDoors);
+        return bus;
+    }
+
+
+    public void ChangeDoor(IDrawingDoors door) {
+        Doors = door;
+        Doors.setCountOfDoors(_countOfDoors);
+    }
+
+
+    public DrawingBus(int speed, float weight, Color bodyColor) {
+        Bus = new EntityBus(speed, weight, bodyColor);
+    }
+
+    public DrawingBus(EntityBus bus, IDrawingDoors doors) {
+        Bus = bus;
+        Doors = doors;
     }
 
     public void SetPosition(int x, int y, int width, int height) {
-        if (_pictureWidth <= _busWidth || _pictureHeight <= _busHeight) {
+        if (width <= _busWidth || height <= _busHeight) {
             _pictureWidth = _null;
             _pictureHeight = _null;
             return;
         }
+
         _startPosX = x;
         _startPosY = y;
         _pictureWidth = width;
@@ -81,7 +123,7 @@ public class DrawingBus {
             return;
         }
 
-        gc.clearRect(0, 0, _pictureWidth, _pictureHeight);
+
         gc.setFill(Bus.BodyColor);
         gc.fillRect(_startPosX, _startPosY + 10, 100, 30);
 
@@ -119,4 +161,8 @@ public class DrawingBus {
             _startPosY = _pictureHeight - _busHeight;
         }
     }
+
+    public Position GetCurrentPosition() {
+        return new Position(_startPosX, _startPosX + _busWidth, _startPosY, _startPosY + _busHeight);
+    }
 }

DoubleDeckerBus/src/main/java/com/example/doubledeckerbus/DrawingDDB.java

@@ -0,0 +1,78 @@
+package com.example.doubledeckerbus;
+
+import javafx.scene.canvas.GraphicsContext;
+import javafx.scene.paint.Color;
+
+public class DrawingDDB extends DrawingBus{
+    Color _extraColor;
+    boolean _ladder;
+    boolean _secondStage;
+
+    public DrawingDDB(int speed, float weight, Color bodyColor, int countOfDoors,
+                      Color extraColor, boolean ladder, boolean secondStage) {
+        super(speed, weight, bodyColor, countOfDoors);
+        Bus = CreateDDB(speed, weight, bodyColor, countOfDoors, extraColor, ladder, secondStage);
+    }
+
+    public DrawingDDB(int speed, float weight, Color bodyColor, int countOfDoors, IDrawingDoors typeDoor,
+                      Color extraColor, boolean ladder, boolean secondStage) {
+        super(speed, weight, bodyColor, countOfDoors, typeDoor);
+        Bus = CreateDDB(speed, weight, bodyColor, countOfDoors, extraColor, ladder, secondStage);
+    }
+
+    private EntityDDB CreateDDB(int speed, float weight, Color bodyColor, int countOfDoors,
+                      Color extraColor, boolean ladder, boolean secondStage) {
+        _speed = speed;
+        _weight = weight;
+        _bodyColor = bodyColor;
+        _countOfDoors = countOfDoors;
+        _extraColor = extraColor;
+        _ladder = ladder;
+        _secondStage = secondStage;
+        return new EntityDDB(speed, weight, bodyColor, extraColor, ladder, secondStage);
+    }
+
+    public DrawingDDB(int speed, float weight, Color bodyColor, Color extraColor, boolean ladder, boolean secondStage) {
+        super(speed, weight, bodyColor);
+        Bus = new EntityDDB(speed, weight, bodyColor, extraColor, ladder, secondStage);
+    }
+
+    public DrawingDDB(EntityBus bus, IDrawingDoors doors) {
+        super(bus, doors);
+    }
+
+    @Override
+    public void DrawTransport(GraphicsContext gc)
+    {
+        if (Bus == null) return;
+
+        _startPosY += 30;
+        super.DrawTransport(gc);
+        _startPosY -= 30;
+        EntityDDB ddb = (EntityDDB) Bus;
+
+        gc.setFill(ddb.ExtraColor);
+        if (ddb.SecondStage) {
+            gc.fillRect(_startPosX, _startPosY + 10, 100, 30);
+            gc.setFill(Color.BLACK);
+            gc.fillRect(_startPosX + 30, _startPosY + 20, 10, 20);
+
+            gc.setFill(Color.BLUE);
+            gc.fillOval(_startPosX + 10, _startPosY + 15, 10, 15);
+            gc.fillOval(_startPosX + 50, _startPosY + 15, 10, 15);
+            gc.fillOval(_startPosX + 70, _startPosY + 15, 10, 15);
+            gc.fillOval(_startPosX + 90, _startPosY + 15, 10, 15);
+        }
+
+        if (ddb.Ladder) {
+            gc.strokeLine(_startPosX, _startPosY + 70, _startPosX, _startPosY + 10);
+            gc.strokeLine(_startPosX + 10, _startPosY + 70, _startPosX + 10, _startPosY + 10);
+
+            gc.strokeLine(_startPosX, _startPosY + 20, _startPosX + 10, _startPosY + 20);
+            gc.strokeLine(_startPosX, _startPosY + 30, _startPosX + 10, _startPosY + 30);
+            gc.strokeLine(_startPosX, _startPosY + 40, _startPosX + 10, _startPosY + 40);
+            gc.strokeLine(_startPosX, _startPosY + 50, _startPosX + 10, _startPosY + 50);
+            gc.strokeLine(_startPosX, _startPosY + 60, _startPosX + 10, _startPosY + 60);
+        }
+    }
+}

DoubleDeckerBus/src/main/java/com/example/doubledeckerbus/DrawingDoors.java

@@ -3,10 +3,11 @@ package com.example.doubledeckerbus;
 import javafx.scene.canvas.GraphicsContext;
 import javafx.scene.paint.Color;
 
-public class DrawingDoors {
+public class DrawingDoors implements IDrawingDoors {
     private CountOfDoors _countOfDoors;
 
-    public void DrawDoors(GraphicsContext gc, int _startPosX, int _startPosY) {
+    @Override
+    public void DrawDoors(GraphicsContext gc, float _startPosX, float _startPosY) {
         gc.setFill(Color.BLACK);
         gc.fillRect(_startPosX, _startPosY + 20, 10, 20);
         gc.fillRect(_startPosX + 20, _startPosY + 20, 10, 20);
@@ -19,13 +20,13 @@ public class DrawingDoors {
         }
     }
 
-    public void setCountOfDoors(int number) {
+    @Override
+    public void setCountOfDoors(int count) {
         for (CountOfDoors item: CountOfDoors.values()) {
-            if (item.getId() == number) {
+            if (item.getId() == count) {
                 _countOfDoors = item;
                 return;
             }
         }
-
     }
 }

DoubleDeckerBus/src/main/java/com/example/doubledeckerbus/DrawingEllipsoidDoors.java

@@ -0,0 +1,33 @@
+package com.example.doubledeckerbus;
+
+import javafx.scene.canvas.GraphicsContext;
+import javafx.scene.paint.Color;
+
+public class DrawingEllipsoidDoors implements IDrawingDoors{
+    private CountOfDoors _countOfDoors;
+
+    @Override
+    public void DrawDoors(GraphicsContext gc, float _startPosX, float _startPosY) {
+        gc.setFill(Color.GRAY);
+        gc.fillOval(_startPosX, _startPosY + 20, 10, 20);
+        gc.fillOval(_startPosX + 20, _startPosY + 20, 10, 20);
+        gc.fillOval(_startPosX + 40, _startPosY + 20, 10, 20);
+        if (_countOfDoors.getId() >= 4) {
+            gc.fillOval(_startPosX + 60, _startPosY + 20, 10, 20);
+        }
+        if (_countOfDoors.getId() >= 5) {
+            gc.fillOval(_startPosX + 80, _startPosY + 20, 10, 20);
+        }
+    }
+
+    @Override
+    public void setCountOfDoors(int count) {
+        for (CountOfDoors item: CountOfDoors.values()) {
+            if (item.getId() == count) {
+                _countOfDoors = item;
+                return;
+            }
+        }
+    }
+
+}

DoubleDeckerBus/src/main/java/com/example/doubledeckerbus/DrawingObjectBus.java

@@ -0,0 +1,106 @@
+package com.example.doubledeckerbus;
+
+import javafx.scene.canvas.GraphicsContext;
+
+import java.util.Objects;
+
+public class DrawingObjectBus implements IDrawingObject {
+    private DrawingBus _bus = null;
+
+    public DrawingObjectBus(DrawingBus bus)
+    {
+        _bus = bus;
+    }
+
+    public float Step() {
+        if (_bus != null && _bus.Bus != null) {
+            return _bus.Bus.Step;
+        }
+        return 0;
+    }
+
+    public Position GetCurrentPosition()
+    {
+        if (_bus != null) {
+            return _bus.GetCurrentPosition();
+        }
+        return null;
+    }
+
+    @Override
+    public String GetInfo() {
+        return ExtensionBus.GetDataForSave(_bus);
+    }
+
+    public void MoveObject(Direction direction)
+    {
+        _bus.MoveTransport(direction);
+    }
+
+    public void SetObject(int x, int y, int width, int height)
+    {
+        _bus.SetPosition(x, y, width, height);
+    }
+
+    public void DrawingObject(GraphicsContext gc)
+    {
+        _bus.DrawTransport(gc);
+    }
+
+    public DrawingBus getBus() {
+        return _bus;
+    }
+
+    public static IDrawingObject Create(String data) {
+        return new DrawingObjectBus(ExtensionBus.CreateDrawingBus(data));
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null)
+        {
+            return false;
+        }
+        var otherBus = (DrawingObjectBus) obj;
+        if (otherBus == null)
+        {
+            return false;
+        }
+        var bus = _bus.Bus;
+        var otherBusBus = otherBus._bus.Bus;
+        if (bus.Speed != otherBusBus.Speed)
+        {
+            return false;
+        }
+        if (bus.Weight != otherBusBus.Weight)
+        {
+            return false;
+        }
+        if (!Objects.equals(bus.getBodyColor().toString(), otherBusBus.getBodyColor().toString()))
+        {
+            return false;
+        }
+        if (!_bus.Doors.getClass().toString().equals(otherBus._bus.Doors.getClass().toString())) {
+            return false;
+        }
+        if (_bus._countOfDoors != otherBus._bus._countOfDoors) {
+            return false;
+        }
+        if (bus instanceof EntityDDB DDB && otherBusBus instanceof EntityDDB otherDDB)
+        {
+
+            if (DDB.Ladder != otherDDB.Ladder) {
+                return false;
+            }
+
+            if (DDB.SecondStage != otherDDB.SecondStage) {
+                return false;
+            }
+
+            return Objects.equals(DDB.ExtraColor.toString(), otherDDB.ExtraColor.toString());
+
+        }
+
+        return true;
+    }
+}

DoubleDeckerBus/src/main/java/com/example/doubledeckerbus/DrawingPolymorphBus.java

@@ -0,0 +1,45 @@
+package com.example.doubledeckerbus;
+
+import java.util.Random;
+
+public class DrawingPolymorphBus<T extends EntityBus, U extends IDrawingDoors> {
+    Object[] buses;
+    Object[] doors;
+
+    int busesCount = 0;
+    int doorsCount = 0;
+
+    public DrawingPolymorphBus(int busesCount, int doorsCount) {
+        buses = new Object[busesCount];
+        doors = new Object[doorsCount];
+    }
+
+    public int AddEntity(T bus)
+    {
+        if(busesCount < buses.length){
+            buses[busesCount] = bus;
+            return busesCount++;
+        }
+        return -1;
+    }
+
+    public int AddDoors(U paddle)
+    {
+        if(doorsCount < doors.length){
+            doors[doorsCount]=paddle;
+            return doorsCount++;
+        }
+        return -1;
+    }
+
+    public DrawingBus CreateBus() {
+        int idBus = new Random().nextInt(busesCount);
+        int idDoor = new Random().nextInt(doorsCount);
+        T selectedBus = (T)buses[idBus];
+        U selectedDoors = (U)doors[idDoor];
+        if (selectedBus instanceof EntityDDB) {
+            return new DrawingDDB(selectedBus, selectedDoors);
+        }
+        return new DrawingBus(selectedBus, selectedDoors);
+    }
+}

DoubleDeckerBus/src/main/java/com/example/doubledeckerbus/DrawingTriangleDoors.java

@@ -0,0 +1,37 @@
+package com.example.doubledeckerbus;
+
+import javafx.scene.canvas.GraphicsContext;
+import javafx.scene.paint.Color;
+
+public class DrawingTriangleDoors implements IDrawingDoors{
+    private CountOfDoors _countOfDoors;
+
+    public void FillTriangle(GraphicsContext gc, float x, float y) {
+        gc.fillPolygon(new double[] {(double) x, (double) (x + 5), (double) (x + 10)},
+                new double[] {(double) y + 20, (double) (y), (double) y + 20}, 3) ;
+    }
+
+    @Override
+    public void DrawDoors(GraphicsContext gc, float _startPosX, float _startPosY) {
+        gc.setFill(Color.BLUE);
+        FillTriangle(gc, _startPosX, _startPosY + 20);
+        FillTriangle(gc,_startPosX + 20, _startPosY + 20);
+        FillTriangle(gc,_startPosX + 40, _startPosY + 20);
+        if (_countOfDoors.getId() >= 4) {
+            FillTriangle(gc, _startPosX + 60, _startPosY + 20);
+        }
+        if (_countOfDoors.getId() >= 5) {
+            FillTriangle(gc, _startPosX + 80, _startPosY + 20);
+        }
+    }
+
+    @Override
+    public void setCountOfDoors(int count) {
+        for (CountOfDoors item: CountOfDoors.values()) {
+            if (item.getId() == count) {
+                _countOfDoors = item;
+                return;
+            }
+        }
+    }
+}

DoubleDeckerBus/src/main/java/com/example/doubledeckerbus/EntityBus.java

@@ -10,7 +10,7 @@ public class EntityBus {
     public Color BodyColor;
     public float Step;
 
-    public void Init(int speed, float weight, Color bodyColor)
+    public EntityBus(int speed, float weight, Color bodyColor)
     {
         Random rnd = new Random();
         Speed = (speed <= 0) ? rnd.nextInt(50, 150): speed;

DoubleDeckerBus/src/main/java/com/example/doubledeckerbus/EntityDDB.java

@@ -0,0 +1,33 @@
+package com.example.doubledeckerbus;
+
+import javafx.scene.paint.Color;
+
+public class EntityDDB extends EntityBus {
+    
+    public Color ExtraColor;
+    
+    public boolean Ladder;
+    
+    public boolean SecondStage;
+
+    
+    private void setExtraColor(Color extraColor) {
+        ExtraColor = extraColor; 
+    }
+
+    private void setLadder(boolean ladder) {
+        Ladder = ladder;
+    }
+
+    private void setSecondStage(boolean secondStage) {
+        SecondStage = secondStage;
+    }
+
+    public EntityDDB(int speed, float height, Color bodyColor, Color extraColor, boolean ladder, boolean secondStage)
+    {
+        super(speed, height, bodyColor);
+        ExtraColor = extraColor;
+        Ladder = ladder;
+        SecondStage = secondStage;
+    }
+}

DoubleDeckerBus/src/main/java/com/example/doubledeckerbus/Event.java

@@ -0,0 +1,17 @@
+package com.example.doubledeckerbus;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.function.Consumer;
+
+public class Event<T> {
+    private final Set<Consumer<T>> listeners = new HashSet<>();
+
+    public void AddListener(Consumer<T> listener) {
+        listeners.add(listener);
+    }
+
+    public void Broadcast(T args) {
+        listeners.forEach(x -> x.accept(args));
+    }
+}

DoubleDeckerBus/src/main/java/com/example/doubledeckerbus/ExtensionBus.java

@@ -0,0 +1,62 @@
+package com.example.doubledeckerbus;
+
+import javafx.scene.paint.Color;
+
+public class ExtensionBus {
+    private static char _separatorForObject = ':';
+
+    public static DrawingBus CreateDrawingBus(String info) {
+        String[] strs = info.split(String.valueOf(_separatorForObject));
+        if (strs.length == 5) {
+            return new DrawingBus(Integer.parseInt(strs[0]),
+                    Float.parseFloat(strs[1].replace(',', '.')), Color.web(strs[2]),
+                    Integer.parseInt(strs[3]), CreateDoors(strs[4]));
+        }
+        if (strs.length == 8) {
+            return new DrawingDDB(Integer.parseInt(strs[0]), Float.parseFloat(strs[1].replace(',', '.')),
+                    Color.web(strs[2]), Integer.parseInt(strs[3]), CreateDoors(strs[4]),
+                    Color.web(strs[5]),  Boolean.parseBoolean(strs[6]),
+                    Boolean.parseBoolean(strs[7]));
+        }
+        return null;
+    }
+
+    private static IDrawingDoors CreateDoors(String name) {
+        switch (name) {
+            case "Triangle" -> {
+                return new DrawingTriangleDoors();
+            }
+            case "Oval" -> {
+                return new DrawingEllipsoidDoors();
+            }
+            case "Rect" -> {
+                return new DrawingDoors();
+            }
+        }
+        return new DrawingDoors();
+    }
+
+    private static String CreateDoors(IDrawingDoors doors) {
+        if (doors instanceof DrawingEllipsoidDoors) {
+            return "Oval";
+        }
+        else if (doors instanceof DrawingTriangleDoors) {
+            return "Triangle";
+        }
+        else {
+            return "Rect";
+        }
+    }
+
+    public static String GetDataForSave(DrawingBus drawingBus)
+    {
+        var bus = drawingBus.Bus;
+        var str = String.format("%d:%f:%s:%d:%s", bus.Speed, bus.Weight, bus.BodyColor.toString(),
+                drawingBus._countOfDoors, CreateDoors(drawingBus.Doors));;
+        if (!(bus instanceof EntityDDB ddb))
+        {
+            return str;
+        }
+        return str + String.format(":%s:%b:%b", ddb.ExtraColor.toString(), ddb.Ladder, ddb.SecondStage);
+    }
+}

DoubleDeckerBus/src/main/java/com/example/doubledeckerbus/Form.java

@@ -7,14 +7,17 @@ import javafx.stage.Stage;
 
 import java.io.IOException;
 
-public class FormBus extends Application {
+public class Form extends Application {
+    static Stage myStage;
+
     @Override
     public void start(Stage stage) throws IOException {
-        FXMLLoader fxmlLoader = new FXMLLoader(FormBus.class.getResource("hello-view.fxml"));
+        FXMLLoader fxmlLoader = new FXMLLoader(Form.class.getResource("FormMapWithSetBus.fxml"));
         Scene scene = new Scene(fxmlLoader.load());
-        stage.setTitle("DoubleDeckerBus");
-        stage.setScene(scene);
-        stage.show();
+        myStage = stage;
+        myStage.setTitle("DoubleDeckerBus");
+        myStage.setScene(scene);
+        myStage.show();
     }
 
     public static void main(String[] args) {

DoubleDeckerBus/src/main/java/com/example/doubledeckerbus/IDrawingDoors.java

@@ -0,0 +1,9 @@
+package com.example.doubledeckerbus;
+
+import javafx.scene.canvas.GraphicsContext;
+import javafx.scene.paint.Color;
+
+public interface IDrawingDoors {
+    void DrawDoors(GraphicsContext gc, float _startPosX, float _startPosY);
+    void setCountOfDoors(int count);
+}

DoubleDeckerBus/src/main/java/com/example/doubledeckerbus/IDrawingObject.java

@@ -0,0 +1,17 @@
+package com.example.doubledeckerbus;
+
+import javafx.scene.canvas.GraphicsContext;
+
+public interface IDrawingObject {
+    float Step = -1;
+
+    void SetObject(int x, int y, int width, int height);
+
+    void MoveObject(Direction direction);
+
+    void DrawingObject(GraphicsContext g);
+
+    Position GetCurrentPosition();
+
+    String GetInfo();
+}

DoubleDeckerBus/src/main/java/com/example/doubledeckerbus/MapWithSetBusesGeneric.java

@@ -0,0 +1,205 @@
+package com.example.doubledeckerbus;
+
+import javafx.scene.canvas.GraphicsContext;
+import javafx.scene.paint.Color;
+
+import java.util.Comparator;
+import java.util.Stack;
+
+public class MapWithSetBusesGeneric<T extends IDrawingObject , U extends AbstractMap> implements Comparable<MapWithSetBusesGeneric>{
+    private final int _pictureWidth;
+    private final int _pictureHeight;
+    private final int _placeSizeWidth = 210;
+    private final int _placeSizeHeight = 90;
+    private final SetBusesGeneric<T> _setBuses;
+    private final Stack<T> _deletedBuses;
+    private U _map;
+
+    public MapWithSetBusesGeneric(int picWidth, int picHeight, U map)
+    {
+        int width = picWidth / _placeSizeWidth;
+        int height = picHeight / _placeSizeHeight;
+        _setBuses = new SetBusesGeneric<T>(width * height);
+        _pictureWidth = picWidth;
+        _pictureHeight = picHeight;
+        _map = map;
+        _deletedBuses = new Stack<>();
+    }
+
+    public void changeMap(U map) {
+        _map = map;
+    }
+
+    public int add(T bus) throws StorageOverflowException {
+        return _setBuses.Insert(bus);
+    }
+
+    public T remove(int position) throws BusNotFoundException {
+        T deletedBus = _setBuses.Remove(position);
+        _deletedBuses.push(deletedBus);
+        return deletedBus;
+    }
+
+    public T getDeletedBus(){
+        if(_deletedBuses.empty())
+            return null;
+        return _deletedBuses.pop();
+    }
+
+    public void ShowSet(GraphicsContext gc)
+    {
+        DrawBackground(gc);
+        DrawBuses(gc);
+    }
+
+    public void ShowOnMap(GraphicsContext gc) throws StorageOverflowException, BusNotFoundException {
+        Shaking();
+        for (var bus: _setBuses.GetBuses())
+        {
+            if (bus != null)
+            {
+                _map.CreateMap(_pictureWidth, _pictureHeight, bus, gc);
+            }
+        }
+
+    }
+
+    public void MoveObject(Direction direction)
+    {
+        if (_map != null)
+        {
+            _map.MoveObject(direction);
+        }
+    }
+
+    private void Shaking() throws StorageOverflowException, BusNotFoundException {
+        int j = _setBuses.Count() - 1;
+        for (int i = 0; i < _setBuses.Count(); i++)
+        {
+            if (_setBuses.Get(i) == null)
+            {
+                for (; j > i; j--)
+                {
+                    var bus = _setBuses.Get(j);
+                    if (bus != null)
+                    {
+                        _setBuses.Insert(bus, i);
+                        _setBuses.Remove(j);
+                        break;
+                    }
+                }
+                if (j <= i)
+                {
+                    return;
+                }
+            }
+        }
+    }
+
+    private void DrawBackground(GraphicsContext gc)
+    {
+        gc.setFill(Color.BLACK);
+        for (int i = 0; i < _pictureWidth / _placeSizeWidth; i++)
+        {
+            for (int j = 0; j < _pictureHeight / _placeSizeHeight + 1; ++j)
+            {//линия рамзетки места
+                gc.strokeLine(i * _placeSizeWidth, j * _placeSizeHeight,
+                        i * _placeSizeWidth + _placeSizeWidth / 2, j * _placeSizeHeight);
+            }
+            gc.strokeLine(i * _placeSizeWidth, 0, i * _placeSizeWidth, (_pictureHeight / _placeSizeHeight) * _placeSizeHeight);
+        }
+    }
+
+    private void DrawBuses(GraphicsContext gc) {
+        int width = _pictureWidth / _placeSizeWidth;
+        int height = _pictureHeight / _placeSizeHeight;
+
+        int currentWidth = width - 1;
+        int currentHeight = 0;
+
+        for (var bus: _setBuses.GetBuses()) {
+            if (bus == null){
+                continue;
+            }
+
+            bus.SetObject(currentWidth * _placeSizeWidth,
+                    currentHeight * _placeSizeHeight,
+                    _pictureWidth, _pictureHeight);
+            bus.DrawingObject(gc);
+
+            if (currentWidth > 0)
+                currentWidth--;
+            else {
+                currentWidth = width - 1;
+                currentHeight++;
+            }
+            if (currentHeight > height) return;
+        }
+    }
+
+    public int getCount() {
+        return _setBuses.Count();
+    }
+
+    public T getBus(int ind) throws BusNotFoundException {
+        return _setBuses.Get(ind);
+    }
+
+    public String GetData(char separatorType, char separatorData)
+    {
+        StringBuilder data = new StringBuilder(String.format("%s%c", _map.getClass().getSimpleName(), separatorType));
+        for (T bus : _setBuses.GetBuses())
+        {
+            data.append(String.format("%s%c", bus.GetInfo(), separatorData));
+        }
+        return data.toString();
+    }
+
+    @SuppressWarnings("unchecked")
+    public void LoadData(String[] data) throws StorageOverflowException {
+        for (String items : data)
+        {
+            _setBuses.Insert((T)(DrawingObjectBus.Create(items)));
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    public void LoadData(String data) throws StorageOverflowException {
+        _setBuses.Insert((T)(DrawingObjectBus.Create(data)));
+    }
+
+    public void Clear() {
+        _setBuses.Clear();
+    }
+
+    @Override
+    public int compareTo(MapWithSetBusesGeneric o) {
+        if (o == null)
+        {
+            return 1;
+        }
+        if (this == o)
+        {
+            return 0;
+        }
+        var pictureWidthCompare = Integer.compare(_pictureWidth, o._pictureWidth);
+        if (pictureWidthCompare != 0)
+        {
+            return pictureWidthCompare;
+        }
+        var pictureHeightCompare = Integer.compare(_pictureHeight, o._pictureHeight);
+        if (pictureHeightCompare != 0)
+        {
+            return pictureHeightCompare;
+        }
+        Integer setCount = _setBuses.Count();
+        Integer otherSetCount= o._setBuses.Count();
+        return setCount.compareTo(otherSetCount);
+    }
+
+    public void Sort(Comparator<T> comparator)
+    {
+        _setBuses.Sort(comparator);
+    }
+}
+

DoubleDeckerBus/src/main/java/com/example/doubledeckerbus/MapsCollection.java

@@ -0,0 +1,178 @@
+package com.example.doubledeckerbus;
+
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+
+import java.io.*;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.*;
+
+
+public class MapsCollection {
+    HashMap<String, MapWithSetBusesGeneric<IDrawingObject, AbstractMap>> _mapStorages;
+    private final char separatorDict = '|';
+    private final char separatorData = ';';
+
+    public List<String> Keys() {
+        return _mapStorages.keySet().stream().toList();
+    }
+
+    private int _pictureWidth;
+
+    private int _pictureHeight;
+
+    public MapsCollection(int pictureWidth, int pictureHeight)
+    {
+        _mapStorages = new HashMap<>();
+        _pictureWidth = pictureWidth;
+        _pictureHeight = pictureHeight;
+    }
+
+    public void AddMap(String name, AbstractMap map)
+    {
+        if (Keys().contains(name)) return;
+        _mapStorages.put(name, new MapWithSetBusesGeneric<IDrawingObject, AbstractMap>(_pictureWidth, _pictureHeight, map));
+    }
+
+    public void DelMap(String name)
+    {
+        _mapStorages.remove(name);
+    }
+
+    public MapWithSetBusesGeneric<IDrawingObject, AbstractMap> GetId(String id)
+    {
+        return _mapStorages.get(id);
+    }
+
+    public ObservableList<String> toObserveList() {
+        ObservableList<String> result = FXCollections.observableArrayList();
+        result.addAll(_mapStorages.keySet());
+        return result;
+    }
+
+    public MapWithSetBusesGeneric<IDrawingObject, AbstractMap> get(String id) {
+        if (_mapStorages.containsKey(id))
+        {
+            return _mapStorages.get(id);
+        }
+        return null;
+    }
+
+    public IDrawingObject get(String name, int id) throws BusNotFoundException {
+        if (_mapStorages.containsKey(name))
+        {
+            return _mapStorages.get(name).getBus(id);
+        }
+        return null;
+    }
+
+    public boolean SaveData(String filename) throws IOException
+    {
+        Files.deleteIfExists(Paths.get(filename));
+
+        try (Writer writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(filename),
+                StandardCharsets.UTF_8)))
+        {
+            writer.write("MapsCollection" + System.lineSeparator());
+            for (String storageKey : _mapStorages.keySet())
+            {
+                MapWithSetBusesGeneric<IDrawingObject, AbstractMap> storage = _mapStorages.get(storageKey);
+                writer.write(String.format("%s|%s\n", storageKey, storage.GetData(separatorDict, separatorData)));
+            }
+        }
+        return true;
+    }
+
+    static String[] reverse(String myArray[])
+    {
+        Collections.reverse(Arrays.asList(myArray));
+        return (String[]) Arrays.stream(myArray).toArray();
+    }
+
+
+    public boolean SaveStorage(String filename, String key) throws IOException
+    {
+        Files.deleteIfExists(Paths.get(filename));
+
+        try (Writer writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(filename),
+                StandardCharsets.UTF_8)))
+        {
+            writer.write("MapsCollectionStorage" + System.lineSeparator());
+            MapWithSetBusesGeneric<IDrawingObject, AbstractMap> storage = _mapStorages.get(key);
+            if (storage == null) {
+                return false;
+            }
+            String[] data = storage.GetData(separatorDict, separatorData).split("\\|");
+
+            writer.write(key + ":" + data[0] + System.lineSeparator());
+            var buses = data[1].split(";");
+            for (int i = buses.length - 1; i >= 0; i--) {
+                writer.write(buses[i]);
+                writer.write(System.lineSeparator());
+            }
+
+        }
+        return true;
+    }
+
+    public boolean LoadData(String filename) throws IOException
+    {
+        File file = new File(filename);
+        if(!file.exists() || file.isDirectory())
+        {
+            return false;
+        }
+
+        try (BufferedReader reader = new BufferedReader(new FileReader(filename)))
+        {
+            String str = reader.readLine();
+            if (str == null || (!str.contains("MapsCollection") && !str.contains("MapsCollectionStorage")))
+            {
+                return false;
+            }
+            if (str.contains("MapsCollectionStorage")) {
+                String[] data = reader.readLine().split(":");
+
+                AbstractMap map = switch (data[1]) {
+                    case "SimpleMap" -> new SimpleMap();
+                    case "WaterMap" -> new WaterMap();
+                    default -> null;
+                };
+                if (_mapStorages.containsKey(data[0])) {
+                    _mapStorages.get(data[0]).Clear();
+                }
+                else {
+                    _mapStorages.put(data[0], new MapWithSetBusesGeneric<>(_pictureWidth, _pictureHeight, map));
+                }
+                String k = reader.readLine();
+                while (k != null) {
+                    _mapStorages.get(data[0]).LoadData(k);
+                    k = reader.readLine();
+                }
+            }
+            else {
+
+                while ((str = reader.readLine()) != null) {
+                    String[] elem = str.split(String.format("\\%c", separatorDict));
+                    AbstractMap map = switch (elem[1]) {
+                        case "SimpleMap" -> new SimpleMap();
+                        case "WaterMap" -> new WaterMap();
+                        default -> null;
+                    };
+                    _mapStorages.put(elem[0], new MapWithSetBusesGeneric<>(_pictureWidth, _pictureHeight, map));
+                    if (elem.length == 3) {
+
+                        _mapStorages.get(elem[0]).LoadData(elem[2].split(String.format("%c", separatorData)));
+                    }
+                }
+
+            }
+        } catch (StorageOverflowException e) {
+            throw new RuntimeException(e);
+        }
+        return true;
+    }
+
+}

DoubleDeckerBus/src/main/java/com/example/doubledeckerbus/Position.java

@@ -0,0 +1,15 @@
+package com.example.doubledeckerbus;
+
+public class Position {
+    public float Left;
+    public float Right;
+    public float Top;
+    public float Bottom;
+
+    public Position (float left, float right, float top, float bottom) {
+        Left = left;
+        Right = right;
+        Top = top;
+        Bottom = bottom;
+    }
+}

DoubleDeckerBus/src/main/java/com/example/doubledeckerbus/SerializableColor.java

@@ -0,0 +1,26 @@
+package com.example.doubledeckerbus;
+
+import java.io.Serializable;
+import javafx.scene.paint.Color;
+
+public class SerializableColor implements Serializable
+{
+    private final double red;
+    private final double green;
+    private final double blue;
+    private final double alpha;
+
+    public SerializableColor(Color color)
+    {
+        red = color.getRed();
+        green = color.getGreen();
+        blue = color.getBlue();
+        alpha = color.getOpacity();
+    }
+
+    public Color getFXColor()
+    {
+        return new Color(red, green, blue, alpha);
+    }
+}
+

DoubleDeckerBus/src/main/java/com/example/doubledeckerbus/SetBusesGeneric.java

@@ -0,0 +1,83 @@
+package com.example.doubledeckerbus;
+
+import java.util.*;
+
+
+class SetBusesGeneric<T> {
+    private ArrayList<T> _places;
+    private int BusyPlaces = 0;
+
+    private int _maxCount;
+
+    public SetBusesGeneric(int count) {
+        _maxCount = count;
+        _places = new ArrayList<>();
+    }
+
+    public int Insert(T bus) throws StorageOverflowException {
+        return Insert(bus, 0);
+    }
+
+    public int Insert(T bus, int position) throws StorageOverflowException {
+        if (_places.contains(bus))
+        {
+            throw new IllegalArgumentException("The same bus exist");
+        }
+        if (_places.size() == _maxCount)
+        {
+            throw new StorageOverflowException(_places.size());
+        }
+
+        if (position < 0 || position >= _maxCount || BusyPlaces == _maxCount) return -1;
+
+        BusyPlaces++;
+        _places.add(position, bus);
+        return position;
+    }
+
+    public T Remove(int position) throws BusNotFoundException {
+
+        if (position < 0 || position >= _maxCount)
+            throw new BusNotFoundException();
+        T savedBus = _places.get(position - 1);
+        if (savedBus == null) {
+            throw new BusNotFoundException();
+        }
+        _places.set(position - 1, null);
+        return savedBus;
+    }
+
+    public T Get(int position) throws BusNotFoundException {
+        if (position < 0 || position >= _maxCount)
+            throw new BusNotFoundException();
+        return _places.get(position);
+    }
+
+
+    public ArrayList<T> GetBuses() {
+        ArrayList<T> result = new ArrayList<>();
+        for (var bus: _places) {
+            if (bus != null){
+                result.add(bus);
+            }
+        }
+        return result;
+    }
+
+    public int Count() {
+        return _places.size();
+    }
+
+    public void Clear() {
+        _places.clear();
+    }
+
+    public void Sort(Comparator<T> comparator) {
+        if (comparator == null) {
+            return;
+        }
+        _places.sort(comparator);
+    }
+}
+
+

DoubleDeckerBus/src/main/java/com/example/doubledeckerbus/SimpleMap.java

@@ -0,0 +1,44 @@
+package com.example.doubledeckerbus;
+
+import javafx.scene.paint.Color;
+
+public class SimpleMap extends AbstractMap{
+    @Override
+    protected void GenerateMap() {
+        _map = new int[100][100];
+        _size_x = (float)_width / _map.length;
+        _size_y = (float)_height / _map[0].length;
+
+        for (int i = 0; i < _map.length; ++i)
+        {
+            for (int j = 0; j < _map[0].length; ++j)
+            {
+                _map[i][j] = _freeRoad;
+            }
+        }
+
+        int counter = 0;
+        while (counter < 20)
+        {
+            int x = _random.nextInt(0, 100);
+            int y = _random.nextInt(0, 100);
+            if (_map[x][y] == _freeRoad)
+            {
+                _map[x][y] = _barrier;
+                counter++;
+            }
+        }
+    }
+
+    @Override
+    protected void DrawRoadPart(int i, int j) {
+        gc.setFill(Color.GRAY);
+        gc.fillRect(i * _size_x, j * _size_y, i * (_size_x + 1), j * (_size_y + 1));
+    }
+
+    @Override
+    protected void DrawBarrierPart(int i, int j) {
+        gc.setFill(Color.BLACK);
+        gc.fillRect(i * _size_x, j * _size_y, i * (_size_x + 1), j * (_size_y + 1));
+    }
+}

DoubleDeckerBus/src/main/java/com/example/doubledeckerbus/StorageOverflowException.java

@@ -0,0 +1,25 @@
+package com.example.doubledeckerbus;
+
+public class StorageOverflowException extends Exception
+{
+    public StorageOverflowException(int count)
+    {
+        super("The set exceeded the allowed number of elements: " + count);
+    }
+    public StorageOverflowException()
+    {
+        super();
+    }
+    public StorageOverflowException(String message)
+    {
+        super(message);
+    }
+    public StorageOverflowException(String message, Throwable cause)
+    {
+        super(message, cause);
+    }
+    public StorageOverflowException(Throwable cause)
+    {
+        super(cause);
+    }
+}

DoubleDeckerBus/src/main/java/com/example/doubledeckerbus/WaterMap.java

@@ -0,0 +1,49 @@
+package com.example.doubledeckerbus;
+
+import javafx.scene.paint.Color;
+
+public class WaterMap extends AbstractMap{
+    @Override
+    protected void GenerateMap() {
+        _map = new int[100][100];
+        _size_x = (float)_width / _map.length;
+        _size_y = (float)_height / _map[0].length;
+
+        for (int i = 0; i < _map.length; ++i)
+        {
+            for (int j = 0; j < _map[0].length; ++j)
+            {
+                _map[i][j] = _freeRoad;
+            }
+        }
+
+        int counter = 0;
+        while (counter < 50)
+        {
+            int x = _random.nextInt(0, 100);
+            int y = _random.nextInt(0, 100);
+            if (_map[x][y] == _freeRoad)
+            {
+                _map[x][y] = _barrier;
+                counter++;
+            }
+        }
+    }
+
+    @Override
+    protected void DrawRoadPart(int i, int j) {
+        if (_random.nextInt(0,20) == 9) {
+            gc.setFill(Color.GREEN);
+        }
+        else {
+            gc.setFill(Color.LIGHTGREEN);
+        }
+        gc.fillRect(i * _size_x, j * _size_y, i * (_size_x + 1), j * (_size_y + 1));
+    }
+
+    @Override
+    protected void DrawBarrierPart(int i, int j) {
+        gc.setFill(Color.BLUE);
+        gc.fillRect(i * _size_x, j * _size_y, i * (_size_x + 1), j * (_size_y + 1));
+    }
+}

DoubleDeckerBus/src/main/java/module-info.java

@@ -4,6 +4,9 @@ module com.example.doubledeckerbus {
 
     requires org.controlsfx.controls;
     requires org.kordamp.bootstrapfx.core;
+    requires javafx.graphics;
+    requires org.apache.logging.log4j;
+    requires org.apache.log4j;
 
     opens com.example.doubledeckerbus to javafx.fxml;
     exports com.example.doubledeckerbus;

DoubleDeckerBus/src/main/resources/com/example/doubledeckerbus/FormBus.fxml

@@ -4,6 +4,7 @@
 <?import javafx.scene.canvas.Canvas?>
 <?import javafx.scene.control.Button?>
 <?import javafx.scene.control.ChoiceBox?>
+<?import javafx.scene.control.ColorPicker?>
 <?import javafx.scene.control.Label?>
 <?import javafx.scene.image.Image?>
 <?import javafx.scene.image.ImageView?>
@@ -27,13 +28,15 @@
                 <Label fx:id="statusSpeed" text="Скорость:" />
                 <Label fx:id="statusWeight" text="Вес:" />
                 <Label fx:id="statusColor" text="Цвет:" />
-            <Label text="Колл-во дверей:" />
-            <ChoiceBox fx:id="choiceDoors" prefHeight="24.0" prefWidth="58.0" />
+            <ColorPicker fx:id="bodyColorPicker" />
+            <ColorPicker fx:id="extraColorPicker" />
+                <Label text="Колл-во дверей:" />
+                <ChoiceBox fx:id="choiceDoors" prefHeight="24.0" prefWidth="58.0" />
             </children>
         </HBox>
         <AnchorPane fx:id="pictureBoxBus" maxHeight="2000000.0" maxWidth="2000000.0" minHeight="0.0" minWidth="0.0" prefHeight="603.0" prefWidth="1020.0">
             <children>
-                <Canvas fx:id="canvasBus" layoutY="38.0" AnchorPane.leftAnchor="0.0" AnchorPane.topAnchor="0.0" />
+                <Canvas fx:id="canvasBus" height="603.0" layoutY="38.0" width="1021.0" AnchorPane.leftAnchor="0.0" AnchorPane.topAnchor="0.0" />
                 <Button fx:id="buttonLeft" layoutX="975.0" layoutY="427.0" mnemonicParsing="false" onAction="#ButtonMove_Click" prefHeight="0.0" prefWidth="0.0" AnchorPane.bottomAnchor="40.0" AnchorPane.rightAnchor="60.0">
                     <graphic>
                         <ImageView fitHeight="27.0" fitWidth="10.0" pickOnBounds="true" preserveRatio="true">
@@ -66,7 +69,9 @@
                             </image>
                         </ImageView>
                     </graphic></Button>
-                <Button fx:id="buttonCreate" layoutY="455.0" mnemonicParsing="false" onAction="#ButtonCreate_Click" text="Создать" AnchorPane.bottomAnchor="14.0" AnchorPane.leftAnchor="0.0" />
+                <Button fx:id="buttonCreate" layoutX="6.0" layoutY="565.0" mnemonicParsing="false" onAction="#ButtonCreate_Click" text="Создать" AnchorPane.bottomAnchor="14.0" AnchorPane.leftAnchor="6.0" />
+                <Button fx:id="buttonCreateExtra" layoutX="90.0" layoutY="565.0" mnemonicParsing="false" onAction="#ButtonCreateExtra_Click" text="Продвинутый объект" AnchorPane.bottomAnchor="14.0" AnchorPane.leftAnchor="90.0" />
+            <Button fx:id="buttonSelectBus" layoutX="840.0" layoutY="565.0" mnemonicParsing="false" onAction="#ButtonSelectBus_Click" text="Выбрать" AnchorPane.bottomAnchor="14.0" AnchorPane.rightAnchor="104.0" />
             </children>
         </AnchorPane>
     </children>

DoubleDeckerBus/src/main/resources/com/example/doubledeckerbus/FormBusConfig.fxml

@@ -0,0 +1,76 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import javafx.scene.canvas.Canvas?>
+<?import javafx.scene.control.Button?>
+<?import javafx.scene.control.CheckBox?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.control.Spinner?>
+<?import javafx.scene.control.SpinnerValueFactory.IntegerSpinnerValueFactory?>
+<?import javafx.scene.layout.Pane?>
+<?import javafx.scene.layout.Region?>
+<?import javafx.scene.layout.StackPane?>
+
+<Pane fx:id="root" prefHeight="395.0" prefWidth="642.0" xmlns="http://javafx.com/javafx/18" xmlns:fx="http://javafx.com/fxml/1" fx:controller="com.example.doubledeckerbus.ControllerBusConfig">
+    <Pane layoutX="5.0" layoutY="5.0" prefHeight="379.0" prefWidth="307">
+        <Label layoutX="18.0" layoutY="18.0" text="Скорость">
+            Speed:
+        </Label>
+        <Label layoutX="181.0" layoutY="18.0" text="Вес:">
+            Weight:
+        </Label>
+        <Spinner fx:id="spinnerSpeed" layoutX="90.0" layoutY="14.0" prefWidth="70">
+            <valueFactory>
+                <SpinnerValueFactory.IntegerSpinnerValueFactory initialValue="100" max="300" min="100" />
+            </valueFactory>
+        </Spinner>
+        <Spinner fx:id="spinnerWeight" layoutX="222.0" layoutY="14.0" prefWidth="70">
+            <valueFactory>
+                <SpinnerValueFactory.IntegerSpinnerValueFactory initialValue="100" max="2000" min="1000" />
+            </valueFactory>
+        </Spinner>
+        <Pane layoutX="12.0" layoutY="131.0" prefHeight="126.0" prefWidth="280.0">
+            <Region layoutX="25.0" layoutY="9.0" onDragDetected="#RegionColor_OnDragDetected" prefHeight="46.0" prefWidth="46.0" style="-fx-background-color: orangered;" />
+            <Region layoutX="79.0" layoutY="9.0" onDragDetected="#RegionColor_OnDragDetected" prefHeight="46.0" prefWidth="46.0" style="-fx-background-color: yellowgreen;" />
+            <Region layoutX="140.0" layoutY="9.0" onDragDetected="#RegionColor_OnDragDetected" prefHeight="46.0" prefWidth="46.0" style="-fx-background-color: cornflowerblue;" />
+            <Region layoutX="197.0" layoutY="9.0" onDragDetected="#RegionColor_OnDragDetected" prefHeight="46.0" prefWidth="46.0" style="-fx-background-color: yellow;" />
+            <Region layoutX="25.0" layoutY="66.0" onDragDetected="#RegionColor_OnDragDetected" prefHeight="46.0" prefWidth="46.0" style="-fx-background-color: white;" />
+            <Region layoutX="79.0" layoutY="66.0" onDragDetected="#RegionColor_OnDragDetected" prefHeight="46.0" prefWidth="46.0" style="-fx-background-color: gray;" />
+            <Region layoutX="140.0" layoutY="66.0" onDragDetected="#RegionColor_OnDragDetected" prefHeight="46.0" prefWidth="46.0" style="-fx-background-color: black;" />
+            <Region layoutX="197.0" layoutY="66.0" onDragDetected="#RegionColor_OnDragDetected" prefHeight="46.0" prefWidth="46.0" style="-fx-background-color: purple;" />
+        </Pane>
+        <CheckBox fx:id="checkBoxLadder" layoutX="188.0" layoutY="110.0" text="Второй этаж" />
+        <CheckBox fx:id="checkBoxSecondStage" layoutX="8" layoutY="110" prefHeight="18.0" prefWidth="135.0" text="Лестница" />
+        <Label fx:id="labelSimpleObject" alignment="CENTER" layoutX="14.0" layoutY="282.0" onDragDetected="#LabelObject_OnDragDetected" prefHeight="30" prefWidth="127.0" style="-fx-border-color: black;" textOverrun="CLIP">
+            Simple
+        </Label>
+        <Label fx:id="labelModifiedObject" alignment="CENTER" layoutX="165.0" layoutY="282.0" onDragDetected="#LabelObject_OnDragDetected" prefHeight="30" prefWidth="135.0" style="-fx-border-color: black;">
+            Modified
+        </Label>
+         <Label layoutX="101.0" layoutY="56.0" text="Двери">
+                Track rollers
+            </Label>
+         <Spinner fx:id="spinnerDoors" layoutX="150.0" layoutY="52.0" prefWidth="70">
+             <valueFactory>
+                 <SpinnerValueFactory.IntegerSpinnerValueFactory initialValue="1" max="5" min="3" />
+             </valueFactory>
+         </Spinner>
+      <Label fx:id="labelTriangle" alignment="CENTER" layoutX="14.0" layoutY="331.0" onDragDetected="#LabelObject_OnDragDetected" prefHeight="30" prefWidth="97.0" style="-fx-border-color: black;" text="Треугольник" textOverrun="CLIP" />
+      <Label fx:id="labelOval" alignment="CENTER" layoutX="128.0" layoutY="331.0" onDragDetected="#LabelObject_OnDragDetected" prefHeight="30" prefWidth="52.0" style="-fx-border-color: black;" text="Овал" textOverrun="CLIP" />
+      <Label fx:id="labelRect" alignment="CENTER" layoutX="199.0" layoutY="331.0" onDragDetected="#LabelObject_OnDragDetected" prefHeight="30" prefWidth="90.0" style="-fx-border-color: black;" text="Квадрат" textOverrun="CLIP" />
+    </Pane>
+    <Label alignment="CENTER" layoutX="356.0" layoutY="52.0" onDragDropped="#LabelBaseColor_OnDragDropped" onDragOver="#LabelColor_OnDragOver" prefHeight="30" prefWidth="127.0" style="-fx-border-color: black;" text="Цвет">
+        Color
+    </Label>
+    <Label alignment="CENTER" layoutX="499.0" layoutY="52.0" onDragDropped="#LabelDopColor_OnDragDropped" onDragOver="#LabelColor_OnDragOver" prefHeight="30" prefWidth="119.0" style="-fx-border-color: black;" text="Доп цвет">
+        Dop Color
+    </Label>
+    <StackPane layoutX="352.0" layoutY="137.0" onDragDropped="#CanvasObject_OnDragDropped" onDragOver="#CanvasObject_OnDragOver" prefHeight="152.0" prefWidth="262.0" style="-fx-border-color: #b8becc; -fx-border-radius: 5; -fx-border-width: 2;">
+        <Canvas fx:id="canvasObject" height="152.0" width="267.0" />
+    </StackPane>
+    <Button fx:id="buttonAdd" layoutX="367.0" layoutY="350.0" onAction="#ButtonOk_Click" prefHeight="26" prefWidth="90" text="Создать">
+        Add
+    </Button>
+    <Button fx:id="buttonCancel" layoutX="522.0" layoutY="350.0" prefHeight="26" prefWidth="90" text="Отмена">
+        Cancel
+    </Button>
+</Pane>

DoubleDeckerBus/src/main/resources/com/example/doubledeckerbus/FormMapWithSetBus.fxml

@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import javafx.scene.Group?>
+<?import javafx.scene.canvas.Canvas?>
+<?import javafx.scene.control.Button?>
+<?import javafx.scene.control.ChoiceBox?>
+<?import javafx.scene.control.ListView?>
+<?import javafx.scene.control.TextField?>
+<?import javafx.scene.control.TitledPane?>
+<?import javafx.scene.image.Image?>
+<?import javafx.scene.image.ImageView?>
+<?import javafx.scene.layout.AnchorPane?>
+<?import javafx.scene.layout.ColumnConstraints?>
+<?import javafx.scene.layout.GridPane?>
+<?import javafx.scene.layout.RowConstraints?>
+
+<GridPane maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="848.0" prefWidth="930.0" xmlns="http://javafx.com/javafx/18" xmlns:fx="http://javafx.com/fxml/1" fx:controller="com.example.doubledeckerbus.ControllerMapWithSetBus">
+  <columnConstraints>
+    <ColumnConstraints hgrow="ALWAYS" maxWidth="463.0" minWidth="10.0" percentWidth="70.0" prefWidth="423.0" />
+    <ColumnConstraints hgrow="NEVER" maxWidth="294.0" minWidth="10.0" percentWidth="30.0" prefWidth="177.0" />
+  </columnConstraints>
+  <rowConstraints>
+    <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
+  </rowConstraints>
+   <children>
+      <AnchorPane fx:id="pictureBoxBus" prefHeight="9.9999999E7" prefWidth="9.9999999E7">
+         <children>
+            <Canvas fx:id="canvasBus" height="745.0" width="573.0" />
+            <TitledPane text="Сохранение">
+              <content>
+                <AnchorPane minHeight="0.0" minWidth="0.0" prefHeight="180.0" prefWidth="200.0">
+                     <children>
+                        <Button fx:id="ButtonSave" layoutX="-1.0" mnemonicParsing="false" onAction="#ButtonSave_Click" prefHeight="50.0" prefWidth="202.0" text="Сохранить" />
+                        <Button fx:id="ButtonLoad" layoutX="-1.0" layoutY="50.0" mnemonicParsing="false" onAction="#ButtonLoad_Click" prefHeight="50.0" prefWidth="202.0" text="Загрузить" />
+                        <Button fx:id="ButtonLoad1" layoutX="-1.0" layoutY="100.0" mnemonicParsing="false" onAction="#ButtonSaveStorage_Click" prefHeight="50.0" prefWidth="202.0" text="Сохранить хранилище" />
+                     </children>
+                  </AnchorPane>
+              </content>
+            </TitledPane>
+         </children>
+      </AnchorPane>
+      <Group GridPane.columnIndex="1" />
+      <GridPane GridPane.columnIndex="1">
+        <columnConstraints>
+          <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" percentWidth="100.0" prefWidth="100.0" />
+        </columnConstraints>
+        <rowConstraints>
+          <RowConstraints maxHeight="120.0" minHeight="0.0" prefHeight="34.0" vgrow="SOMETIMES" />
+            <RowConstraints maxHeight="200.0" minHeight="10.0" prefHeight="24.0" vgrow="SOMETIMES" />
+            <RowConstraints maxHeight="200.0" minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
+            <RowConstraints maxHeight="200.0" minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
+          <RowConstraints maxHeight="200.0" minHeight="8.0" prefHeight="27.0" vgrow="SOMETIMES" />
+            <RowConstraints maxHeight="269.0" minHeight="10.0" prefHeight="65.0" vgrow="SOMETIMES" />
+            <RowConstraints maxHeight="250.0" minHeight="0.0" prefHeight="44.0" vgrow="SOMETIMES" />
+            <RowConstraints maxHeight="250.0" minHeight="10.0" prefHeight="44.0" vgrow="SOMETIMES" />
+            <RowConstraints maxHeight="250.0" minHeight="10.0" prefHeight="44.0" vgrow="SOMETIMES" />
+            <RowConstraints maxHeight="272.0" minHeight="10.0" prefHeight="34.0" vgrow="SOMETIMES" />
+          <RowConstraints maxHeight="272.0" minHeight="10.0" prefHeight="34.0" vgrow="SOMETIMES" />
+            <RowConstraints maxHeight="272.0" minHeight="0.0" prefHeight="46.0" vgrow="SOMETIMES" />
+            <RowConstraints maxHeight="272.0" minHeight="0.0" prefHeight="46.0" vgrow="SOMETIMES" />
+            <RowConstraints maxHeight="272.0" minHeight="10.0" prefHeight="134.0" vgrow="SOMETIMES" />
+        </rowConstraints>
+         <children>
+            <ChoiceBox fx:id="comboBoxSelectorMap" prefHeight="50.0" prefWidth="9.9999999E7" GridPane.rowIndex="1" />
+            <Button fx:id="buttonAddBus" mnemonicParsing="false" onAction="#ButtonAddBus_Click" prefHeight="50.0" prefWidth="9.999999999E9" text="Добавить автобус" GridPane.rowIndex="5" />
+            <TextField fx:id="textBoxPosition" GridPane.rowIndex="6" />
+            <Button fx:id="buttonRemoveCar" mnemonicParsing="false" onAction="#ButtonRemoveBus_Click" prefHeight="63.0" prefWidth="9.999999999E9" text="Удалить автобус" GridPane.rowIndex="9" />
+            <Button fx:id="buttonShowMap" mnemonicParsing="false" onAction="#ButtonShowOnMap_Click" prefHeight="63.0" prefWidth="9.99999999999E11" text="Посмотреть карту" GridPane.rowIndex="12" />
+            <AnchorPane prefHeight="230.0" prefWidth="377.0" GridPane.rowIndex="13">
+               <children>
+                  <Button fx:id="buttonLeft" layoutX="38.0" layoutY="52.0" maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" mnemonicParsing="false" onAction="#ButtonMove_Click" prefHeight="30.0" prefWidth="30.0" AnchorPane.bottomAnchor="52.0" AnchorPane.rightAnchor="111.0">
+                     <graphic>
+                        <ImageView fitHeight="27.0" fitWidth="10.0" pickOnBounds="true" preserveRatio="true">
+                           <image>
+                              <Image url="@images/LeftArrow.png" />
+                           </image>
+                        </ImageView>
+                     </graphic>
+                  </Button>
+                  <Button fx:id="buttonDown" layoutX="68.0" layoutY="82.0" maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" mnemonicParsing="false" onAction="#ButtonMove_Click" prefHeight="30.0" prefWidth="30.0" AnchorPane.bottomAnchor="22.0" AnchorPane.rightAnchor="81.0">
+                     <graphic>
+                        <ImageView fitHeight="27.0" fitWidth="10.0" pickOnBounds="true" preserveRatio="true">
+                           <image>
+                              <Image url="@images/DownArrow.png" />
+                           </image>
+                        </ImageView>
+                     </graphic>
+                  </Button>
+                  <Button fx:id="buttonRight" layoutX="98.0" layoutY="52.0" maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" mnemonicParsing="false" onAction="#ButtonMove_Click" prefHeight="30.0" prefWidth="30.0" AnchorPane.bottomAnchor="52.0" AnchorPane.rightAnchor="51.0">
+                     <graphic>
+                        <ImageView fitHeight="27.0" fitWidth="10.0" pickOnBounds="true" preserveRatio="true">
+                           <image>
+                              <Image url="@images/RightArrow.png" />
+                           </image>
+                        </ImageView>
+                     </graphic>
+                  </Button>
+                  <Button fx:id="buttonUp" layoutX="68.0" layoutY="22.0" maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" mnemonicParsing="false" onAction="#ButtonMove_Click" prefHeight="30.0" prefWidth="30.0" AnchorPane.bottomAnchor="82.0" AnchorPane.rightAnchor="81.0">
+                     <graphic>
+                        <ImageView fitHeight="27.0" fitWidth="10.0" pickOnBounds="true" preserveRatio="true">
+                           <image>
+                              <Image url="@images/UpArrow.png" />
+                           </image>
+                        </ImageView>
+                     </graphic>
+                  </Button>
+               </children>
+            </AnchorPane>
+            <Button fx:id="buttonShowStorage" mnemonicParsing="false" onAction="#ButtonShowStorage_Click" prefHeight="50.0" prefWidth="1.0E16" text="Посмотреть хранилище" GridPane.rowIndex="11" />
+            <TextField fx:id="TextFieldMap" />
+            <Button fx:id="Map" mnemonicParsing="false" onAction="#ButtonAddMap_Click" prefHeight="50.0" prefWidth="9.999999999E9" text="Добавить карту" GridPane.rowIndex="2" />
+            <ListView fx:id="listViewMaps" prefHeight="200.0" prefWidth="200.0" GridPane.rowIndex="3" />
+            <Button fx:id="buttonDeleteMap" mnemonicParsing="false" onAction="#ButtonDeleteMap_Click" prefHeight="50.0" prefWidth="9.999999999E9" text="Удалить карту" GridPane.rowIndex="4" />
+            <Button fx:id="ButtonDeleteEditBus" mnemonicParsing="false" onAction="#ButtonDeleteEditBus_Click" prefHeight="63.0" prefWidth="9.999999999E9" text="Вернуть автобус" GridPane.rowIndex="10" />
+            <Button fx:id="ButtonSortByColor" mnemonicParsing="false" onAction="#ButtonSortByColor_Click" prefHeight="63.0" prefWidth="9.999999999E9" text="Сортировка по цвету" GridPane.rowIndex="7" />
+            <Button fx:id="buttonSortByType" mnemonicParsing="false" onAction="#ButtonSortByType_Click" prefHeight="63.0" prefWidth="9.999999999E9" text="Сортировка по типу" GridPane.rowIndex="8" />
+         </children>
+      </GridPane>
+   </children>
+</GridPane>

DoubleDeckerBus/src/main/resources/com/example/doubledeckerbus/FormPolymorph.fxml

@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import javafx.geometry.Insets?>
+<?import javafx.scene.canvas.Canvas?>
+<?import javafx.scene.control.Button?>
+<?import javafx.scene.control.ChoiceBox?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.layout.AnchorPane?>
+<?import javafx.scene.layout.ColumnConstraints?>
+<?import javafx.scene.layout.GridPane?>
+<?import javafx.scene.layout.HBox?>
+<?import javafx.scene.layout.RowConstraints?>
+
+<GridPane alignment="CENTER" prefHeight="691.0" prefWidth="1041.0" xmlns="http://javafx.com/javafx/18" xmlns:fx="http://javafx.com/fxml/1" fx:controller="com.example.doubledeckerbus.ControllerPolymorph">
+    <columnConstraints>
+        <ColumnConstraints hgrow="ALWAYS" minWidth="10.0" percentWidth="100.0" />
+    </columnConstraints>
+    <rowConstraints>
+        <RowConstraints fillHeight="false" maxHeight="1.7976931348623157E308" percentHeight="90.0" vgrow="ALWAYS" />
+        <RowConstraints fillHeight="false" maxHeight="-Infinity" minHeight="-Infinity" percentHeight="10.0" prefHeight="31.0" vgrow="NEVER" />
+    </rowConstraints>
+    <children>
+        <HBox alignment="CENTER_LEFT" prefHeight="57.0" prefWidth="777.0" spacing="20.0" GridPane.rowIndex="1">
+            <children>
+                <Label fx:id="statusSpeed" text="Скорость:" />
+                <Label fx:id="statusWeight" text="Вес:" />
+                <Label fx:id="statusColor" text="Цвет:" />
+                <Label text="Колл-во дверей:" />
+                <ChoiceBox fx:id="choiceDoors" prefHeight="24.0" prefWidth="58.0" />
+            </children>
+        </HBox>
+        <AnchorPane fx:id="pictureBoxBus" maxHeight="2000000.0" maxWidth="2000000.0" minHeight="0.0" minWidth="0.0" prefHeight="603.0" prefWidth="1020.0">
+            <children>
+                <Canvas fx:id="canvasBus" layoutY="38.0" AnchorPane.leftAnchor="0.0" AnchorPane.topAnchor="0.0" />
+                <Button fx:id="buttonCreate" layoutX="6.0" layoutY="565.0" mnemonicParsing="false" onAction="#ButtonCreate_Click" text="Создать" AnchorPane.bottomAnchor="14.0" AnchorPane.leftAnchor="6.0" />
+                <Button fx:id="buttonCreateExtra" layoutX="90.0" layoutY="565.0" mnemonicParsing="false" onAction="#ButtonCreateExtra_Click" text="Продвинутый объект" AnchorPane.bottomAnchor="14.0" AnchorPane.leftAnchor="90.0" />
+            </children>
+        </AnchorPane>
+    </children>
+    <padding>
+        <Insets bottom="10.0" left="10.0" right="10.0" top="10.0" />
+    </padding>
+</GridPane>

DoubleDeckerBus/src/main/resources/log4j2.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Configuration status="INFO">
+    <Appenders>
+        <File name="InfoFile" fileName="info.log" immediateFlush="false" append="true">
+            <PatternLayout pattern="[%-4level]: %msg (date-%d{yyy.MM.dd})%n"/>
+            <LevelRangeFilter minLevel="INFO" maxLevel="INFO" onMatch="ACCEPT" onMismatch="DENY"/>
+        </File>
+        <File name="WarnErrorFatalFile" fileName="warn.log" immediateFlush="false" append="true">
+            <PatternLayout pattern="[%.5level]: %msg (date-%d{yyy.MM.dd})%n"/>
+            <LevelRangeFilter minLevel="FATAL" maxLevel="WARN" onMatch="ACCEPT" onMismatch="DENY"/>
+        </File>
+    </Appenders>
+    <Loggers>
+        <Root level="debug">
+            <AppenderRef ref="InfoFile" level="info"/>
+            <AppenderRef ref="WarnErrorFatalFile" level="warn"/>
+        </Root>
+    </Loggers>
+</Configuration>