propagation-remastered/VsProject/PropagationRemasteredBeta/Human.cs

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

namespace PropagationRemasteredBeta
{
    public class Human : ICloneable
    {
        //State values
        /*
        public Color SAIN_COLOR = Color.Green;
        public Color INFECTED_COLOR = Color.Red;
        public Color IMMUNE_COLOR = Color.Blue;
        public Color DEATH_COLOR = Color.Black;
        
        public SolidBrush SAIN_COLOR = new SolidBrush(Color.Green);
        public SolidBrush INFECTED_COLOR = new SolidBrush(Color.Red);
        public SolidBrush IMMUNE_COLOR = new SolidBrush(Color.Blue);
        public SolidBrush DEATH_COLOR = new SolidBrush(Color.Black);
        */
        public SolidBrush SAIN_COLOR;
        public SolidBrush INFECTED_COLOR;
        public SolidBrush IMMUNE_COLOR;
        public SolidBrush DEATH_COLOR;

        public const int SAIN = 0;
        public const int INFECTED = 1;
        public const int IMMUNE = 2;
        public const int DEAD = 3;

        const int DEFAULT_HUMAN_SIZE = 1;

        private Point _position;
        private int _state;
        private Size _humanSize;
        private int _lifeTimeCounter;
        private int _InfectedTimeCounter;
        //private Color _sprite;
        private SolidBrush _sprite;

        public Point Position { get => _position; set => _position = value; }
        public int State
        {
            get { return _state; }
            //We set the counter of infection whenever we set it to infected
            set
            {
                _state = value;
                if (_state == INFECTED) { _InfectedTimeCounter = 1; }
                switch (_state)
                {
                    case INFECTED:
                        Sprite = INFECTED_COLOR;
                        break;
                    case SAIN:
                        Sprite = SAIN_COLOR;
                        break;
                    case DEAD:
                        Sprite = DEATH_COLOR;
                        break;
                    case IMMUNE:
                        Sprite = IMMUNE_COLOR;
                        break;
                }
            }
        }
        public Size HumanSize { get => _humanSize; set => _humanSize = value; }
        public int LifeTimeCounter { get => _lifeTimeCounter; set => _lifeTimeCounter = value; }
        public int InfectedTimeCounter { get => _InfectedTimeCounter; set => _InfectedTimeCounter = value; }
        //public Color Sprite { get => Sprite; set => Sprite = value; }
        public SolidBrush Sprite { get => _sprite; set => _sprite = value; }
        public Human(Point position, int state, Size humanSize, SolidBrush sainColor, SolidBrush infectedColor, SolidBrush immuneColor, SolidBrush deadColor)
        {
            HumanSize = humanSize;
            Position = position;
            
            LifeTimeCounter = 1;
            InfectedTimeCounter = 0;
            SAIN_COLOR = sainColor;
            INFECTED_COLOR = infectedColor;
            IMMUNE_COLOR = immuneColor;
            DEATH_COLOR = deadColor;

            //IMPORTANT only set state AFTER colors
            State = state;
        }

        public Human(Point position, int state, Size humanSize) : this(position,state,humanSize, new SolidBrush(Color.Green), new SolidBrush(Color.Red), new SolidBrush(Color.Blue), new SolidBrush(Color.Black))
        {
            
        }
        public Human(Point position, int state) : this(position, state, new Size(DEFAULT_HUMAN_SIZE, DEFAULT_HUMAN_SIZE))
        {

        }
        //we dont have any constructor with only default values because the human needs his position in the field to process the infection

        public void ChangeBaseColors(SolidBrush sainColor, SolidBrush infectedColor, SolidBrush immuneColor, SolidBrush deadColor)
        {
            SAIN_COLOR = sainColor;
            IMMUNE_COLOR = immuneColor;
            DEATH_COLOR = deadColor;
            INFECTED_COLOR = infectedColor;
        }

        public Human Propagate(Terrain T)
        {
            Human target;
            Point location;

            LifeTimeCounter++;

            if (this.State == INFECTED)
            {
                InfectedTimeCounter++;
                if (T.Rnd.Next(0, 100) <= T.DeathRate)
                {
                    State = DEAD;
                }
                if (LifeTimeCounter >= T.CureTime)
                {
                    State = IMMUNE;
                }
                else
                {
                    //we need to check if we are not in a corner 
                    if (Position.X > 0 && Position.Y > 0 && Position.X < (T.TerrainSize.Width - 1) && Position.Y < (T.TerrainSize.Height - 1))
                    {
                        //check top left
                        location = new Point(Position.X - 1, Position.Y + 1);
                        target = T.Population[location.X, location.Y];
                        if (target.State == Human.SAIN)
                        {
                            T.PeopleToCheck.Add(target);
                        }



                        //check top 
                        location = new Point(Position.X, Position.Y + 1);
                        target = T.Population[location.X, location.Y];

                        if (target.State == Human.SAIN)
                        {
                            T.PeopleToCheck.Add(target);
                        }

                        //check top left
                        location = new Point(Position.X + 1, Position.Y + 1);
                        target = T.Population[location.X, location.Y];

                        if (target.State == Human.SAIN)
                        {
                            T.PeopleToCheck.Add(target);
                        }

                        //check left
                        location = new Point(Position.X - 1, Position.Y);
                        target = T.Population[location.X, location.Y];

                        if (target.State == Human.SAIN)
                        {
                            T.PeopleToCheck.Add(target);
                        }

                        //check right
                        location = new Point(Position.X + 1, Position.Y);
                        target = T.Population[location.X, location.Y];

                        if (target.State == Human.SAIN)
                        {
                            T.PeopleToCheck.Add(target);
                        }

                        //check bottom left
                        location = new Point(Position.X - 1, Position.Y - 1);
                        target = T.Population[location.X, location.Y];

                        if (target.State == Human.SAIN)
                        {
                            T.PeopleToCheck.Add(target);
                        }

                        //check bottom 
                        location = new Point(Position.X, Position.Y - 1);
                        target = T.Population[location.X, location.Y];

                        if (target.State == Human.SAIN)
                        {
                            T.PeopleToCheck.Add(target);
                        }

                        //check bottom right
                        location = new Point(Position.X + 1, Position.Y - 1);
                        target = T.Population[location.X, location.Y];

                        if (target.State == Human.SAIN)
                        {
                            T.PeopleToCheck.Add(target);
                        }
                    }
                }
            }
            return this;
        }
        public Human CheckInfection(int infectiosity, Random rnd)
        {
            if (rnd.Next(0, 100) <= infectiosity)
            {
                State = INFECTED;
            }
            return this;
        }

        public object Clone()
        {
            Human newHuman = new Human(Position, State);
            newHuman.HumanSize = HumanSize;
            newHuman.InfectedTimeCounter = InfectedTimeCounter;
            newHuman.LifeTimeCounter = LifeTimeCounter;
            return newHuman;
        }
    }
}