PIbd-22_Turner_I.A._AntiAircraftGun._Base/AntiAircraftGun/AntiAircraftGun/AbstractMap.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AntiAircraftGun
{
    internal 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 readonly Random _random = new();
        protected readonly int _freeRoad = 0;
        protected readonly int _barrier = 1;
        public Bitmap CreateMap(int width, int height, IDrawingObject drawningObject)
        {
            _width = width;
            _height = height;
            _drawingObject = drawningObject;
            GenerateMap();
            while (!SetObjectOnMap())
            {
                GenerateMap();
            }
            return DrawMapWithObject();
        }
        public Bitmap MoveObject(Direction direction)
        {
            if (CheckCollision(direction))
            {
                _drawingObject.MoveObject(direction);
            }
            return DrawMapWithObject();
        }
        private bool CheckCollision(Direction direction)
        {
            (float left, float right, float top, float bottom) = _drawingObject.GetCurrentPosition();
            float step = _drawingObject?.Step ?? 0;
            int startX = 0, startY = 0, finishX = 0, finishY = 0;

            switch (direction)
            {
                case Direction.Up:
                    startX = (int)left;
                    startY = (int)(top - step);
                    finishX = (int)right;
                    finishY = (int)top;
                    break;
                case Direction.Down:
                    startX = (int)left;
                    startY = (int)bottom;
                    finishX = (int)right;
                    finishY = (int)(bottom + step);
                    break;
                case Direction.Left:
                    startX = (int)(left - step);
                    startY = (int)top;
                    finishX = (int)left;
                    finishY = (int)bottom;
                    break;
                case Direction.Right:
                    startX = (int)right;
                    startY = (int)top;
                    finishX = (int)(right + step);
                    finishY = (int)bottom;
                    break;
            }

            if (startX < 0 || finishX > _width || startY < 0 || finishY > _height) return false;

            startX = (int)(startX / _size_x);
            startY = (int)(startY / _size_y);
            finishX = (int)(finishX / _size_x) + 1;
            finishY = (int)(finishY / _size_y) + 1;

            for (int i = startX; i < (finishX > _map.GetLength(0) ? _map.GetLength(0) : finishX); i++)
                for (int j = startY; j < (finishY > _map.GetLength(1) ? _map.GetLength(1) : finishY); j++)
                    if (_map[i, j] == _barrier) return false;
            return true;
        }
        private bool CheckCollisionOnSpawn()
        {
            (float left, float right, float top, float bottom) = _drawingObject.GetCurrentPosition();
            int spawnX = (int)(left / _size_x) - 1 < 0 ? 0 : (int)(left / _size_x);
            int spawnY = (int)(top / _size_y) - 1 < 0 ? 0 : (int)(bottom / _size_y);

            for (int i = spawnX; i <= (int)(right / _size_x) + 1; i++)
                for (int j = spawnY; j <= (int)(bottom / _size_y) + 1; j++)
                    if (_map[i, j] == _barrier)
                    {
                        return false;
                    }
            return true;
        }
        private bool SetObjectOnMap()
        {
            if (_drawingObject == null || _map == null)
            {
                return false;
            }
            int x = _random.Next(0, 10);
            int y = _random.Next(0, 10);
            _drawingObject.SetObject(x, y, _width, _height);
            while (!CheckCollisionOnSpawn())
            {
                x += 10;
                if (x > _width)
                {
                    if (y < _height)
                    {
                        y += 10;
                        x = 0;
                    }
                    else
                    {
                        return false;
                    }                        
                }
                _drawingObject.SetObject(x, y, _width, _height);
            }
            return true;
        }
        private Bitmap DrawMapWithObject()
        {
            Bitmap bmp = new(_width, _height);
            if (_drawingObject == null || _map == null)
            {
                return bmp;
            }
            Graphics gr = Graphics.FromImage(bmp);
            for (int i = 0; i < _map.GetLength(0); ++i)
            {
                for (int j = 0; j < _map.GetLength(1); ++j)
                {
                    if (_map[i, j] == _freeRoad)
                    {
                        DrawRoadPart(gr, i, j);
                    }
                    else if (_map[i, j] == _barrier)
                    {
                        DrawBarrierPart(gr, i, j);
                    }
                }
            }
            _drawingObject.DrawingObjectAntiAircraftGun(gr);
            return bmp;
        }
        protected abstract void GenerateMap();
        protected abstract void DrawRoadPart(Graphics g, int i, int j);
        protected abstract void DrawBarrierPart(Graphics g, int i, int j);
    }
}