Фиксация третьей лабы на всякий случай

ProjectBulldozer/ProjectBulldozer/CollectionGenericObjects/ICollectoinGenericObjects.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ProjectBulldozer.CollectionGenericObjects;
+
+/// <summary>
+/// Интерфейс описания действий для набора хранимых объектов
+/// </summary>
+/// <typeparam name="T">Параметр: ограничение - ссылочный тип</typeparam>
+public interface ICollectoinGenericObjects<T>
+    where T : class
+{
+    /// <summary>
+    /// Колличество объектов в коллекции
+    /// </summary>
+    int Count { get; }
+
+    /// <summary>
+    /// Установка максимального колличества элементов
+    /// </summary>
+    int SetMaxCount { set; }
+
+    /// <summary>
+    /// Добавление элемента в коллекцию
+    /// </summary>
+    /// <param name="obj">Добавляемый объект</param>
+    /// <returns>true - вставка прошла удачно, false - вставка не удалась</returns>
+    bool Insert(T obj);
+
+    /// <summary>
+    /// Добавление объекта в коллекцию на конкретную позицию
+    /// </summary>
+    /// <param name="obj">Добавляемый объект</param>
+    /// <param name="position">Позиция</param>
+    /// <returns>true - вставка прошла удачно, false - вставка не удалась</returns>
+    bool Insert(T obj, int position);
+
+    /// <summary>
+    /// Удаление объекта из коллекции на конкретной позиции
+    /// </summary>
+    /// <param name="position">Позиция</param>
+    /// <returns></returns>
+    bool Remove(int position);
+
+    /// <summary>
+    /// Получение объекта по позиции
+    /// </summary>
+    /// <param name="position">Позиция</param>
+    /// <returns>Объект</returns>
+    T? Get(int position);
+}

ProjectBulldozer/ProjectBulldozer/CollectionGenericObjects/MassiveGenericObject.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ProjectBulldozer.CollectionGenericObjects;
+
+public class MassiveGenericObject<T> : ICollectoinGenericObjects<T> 
+    where T : class
+{
+    /// <summary>
+    /// Массив объектов, который храним
+    /// </summary>
+    private T?[] _collection;
+
+    public int Count => _collection.Length;
+
+    public int SetMaxCount
+    {
+        set
+        {
+            if (value > 0)
+            {
+                Array.Resize(ref _collection, value);
+            }
+            else
+            {
+                _collection  =new T?[value];
+            }
+        }
+    }
+
+    /// <summary>
+    /// Конструктор
+    /// </summary>
+    public MassiveGenericObject()
+    {
+        _collection = Array.Empty<T>();
+    }
+
+    public T? Get(int position)
+    {
+        //TODO проверка позиции
+        return _collection[position];
+    }
+
+    public bool Insert(T obj)
+    {
+        //TODO вставка в свободное место набора
+        return false;
+    }
+
+    public bool Insert(T obj, int position)
+    {
+        //TODO Проверка позиции
+        //TODO проверка, что элемент массива по этой позиции пустой, если нет, то ищется свободное место после этой
+        //позиции и идёт вставка туда, если нет после, ищем до
+        //TODO вставка
+        return false;
+    }
+
+    public bool Remove(int position)
+    {
+        //TODO проверка позиции
+        //TODO удаление объекта из массива, присвоив элементу массива значение null
+        return true;
+    }
+}

ProjectBulldozer/ProjectBulldozer/Drawnings/DirectionType.cs

@@ -8,6 +8,11 @@ namespace ProjectBulldozer.Drawnings;
 
 public enum DirectionType
 {
+    /// <summary>
+    /// Неизвестное направление
+    /// </summary>
+    Unknow = -1,
+
     ///<summary>
     /// Вверх
     /// </summary>

ProjectBulldozer/ProjectBulldozer/Drawnings/DrawningBulldozer.cs

@@ -37,6 +37,11 @@ public class DrawningBulldozer : DrawningDozer
         Brush bodyBrush = new SolidBrush(EntityDozer.BodyColor);
         Brush additionalBrush = new SolidBrush(EntityDozer.AdditionalColor);
         //BULDOZER
+        _startPosX += 0;
+        _startPosY += 0;
+        base.DrawTransport(g);
+        _startPosX -= 0;
+        _startPosY -= 0;
         //caterpillar
         if (bulldozer.Caterpillar)
         {
@@ -58,10 +63,5 @@ public class DrawningBulldozer : DrawningDozer
             g.DrawRectangle(pen, _startPosX.Value + 125, _startPosY.Value, 25, 90);
             g.DrawLine(pen, _startPosX.Value + 140, _startPosY.Value, _startPosX.Value + 140, _startPosY.Value + 90);
         }
-        _startPosX += 0;
-        _startPosY += 0;
-        base.DrawTransport(g);
-        _startPosX -= 0;
-        _startPosY -= 0;
     }
 }

ProjectBulldozer/ProjectBulldozer/Drawnings/DrawningDozer.cs

