PIbd-21_Eliseev_E.E._Airbus_Base/Airbus/Airbus/AbstractMap.cs

using Microsoft.VisualBasic.Logging;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Airbus
{
    internal abstract class AbstractMap : IEquatable<AbstractMap>
    {
        private IDrawningObject _drawningObject = 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, IDrawningObject drawningObject)
        {
            _width = width;
            _height = height;
            _drawningObject = drawningObject;

            GenerateMap();
            while (!SetObjectOnMap())
            {
                GenerateMap();
            }

            return DrawMapWithObject();
        }

        //проверка на "накладывание"
        protected bool CheckPosition(float Left, float Right, float Top, float Bottom)
        {
            int x_start = (int)(Left / _size_x);
            int y_start = (int)(Right / _size_y);
            int x_end = (int)(Top / _size_x);
            int y_end = (int)(Bottom / _size_y);

            for(int i = x_start; i <= x_end; i++)
            {
                for(int j = y_start; j <= y_end; j++)
                {
                    if (_map[i, j] == _barrier)
                    {
                        return true;
                    }
                }
            }

            return false;
        }

        public Bitmap MoveObject(Direction direction)
        {
            _drawningObject.MoveObject(direction);
            (float Left, float Right, float Top, float Bottom) = _drawningObject.GetCurrentPosition();

            if (CheckPosition(Left, Right, Top, Bottom))
            {
                _drawningObject.MoveObject(MoveObjectBack(direction));
            }

            return DrawMapWithObject();
        }

        private Direction MoveObjectBack(Direction direction)
        {
            switch (direction)
            {
                case Direction.Up:
                    return Direction.Down;
                    break;
                case Direction.Down:
                    return Direction.Up;
                    break;
                case Direction.Left:
                    return Direction.Right;
                    break;
                case Direction.Right:
                    return Direction.Left;
                    break;
            }

            return Direction.None;
        }

        private bool SetObjectOnMap()
        {
            if(_drawningObject == null || _map == null)
            {
                return false;
            }

            int x = _random.Next(0, 10);
            int y = _random.Next(0, 10);
            _drawningObject.SetObject(x, y, _width, _height);
            (float Left, float Right, float Top, float Bottom) = _drawningObject.GetCurrentPosition();
            
            if(!CheckPosition(Left, Right, Top, Bottom))
            {
                return true;
            }

            float x_start = Left;
            float y_start = Right;
            float x_length = Top - Left;
            float y_length = Bottom - Right;
            while(CheckPosition(x_start, y_start, x_start + x_length, y_start + y_length))
            {
                bool check;

                do
                {
                    check = CheckPosition(x_start, y_start, x_start + x_length, y_start + y_length);

                    if (!check)
                    {
                        _drawningObject.SetObject((int)x_start, (int)y_start, _width, _height);
                        return true;
                    } 
                    else
                    {
                        x_start += _size_x;
                    }
                } while (check);
            }

            x_start = x;
            y_start += _size_y;
            return false;
        }

        private Bitmap DrawMapWithObject()
        {
            Bitmap bmp = new(_width, _height);

            if(_drawningObject == 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);
                    }
                }
            }

            _drawningObject.DrawningObject(gr);
            return bmp;
        }

        //сравнение
        public bool Equals(AbstractMap? other)
        {
            if (other == null || _map != other._map || _height != other._height || _width != other._width
                || _size_x != other._size_x || _size_y != other._size_y || GetType() != other.GetType()
                || _map.GetLength(0) != other._map.GetLength(0) || _map.GetLength(1) != other._map.GetLength(1))
            {
                return false;
            }

            for(int i = 0; i < _map.GetLength(0); i++)
            {
                for(int j = 0; j < _map.GetLength(1); j++)
                {
                    if (_map[i, j] != other._map[i, j])
                    {
                        return false;
                    }
                }
            }

            return true;
        }

        protected abstract void GenerateMap();
        protected abstract void DrawRoadPart(Graphics g, int i, int j);
        protected abstract void DrawBarrierPart(Graphics g, int i, int j);
    }
}