@@ -47,6 +47,27 @@ public class DrawningDozer
     /// </summary>
     private readonly int _drawningBulldozerHeight = 90;
 
+    /// <summary>
+    /// Координата X объекта
+    /// </summary>
+    public int? GetPosX => _startPosX;
+
+    /// <summary>
+    /// Координата Y объекта
+    /// </summary>
+    public int? GetPosY => _startPosY;
+
+    /// <summary>
+    /// Ширина объекта
+    /// </summary>
+    public int GetWidth => _drawningBulldozerWidth;
+
+    /// <summary>
+    /// Высота объекта
+    /// </summary>
+    public int GetHeight => _drawningBulldozerHeight;
+
+
     /// <summary>
     /// Пустой конструктор.
     /// </summary>
@@ -75,7 +96,7 @@ public class DrawningDozer
     /// </summary>
     /// <param name="drawningBulldozerWidth">Ширина прорисовки бульдозера</param>
     /// <param name="drawningBulldozerHeigh">Высота прорисовки бульдозера</param>
-    protected DrawningDozer (int drawningBulldozerWidth, int drawningBulldozerHeigh)
+    protected DrawningDozer (int drawningBulldozerWidth, int drawningBulldozerHeigh) :this() 
     {
         _drawningBulldozerWidth = drawningBulldozerWidth;
         //????????
@@ -169,7 +190,7 @@ public class DrawningDozer
     /// </summary>
     /// <param name="direction">Направлениие</param>
     /// <returns>true - перемещениие выполнено, false - перемещение невозможно</returns>
-    public bool MoveTransport(DirectionType direction)
+    public virtual bool MoveTransport(DirectionType direction)
     {
         if (EntityDozer == null || !_startPosX.HasValue || !_startPosY.HasValue)
         {

ProjectBulldozer/ProjectBulldozer/Entities/EntityBulldozer.cs

@@ -9,27 +9,9 @@ namespace ProjectBulldozer.Entities;
 /// <summary>
 /// Класс-сущность "Бульдозер"
 /// </summary>
-public class EntityBulldozer
+public class EntityBulldozer : EntityDozer
 {
-    ///<summary>
+    
-    /// Скорость
-    /// </summary>
-    public int Speed { get; private set; }
-
-    ///<summary>
-    /// Вес
-    /// </summary>
-    public double Weight { get; private set; }
-
-    ///<summary>
-    /// Основной цвет
-    /// </summary>
-    public Color BodyColor { get; private set; }
-
-    ///<summary>
-    /// Дополнительный цвет 
-    /// </summary>
-    public Color AdditionalColor { get; private set; }
 
     ///<summary>
     /// Признак (опция) наличие отвала(ковша)
@@ -40,12 +22,12 @@ public class EntityBulldozer
     /// Признак (опция) наличие гусеницы
     /// </summary>
     public bool Caterpillar { get; private set; }
-
+/*
     ///<summary>
     /// Шаг перемещения бульдозера
     /// </summary>
-    public double Step => Speed * 100 / Weight;
+    public double Step => Speed * 100 / Weight;*/
-
+/*
     ///<summary>
     ///Инициализация полей объекта-класса бульдозера
     /// </summary>
@@ -55,12 +37,13 @@ public class EntityBulldozer
     ///<param name="additionalColor">Дополнительный цвет</param>
     ///<param name="blade">Признак наличия отвала</param>
     ///<param name="caterpillar">Признак наличия гусеницы</param>
-    public void Init(int speed, double weight, Color bodyColor, Color additionalColor, bool blade, bool caterpillar)
+    public void EntityBulldozer(bool blade, bool caterpillar) base(speed, )
+    {
+        Blade = blade;
+        Caterpillar = caterpillar;
+    }*/
+    public EntityBulldozer(int speed, double weight, Color bodyColor, Color additionalColor, bool blade, bool caterpillar) : base(speed, weight, bodyColor, additionalColor)
     {
-        Speed = speed;
-        Weight = weight;
-        BodyColor = bodyColor;
-        AdditionalColor = additionalColor;
         Blade = blade;
         Caterpillar = caterpillar;
     }

ProjectBulldozer/ProjectBulldozer/Entities/EntityDozer.cs

@@ -37,13 +37,13 @@ public class EntityDozer
     public double Step => Speed * 100 / Weight;
 
     ///<summary>
-    /// Конструктор сущности
+    /// Конструктор
     /// </summary>
     ///<param name="speed">Скорость</param>
     ///<param name="weight">Вес</param>
     ///<param name="bodyColor">Основной цвет</param>
     ///<param name="additionalColor">Дополнительный цвет</param>
-    public EntityDozer(int speed, double weight, Color bodyColor, Color additionalColor)
+    public EntityDozer(int speed, double weight, Color bodyColor, Color additionalColor) 
     {
         Speed = speed;
         Weight = weight;

ProjectBulldozer/ProjectBulldozer/FormBulldozer.Designer.cs

@@ -29,11 +29,14 @@
         private void InitializeComponent()
         {
             pictureBoxBulldozer = new PictureBox();
-            buttonCreate = new Button();
+            ButtonCreateBulldozer = new Button();
             buttonRight = new Button();
             buttonUp = new Button();
             buttonLeft = new Button();
             buttonDown = new Button();
+            ButtonCreateDozer = new Button();
+            comboBoxStrategy = new ComboBox();
+            buttonStrategyStep = new Button();
             ((System.ComponentModel.ISupportInitialize)pictureBoxBulldozer).BeginInit();
             SuspendLayout();
             // 
@@ -47,17 +50,17 @@
             pictureBoxBulldozer.TabIndex = 0;
             pictureBoxBulldozer.TabStop = false;
             // 
-            // buttonCreate
+            // ButtonCreateBulldozer
             // 
-            buttonCreate.Anchor = AnchorStyles.Bottom | AnchorStyles.Left;
+            ButtonCreateBulldozer.Anchor = AnchorStyles.Bottom | AnchorStyles.Left;
-            buttonCreate.Font = new Font("Comic Sans MS", 9F, FontStyle.Regular, GraphicsUnit.Point);
+            ButtonCreateBulldozer.Font = new Font("Comic Sans MS", 9F, FontStyle.Regular, GraphicsUnit.Point);
-            buttonCreate.Location = new Point(12, 371);
+            ButtonCreateBulldozer.Location = new Point(12, 371);
-            buttonCreate.Name = "buttonCreate";
+            ButtonCreateBulldozer.Name = "ButtonCreateBulldozer";
-            buttonCreate.Size = new Size(150, 46);
+            ButtonCreateBulldozer.Size = new Size(325, 46);
-            buttonCreate.TabIndex = 1;
+            ButtonCreateBulldozer.TabIndex = 1;
-            buttonCreate.Text = "Создать";
+            ButtonCreateBulldozer.Text = "Создать крутой бульдозер";
-            buttonCreate.UseVisualStyleBackColor = true;
+            ButtonCreateBulldozer.UseVisualStyleBackColor = true;
-            buttonCreate.Click += buttonCreate_Click;
+            ButtonCreateBulldozer.Click += ButtonCreateBulldozer_Click;
             // 
             // buttonRight
             // 
@@ -107,16 +110,53 @@
             buttonDown.UseVisualStyleBackColor = true;
             buttonDown.Click += ButtonMove_Click;
             // 
+            // ButtonCreateDozer
+            // 
+            ButtonCreateDozer.Anchor = AnchorStyles.Bottom | AnchorStyles.Left;
+            ButtonCreateDozer.Font = new Font("Comic Sans MS", 9F, FontStyle.Regular, GraphicsUnit.Point);
+            ButtonCreateDozer.Location = new Point(343, 371);
+            ButtonCreateDozer.Name = "ButtonCreateDozer";
+            ButtonCreateDozer.Size = new Size(248, 46);
+            ButtonCreateDozer.TabIndex = 6;
+            ButtonCreateDozer.Text = "Создать бульдозер";
+            ButtonCreateDozer.UseVisualStyleBackColor = true;
+            ButtonCreateDozer.Click += ButtonCreateDozer_Click;
+            // 
+            // comboBoxStrategy
+            // 
+            comboBoxStrategy.DropDownStyle = ComboBoxStyle.DropDownList;
+            comboBoxStrategy.FormattingEnabled = true;
+            comboBoxStrategy.Items.AddRange(new object[] { "К центру", "К левому нижнему краю", "К правому нижнему краю" });
+            comboBoxStrategy.Location = new Point(620, 12);
+            comboBoxStrategy.Name = "comboBoxStrategy";
+            comboBoxStrategy.Size = new Size(242, 40);
+            comboBoxStrategy.TabIndex = 7;
+            // 
+            // buttonStrategyStep
+            // 
+            buttonStrategyStep.Anchor = AnchorStyles.Bottom | AnchorStyles.Left;
+            buttonStrategyStep.Font = new Font("Comic Sans MS", 9F, FontStyle.Regular, GraphicsUnit.Point);
+            buttonStrategyStep.Location = new Point(760, 58);
+            buttonStrategyStep.Name = "buttonStrategyStep";
+            buttonStrategyStep.Size = new Size(102, 38);
+            buttonStrategyStep.TabIndex = 8;
+            buttonStrategyStep.Text = "Шаг";
+            buttonStrategyStep.UseVisualStyleBackColor = true;
+            buttonStrategyStep.Click += ButtonStrategyStep_Click;
+            // 
             // FormBulldozer
             // 
             AutoScaleDimensions = new SizeF(13F, 32F);
             AutoScaleMode = AutoScaleMode.Font;
             ClientSize = new Size(874, 429);
+            Controls.Add(buttonStrategyStep);
+            Controls.Add(comboBoxStrategy);
+            Controls.Add(ButtonCreateDozer);
             Controls.Add(buttonDown);
             Controls.Add(buttonLeft);
             Controls.Add(buttonUp);
             Controls.Add(buttonRight);
-            Controls.Add(buttonCreate);
+            Controls.Add(ButtonCreateBulldozer);
             Controls.Add(pictureBoxBulldozer);
             Name = "FormBulldozer";
             Text = "FormBulldozer";
@@ -128,10 +168,13 @@
         #endregion
 
         private PictureBox pictureBoxBulldozer;
-        private Button buttonCreate;
+        private Button ButtonCreateBulldozer;
         private Button buttonRight;
         private Button buttonUp;
         private Button buttonLeft;
         private Button buttonDown;
+        private Button ButtonCreateDozer;
+        private ComboBox comboBoxStrategy;
+        private Button buttonStrategyStep;
     }
 }

ProjectBulldozer/ProjectBulldozer/FormBulldozer.cs

@@ -4,95 +4,179 @@ using System.ComponentModel;
 using System.Data;
 using System.Drawing;
 using System.Linq;
+using System.Runtime.InteropServices;
 using System.Text;
 using System.Threading.Tasks;
 using System.Windows.Forms;
 using ProjectBulldozer.Drawnings;
+using ProjectBulldozer.MovementStrategy;
 
-namespace ProjectBulldozer
+namespace ProjectBulldozer;
+
+/// <summary>
+/// Форма работы с объектом "Бульдозер"
+/// </summary>
+public partial class FormBulldozer : Form
 {
-    public partial class FormBulldozer : Form
+    /// <summary>
+    /// Поле-объект для прорисовки объекта
+    /// </summary>
+    private DrawningDozer? _drawningDozer;
+
+    /// <summary>
+    /// Стратегия перемещения
+    /// </summary>
+    private AbstractStrategy? _strategy;
+
+    /// <summary>
+    /// Конструктор формы
+    /// </summary>
+    public FormBulldozer()
     {
-        private DrawningBulldozer? _drawningBulldozer;
+        InitializeComponent();
-        //private EntityBulldozer? _entityBulldozer;
+        _strategy = null;
-        public FormBulldozer()
+    }
+
+    /// <summary>
+    /// Метод прорисовки транспорта
+    /// </summary>
+    private void Draw()
+    {
+        if (_drawningDozer == null)
         {
-            InitializeComponent();
+            return;
         }
 
-        private void Draw()
+        Bitmap bmp = new(pictureBoxBulldozer.Width, pictureBoxBulldozer.Height);
+        Graphics gr = Graphics.FromImage(bmp);
+        _drawningDozer.DrawTransport(gr);
+        pictureBoxBulldozer.Image = bmp;
+    }
+
+    /// <summary>
+    /// Создание объекта класса-перемещения
+    /// </summary>
+    /// <param name="type">Тип создаваемого объекта</param>
+    private void CreateObject(string type)
+    {
+        Random random = new();
+        switch (type)
         {
-            if (_drawningBulldozer == null)
+            case nameof(DrawningDozer):
-            {
+                _drawningDozer = new DrawningDozer(random.Next(100, 300), random.Next(1000, 3000),
+            Color.FromArgb(random.Next(170, 256), random.Next(170, 256), random.Next(30, 140)),
+            Color.FromArgb(random.Next(30, 120), random.Next(30, 120), random.Next(30, 120)));
+                break;
+            case nameof(DrawningBulldozer):
+                _drawningDozer = new DrawningBulldozer(random.Next(100, 300), random.Next(1000, 3000),
+            Color.FromArgb(random.Next(170, 256), random.Next(170, 256), random.Next(30, 140)),
+            Color.FromArgb(random.Next(30, 120), random.Next(30, 120), random.Next(30, 120)),
+            Convert.ToBoolean(random.Next(0, 2)), Convert.ToBoolean(random.Next(0, 2)));
+                break;
+            default:
                 return;
-            }
-
-            Bitmap bmp = new(pictureBoxBulldozer.Width, pictureBoxBulldozer.Height);
-            Graphics gr = Graphics.FromImage(bmp);
-            _drawningBulldozer.DrawTransport(gr);
-            pictureBoxBulldozer.Image = bmp;
         }
 
-        /// <summary>
+        _drawningDozer.SetPictureSize(pictureBoxBulldozer.Width, pictureBoxBulldozer.Height);
-        /// Обработка нажатия кнопки "Создать"
+        _drawningDozer.SetPosition(random.Next(10, 100), random.Next(10, 100));
-        /// </summary>
+        _strategy = null;
-        /// <param name="sender"></param>
+        comboBoxStrategy.Enabled = true;
-        /// <param name="e"></param>
+        Draw();
-        private void buttonCreate_Click(object sender, EventArgs e)
+    }
+
+    /// <summary>
+    /// Обработка нажатия кнопки "Создать крутой бульдозер"
+    /// </summary>
+    /// <param name="sender"></param>
+    /// <param name="e"></param>
+    private void ButtonCreateBulldozer_Click(object sender, EventArgs e) =>
+        CreateObject(nameof(DrawningBulldozer));
+
+    /// <summary>
+    /// Обработка нажатия кнопки "Создать бульдозер"
+    /// </summary>
+    /// <param name="sender"></param>
+    /// <param name="e"></param>
+    private void ButtonCreateDozer_Click(object sender, EventArgs e) =>
+        CreateObject(nameof(DrawningDozer));
+
+    /// <summary>
+    /// Перемещение объекта по форме (нажатие кнопок навигации)
+    /// </summary>
+    /// <param name="sender"></param>
+    /// <param name="e"></param>
+    private void ButtonMove_Click(object sender, EventArgs e)
+    {
+        if (_drawningDozer == null)
+        {
+            return;
+        }
+
+        string name = ((Button)sender)?.Name ?? string.Empty;
+        bool result = false;
+        switch (name)
+        {
+            case "buttonUp":
+                result = _drawningDozer.MoveTransport(DirectionType.Up);
+                break;
+            case "buttonDown":
+                result = _drawningDozer.MoveTransport(DirectionType.Down);
+                break;
+            case "buttonLeft":
+                result = _drawningDozer.MoveTransport(DirectionType.Left);
+                break;
+            case "buttonRight":
+                result = _drawningDozer.MoveTransport(DirectionType.Right);
+                break;
+        }
+        if (result)
         {
-            Random random = new();
-            _drawningBulldozer = new DrawningBulldozer();
-            //_entityBulldozer = new EntityBulldozer();
-            /*_entityBulldozer.Init(random.Next(100, 300), random.Next(1000, 3000),
-                Color.FromArgb(random.Next(170, 256), random.Next(170, 210), random.Next(30, 140)),
-                Color.FromArgb(random.Next(30, 120), random.Next(30, 120), random.Next(30, 120)),
-                Convert.ToBoolean(random.Next(0, 2)), Convert.ToBoolean(random.Next(0, 2)));*/
-            //_drawningBulldozer.Init(_entityBulldozer);
-            _drawningBulldozer.Init(random.Next(100, 300), random.Next(1000, 3000),
-                Color.FromArgb(random.Next(170, 256), random.Next(170, 256), random.Next(30, 140)),
-                Color.FromArgb(random.Next(30, 120), random.Next(30, 120), random.Next(30, 120)),
-                Convert.ToBoolean(random.Next(0, 2)), Convert.ToBoolean(random.Next(0, 2)));
-            //_drawningBulldozer.Init(150, 2000, Color.FromArgb(240, 200, 50), Color.FromArgb(30, 30, 70), true, false);
-            _drawningBulldozer.SetPictureSize(pictureBoxBulldozer.Width, pictureBoxBulldozer.Height);
-            //_drawningBulldozer.SetPosition(pictureBoxBulldozer.Width - random.Next(150, 250), pictureBoxBulldozer.Height - random.Next(100, 200));
-            _drawningBulldozer.SetPosition(random.Next(10, 100), random.Next(10, 100));
             Draw();
         }
+    }
 
-        /// <summary>
+
-        /// Перемещение объекта по форме (нажатие кнопок навигации)
+    private void ButtonStrategyStep_Click(object sender, EventArgs e)
-        /// </summary>
+    {
-        /// <param name="sender"></param>
+        if (_drawningDozer == null)
-        /// <param name="e"></param>
-        private void ButtonMove_Click(object sender, EventArgs e)
         {
-            if (_drawningBulldozer == null)
+            return;
+        }
+
+        if (comboBoxStrategy.Enabled)
+        {
+            _strategy = comboBoxStrategy.SelectedIndex switch
+            {
+                0 => new MoveToCenter(),
+                1 => new MoveToBorderLB(),
+                2 => new MoveToBorderRB(),
+                _ => null,
+            };
+
+            if (_strategy == null)
             {
                 return;
             }
 
-            string name = ((Button)sender)?.Name ?? string.Empty;
+            _strategy.SetData(new MoveableDozer(_drawningDozer), pictureBoxBulldozer.Width,
-            bool result = false;
+                pictureBoxBulldozer.Height);
-            switch (name)
-            {
-                case "buttonUp":
-                    result = _drawningBulldozer.MoveTransport(DirectionType.Up);
-                    break;
-                case "buttonDown":
-                    result = _drawningBulldozer.MoveTransport(DirectionType.Down);
-                    break;
-                case "buttonLeft":
-                    result = _drawningBulldozer.MoveTransport(DirectionType.Left);
-                    break;
-                case "buttonRight":
-                    result = _drawningBulldozer.MoveTransport(DirectionType.Right);
-                    break;
-            }
-            if (result)
-            {
-                Draw();
-            }
         }
 
+        if (_strategy == null)
+        {
+            return;
+        }
+
+        comboBoxStrategy.Enabled = false;
+        _strategy.MakeStep();
+        Draw();
+
+        if (_strategy.GetStatus() == StrategyStatus.Finish)
+        {
+            comboBoxStrategy.Enabled = true;
+            _strategy = null;
+        }
     }
 }
+
+//2

ProjectBulldozer/ProjectBulldozer/MovementStrategy/AbstractStrategy.cs

@@ -0,0 +1,141 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ProjectBulldozer.MovementStrategy;
+
+public abstract class AbstractStrategy
+{
+    /// <summary>
+    /// Перемещаемый объект
+    /// </summary>
+    private IMoveableObject? _moveableObject;
+
+    /// <summary>
+    /// Статус перемещения
+    /// </summary>
+    private StrategyStatus _state = StrategyStatus.NotInit;
+
+    /// <summary>
+    /// Ширина поля
+    /// </summary>
+    protected int FieldWidth {  get; private set; }
+
+    /// <summary>
+    /// Высота поля
+    /// </summary>
+    protected int FieldHeight { get; private set; }
+
+    /// <summary>
+    /// Статус перемещения
+    /// </summary>
+    /// <returns></returns>
+    public StrategyStatus GetStatus() { return _state; }
+
+    /// <summary>
+    /// Установка данных
+    /// </summary>
+    /// <param name="moveableObject">Перемещаемый объект</param>
+    /// <param name="width">Ширина поля</param>
+    /// <param name="height">Высота поля</param>
+    public void SetData(IMoveableObject moveableObject, int width, int height)
+    {
+        if (moveableObject == null)
+        {
+            _state = StrategyStatus.NotInit;
+            return;
+        }
+        _state = StrategyStatus.InProgress;
+        _moveableObject = moveableObject;
+        FieldWidth = width;
+        FieldHeight = height;
+    }
+
+    /// <summary>
+    /// Шаг перемещения
+    /// </summary>
+    public void MakeStep()
+    {
+        if (_state != StrategyStatus.InProgress)
+        {
+            return;
+        }
+
+        if (IsTargetDestinaion())
+        {
+            _state = StrategyStatus.Finish;
+            return;
+        }
+
+        MoveToTarget();
+    }
+
+    /// <summary>
+    /// Пермещение влево
+    /// </summary>
+    /// <returns>Результат перемещения (true - удалось переместиться, false - неудача)</returns>
+    protected bool MoveLeft() => MoveTo(MovementDirection.Left);
+
+    /// <summary>
+    /// Пермещение вправо
+    /// </summary>
+    /// <returns>Результат перемещения (true - удалось переместиться, false - неудача)</returns>
+    protected bool MoveRight() => MoveTo(MovementDirection.Right);
+
+    /// <summary>
+    /// Пермещение вверх
+    /// </summary>
+    /// <returns>Результат перемещения (true - удалось переместиться, false - неудача)</returns>
+    protected bool MoveUp() => MoveTo(MovementDirection.Up);
+
+    /// <summary>
+    /// Пермещение вниз
+    /// </summary>
+    /// <returns>Результат перемещения (true - удалось переместиться, false - неудача)</returns>
+    protected bool MoveDown() => MoveTo(MovementDirection.Down);
+
+    /// <summary>
+    /// Параметры объекта
+    /// </summary>
+    protected ObjectParameters? GetObjectParameters => _moveableObject?.GetObjectPosition;
+
+    /// <summary>
+    /// Шаг объекта
+    /// </summary>
+    /// <returns></returns>
+    protected int? GetStep()
+    {
+        if (_state != StrategyStatus.InProgress)
+        {
+            return null;
+        }
+        return _moveableObject?.GetStep;
+    }
+
+    /// <summary>
+    /// Перемещение к цели
+    /// </summary>
+    protected abstract void MoveToTarget();
+
+    /// <summary>
+    /// Достигнута ли цель
+    /// </summary>
+    /// <returns></returns>
+    protected abstract bool IsTargetDestinaion();
+
+    /// <summary>
+    /// Попытка пермещения  в требуемом направлении
+    /// </summary>
+    /// <param name="movementDirection">Направление</param>
+    /// <returns>Результат попытки (true - удалось переместиться, false - неудача)</returns>
+    private bool MoveTo(MovementDirection movementDirection)
+    {
+        if (_state  != StrategyStatus.InProgress)
+        {
+            return false;
+        }
+        return _moveableObject?.TryMoveObject(movementDirection) ?? false;
+    }
+}

ProjectBulldozer/ProjectBulldozer/MovementStrategy/IMoveableObject.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ProjectBulldozer.MovementStrategy;
+
+/// <summary>
+/// Интерфейс для работы с перемещаемым объектом
+/// </summary>
+public interface IMoveableObject
+{
+    /// <summary>
+    /// Получение координаты объекта
+    /// </summary>
+    ObjectParameters? GetObjectPosition {  get; }
+
+    /// <summary>
+    /// Шаг объекта
+    /// </summary>
+    int GetStep {  get; }
+
+    /// <summary>
+    /// Попытка переместить объект в указанном направлении
+    /// </summary>
+    /// <param name="direction">Направление</param>
+    /// <returns>true - объект перемещён, false - перемещение невозможно</returns>
+    bool TryMoveObject(MovementDirection direction);
+}

ProjectBulldozer/ProjectBulldozer/MovementStrategy/MoveToBorderLB.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ProjectBulldozer.MovementStrategy;
+
+public class MoveToBorderLB : AbstractStrategy
+{
+
+    protected override bool IsTargetDestinaion()
+    {
+        ObjectParameters? objParams = GetObjectParameters;
+        if (objParams == null)
+        {
+            return false;
+        }
+
+        return objParams.LeftBorder - GetStep() <= 0 && objParams.BottomBorder + GetStep() >= FieldHeight;
+    }
+
+    protected override void MoveToTarget()
+    {
+        ObjectParameters? objParams = GetObjectParameters;
+        if (objParams == null)
+        {
+            return;
+        }
+
+        int diffX = objParams.LeftBorder - FieldWidth;
+        if (Math.Abs(diffX) > GetStep())
+        {
+            MoveLeft();
+        }
+
+        int diffY = objParams.BottomBorder - FieldHeight;
+        if (Math.Abs(diffY) > GetStep())
+        {
+            MoveDown();
+        }
+    }
+}

ProjectBulldozer/ProjectBulldozer/MovementStrategy/MoveToBorderRB.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ProjectBulldozer.MovementStrategy;
+
+public class MoveToBorderRB : AbstractStrategy
+{
+
+    protected override bool IsTargetDestinaion()
+    {
+        ObjectParameters? objParams = GetObjectParameters;
+        if (objParams == null)
+        {
+            return false;
+        }
+
+        return objParams.RightBorder + GetStep() >= FieldWidth && objParams.LeftBorder + GetStep() >= FieldHeight;
+    }
+
+    protected override void MoveToTarget()
+    {
+        ObjectParameters? objParams = GetObjectParameters;
+        if (objParams == null)
+        {
+            return;
+        }
+
+        int diffX = objParams.RightBorder - FieldWidth;
+        if (Math.Abs(diffX) > GetStep())
+        {
+            MoveRight();
+        }
+
+        int diffY = objParams.BottomBorder - FieldHeight;
+        if (Math.Abs(diffY) > GetStep())
+        {
+            MoveDown();
+        }
+    }
+}

ProjectBulldozer/ProjectBulldozer/MovementStrategy/MoveToCenter.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ProjectBulldozer.MovementStrategy;
+
+/// <summary>
+/// Стратегия перемещения объекта в центр экрана
+/// </summary>
+public class MoveToCenter : AbstractStrategy
+{
+
+    protected override bool IsTargetDestinaion()
+    {
+        ObjectParameters? objParams = GetObjectParameters;
+        if (objParams == null)
+        {
+            return false;
+        }
+
+        return objParams.ObjectMiddleHorizontal - GetStep() <= FieldWidth / 2 && 
+            objParams.ObjectMiddleHorizontal + GetStep() >= FieldWidth / 2 &&
+            objParams.ObjectMiddleVertical - GetStep() <= FieldHeight / 2 && 
+            objParams.ObjectMiddleVertical + GetStep() >= FieldHeight / 2;
+    }
+
+    protected override void MoveToTarget()
+    {
+        ObjectParameters? objParams = GetObjectParameters;
+        if(objParams == null)
+        {
+            return;
+        }
+
+        int diffX = objParams.ObjectMiddleHorizontal - FieldWidth / 2;
+        if (Math.Abs(diffX) > GetStep())
+        {
+            if (diffX > 0)
+            {
+                MoveLeft();
+            }
+            else
+            {
+                MoveRight();
+            }
+        }
+
+        int diffY = objParams.ObjectMiddleVertical - FieldHeight / 2;
+        if (Math.Abs(diffY) > GetStep())
+        {
+            if (diffY > 0)
+            {
+                MoveUp();
+            }
+            else
+            {
+                MoveDown();
+            }
+        }
+    }
+}

ProjectBulldozer/ProjectBulldozer/MovementStrategy/MoveableDozer.cs

@@ -0,0 +1,66 @@
+using ProjectBulldozer.Drawnings;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ProjectBulldozer.MovementStrategy;
+
+/// <summary>
+/// Класс-реализация IMoveableObject с использованием DrawningDozer
+/// </summary>
+public class MoveableDozer : IMoveableObject
+{
+    /// <summary>
+    /// Поле-объект класса DrawningDozer или его наследника
+    /// </summary>
+    private readonly DrawningDozer? _dozer = null;
+
+    /// <summary>
+    /// Констректор
+    /// </summary>
+    /// <param name="dozer">Объект класса DrawningDozer</param>
+    public MoveableDozer(DrawningDozer dozer)
+    {
+        _dozer = dozer;
+    }
+
+    public ObjectParameters? GetObjectPosition
+    {
+        get
+        {
+            if (_dozer == null || _dozer.EntityDozer == null || 
+                !_dozer.GetPosX.HasValue || !_dozer.GetPosY.HasValue)
+            {
+                return null;
+            }
+            return new ObjectParameters(_dozer.GetPosX.Value, _dozer.GetPosY.Value,
+                _dozer.GetWidth, _dozer.GetHeight);
+        }
+    }
+
+    public int GetStep => (int)(_dozer?.EntityDozer?.Step ?? 0);
+
+    public bool TryMoveObject(MovementDirection direction)
+    {
+        if (_dozer == null || _dozer.EntityDozer == null)
+        {
+            return false;
+        }
+
+        return _dozer.MoveTransport(GetDirectionType(direction));
+    }
+
+    private static DirectionType GetDirectionType(MovementDirection direction)
+    {
+        return direction switch
+        {
+            MovementDirection.Left => DirectionType.Left,
+            MovementDirection.Right => DirectionType.Right,
+            MovementDirection.Up => DirectionType.Up,
+            MovementDirection.Down => DirectionType.Down,
+            _ => DirectionType.Unknow,
+        };
+    }
+}

ProjectBulldozer/ProjectBulldozer/MovementStrategy/MovementDirection.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ProjectBulldozer.MovementStrategy;
+
+public enum MovementDirection
+{
+    /// <summary>
+    /// Вверх
+    /// </summary>
+    Up = 1,
+
+    /// <summary>
+    /// Вниз
+    /// </summary>
+    Down = 2,
+
+    /// <summary>
+    /// Вллево
+    /// </summary>
+    Left = 3,
+
+    /// <summary>
+    /// Вправо
+    /// </summary>
+    Right = 4
+}

ProjectBulldozer/ProjectBulldozer/MovementStrategy/ObjectParameters.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ProjectBulldozer.MovementStrategy;
+
+/// <summary>
+/// Параметры-координаты объекта
+/// </summary>
+public class ObjectParameters
+{
+    /// <summary>
+    /// Координата X
+    /// </summary>
+    private readonly int _x;
+
+    /// <summary>
+    /// Координата Y
+    /// </summary>
+    private readonly int _y;
+
+    /// <summary>
+    /// Ширина объекта
+    /// </summary>
+    private readonly int _width;
+
+    /// <summary>
+    /// Высота объекта
+    /// </summary>
+    private readonly int _height;
+
+    /// <summary>
+    /// Левая граница
+    /// </summary>
+    public int LeftBorder => _x;
+
+    /// <summary>
+    /// Верхняя граница
+    /// </summary>
+    public int TopBorder => _y;
+
+    /// <summary>
+    /// Правая граница
+    /// </summary>
+    public int RightBorder => _x + _width;
+
+    /// <summary>
+    /// Нижняя граница
+    /// </summary>
+    public int BottomBorder => _y + _height;
+
+    /// <summary>
+    /// Середина объекта
+    /// </summary>
+    public int ObjectMiddleHorizontal => _x + _width / 2; //???
+
+    /// <summary>
+    /// Середина объекта
+    /// </summary>
+    public int ObjectMiddleVertical => _y + _height / 2;
+
+    /// <summary>
+    /// Конструктор
+    /// </summary>
+    /// <param name="x">Координата X</param>
+    /// <param name="y">Координата Y</param>
+    /// <param name="width">Ширина объекта</param>
+    /// <param name="height">Высота объекта</param>
+    public ObjectParameters(int x, int y, int width, int height)
+    {
+        _x = x;
+        _y = y;
+        _width = width;
+        _height = height;
+    }
+}

ProjectBulldozer/ProjectBulldozer/MovementStrategy/StrategyStatus.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ProjectBulldozer.MovementStrategy;
+
+/// <summary>
+/// Статус выполнения операции перемещения
+/// </summary>
+public enum StrategyStatus
+{
+    /// <summary>
+    /// Всё готово к началу
+    /// </summary>
+    NotInit,
+
+    /// <summary>
+    /// Выполняется
+    /// </summary>
+    InProgress,
+
+    /// <summary>
+    /// Завершено
+    /// </summary>
+    Finish
+}

ProjectBulldozer/ProjectBulldozer/NewClass.cs

@@ -1,18 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace ProjectBulldozer
-{
-    internal class NewClass
-    {
-        private int closedField;
-        public double Property { private get; set; }
-        public void NewMethod()
-        {
-            //Новый метод.
-        }
-    }
-}

ProjectBulldozer/ProjectBulldozer/ProjectBulldozer.csproj

@@ -23,8 +23,4 @@
     </EmbeddedResource>
   </ItemGroup>
 
-  <ItemGroup>
-    <Folder Include="MovementStrategy\" />
-  </ItemGroup>
-
 </Project>