Exemple #1
0
 public Wezel()
 {
     dzieci = new List<Wezel>();
     wspolrzedne = new Wspolrzedne(-1, -1);
     nalezyDoRozwiazania = false;
     waga = 0;
     sprawdzony = false;
 }
Exemple #2
0
        public List<Wspolrzedne> obliczSciezke(Wspolrzedne _poczatek, Wspolrzedne _koniec, int[,] _mapa)
        {
            int[,] mapaTmp = mapa;
            mapa = _mapa;

            List<Wspolrzedne> wynik = obliczSciezke(_poczatek, _koniec);

            mapa = mapaTmp;
            return wynik;
        }
Exemple #3
0
        public List<Wspolrzedne> obliczSciezke(Wspolrzedne _poczatek, Wspolrzedne _koniec)
        {
            _poczatek.X = _poczatek.X / SKALA;
            _poczatek.Y = _poczatek.Y / SKALA;

            _koniec.X = _koniec.X / SKALA;
            _koniec.Y = _koniec.Y / SKALA;

            if
            (
                (mapa[_koniec.X, _koniec.Y] == 1)
                ||
                (
                    (_poczatek.X == _koniec.X)
                    &&
                    (_poczatek.Y == _koniec.Y)
                )
            )
            {
                return new List<Wspolrzedne>();
            }

            sciezkaPrzeszukiwana = new List<Wezel>();

            Wezel obecny = new Wezel();
            obecny.Wspolrzedne.X = _poczatek.X;
            obecny.Wspolrzedne.Y = _poczatek.Y;
            obecny.Waga = kosztSciezki(obecny) + funkcjaHeurystyczna(_poczatek, _koniec);

            sciezkaPrzeszukiwana.Add(obecny);

            bool liczDalej = true;//liczDalej = !obliczDzieci(obecny, _koniec);
            bool cofa = false;

            while (liczDalej)
            {
                if (obecny.Sprawdzony)
                {
                    obecny = obecny.Ojciec;

                    if (obecny == null)
                    {
                        Console.WriteLine("Nie znaleziono drogi.");

                        return new List<Wspolrzedne>();
                    }

                    cofa = true;
                }
                else
                {
                    if ((!cofa) && (obecny.Dzieci.Count == 0))
                    {
                        liczDalej = !obliczDzieci(obecny, _koniec);
                    }

                    cofa = false;

                    int iloscDzieciSprawdzonych = 0;

                    for (int dziecko = 0; dziecko < obecny.Dzieci.Count; ++dziecko)
                    {
                        if (obecny.Dzieci[dziecko].Sprawdzony)
                        {
                            ++iloscDzieciSprawdzonych;
                        }
                    }

                    int idNajlepszegoWezla = 0;

                    for (int najlepszy = 0; najlepszy < sciezkaPrzeszukiwana.Count; ++najlepszy)
                    {
                        if
                        (
                            (
                                (sciezkaPrzeszukiwana[idNajlepszegoWezla].Wspolrzedne.X != sciezkaPrzeszukiwana[najlepszy].Wspolrzedne.X)
                                ||
                                (sciezkaPrzeszukiwana[idNajlepszegoWezla].Wspolrzedne.Y != sciezkaPrzeszukiwana[najlepszy].Wspolrzedne.Y)
                            )
                            &&
                            (
                                !sciezkaPrzeszukiwana[najlepszy].Sprawdzony
                            )
                        )
                        {
                            idNajlepszegoWezla = najlepszy;
                            break;
                        }
                    }

                    for (int najlepszy = 0; najlepszy < sciezkaPrzeszukiwana.Count; ++najlepszy)
                    {
                        if (
                            (
                                (sciezkaPrzeszukiwana[idNajlepszegoWezla].Wspolrzedne.X != sciezkaPrzeszukiwana[najlepszy].Wspolrzedne.X)
                                ||
                                (sciezkaPrzeszukiwana[idNajlepszegoWezla].Wspolrzedne.Y != sciezkaPrzeszukiwana[najlepszy].Wspolrzedne.Y)
                            )
                            &&
                            (
                                !sciezkaPrzeszukiwana[najlepszy].Sprawdzony
                            )
                            &&
                            (
                                sciezkaPrzeszukiwana[idNajlepszegoWezla].Waga > sciezkaPrzeszukiwana[najlepszy].Waga
                            )
                           )
                        {
                            idNajlepszegoWezla = najlepszy;
                        }
                    }

                    obecny = sciezkaPrzeszukiwana[idNajlepszegoWezla];
                }
            };

            sciezka = new List<Wspolrzedne>();

            for (int wezel = 0; wezel < sciezkaPrzeszukiwana.Count; ++wezel)
            {
                if (sciezkaPrzeszukiwana[wezel].NalezyDoRozwiazania)
                {
                    sciezka.Add(new Wspolrzedne(sciezkaPrzeszukiwana[wezel].Wspolrzedne.X * SKALA, sciezkaPrzeszukiwana[wezel].Wspolrzedne.Y * SKALA));
                }
            }

            return sciezka;
        }
Exemple #4
0
 private KOLEJNOSC obliczRuch(Wspolrzedne _poczatek, Wspolrzedne _koniec)
 {
     if ((_koniec.Y < _poczatek.Y) && (_koniec.X == _poczatek.X))
     {
         return KOLEJNOSC.GORA;
     }
     else if ((_koniec.Y < _poczatek.Y) && (_koniec.X > _poczatek.X))
     {
         return KOLEJNOSC.GORA_PRAWO;
     }
     else if ((_koniec.X > _poczatek.X) && (_koniec.Y == _poczatek.Y))
     {
         return KOLEJNOSC.PRAWO;
     }
     else if ((_koniec.X > _poczatek.X) && (_koniec.Y > _poczatek.Y))
     {
         return KOLEJNOSC.DOL_PRAWO;
     }
     else if ((_koniec.Y > _poczatek.Y) && (_koniec.X == _poczatek.X))
     {
         return KOLEJNOSC.DOL;
     }
     else if ((_koniec.Y > _poczatek.Y) && (_koniec.X < _poczatek.X))
     {
         return KOLEJNOSC.DOL_LEWO;
     }
     else if ((_koniec.X < _poczatek.X) && (_koniec.Y == _poczatek.Y))
     {
         return KOLEJNOSC.LEWO;
     }
     else
     {
         return KOLEJNOSC.GORA_LEWO;
     }
 }
Exemple #5
0
        private bool obliczDzieci(Wezel _obecny, Wspolrzedne _warunekStopu)
        {
            _obecny.Sprawdzony = true;

            for (int _kolejny = 0; _kolejny < 8; ++_kolejny)
            {
                //Pominięcie drogi, którą się przyszło.
                if ((_obecny.Ojciec != null) && ((KOLEJNOSC)_kolejny == odwrocRuch(_obecny.OstatniRuch)))
                {
                    continue;
                }

                // Jeśli ruch w daną stronę natrafia na ścianę.
                if (czySciana(_obecny.Wspolrzedne, (KOLEJNOSC)_kolejny))
                {
                    continue;
                }

                Wezel nowy = new Wezel();

                switch ((KOLEJNOSC)_kolejny)
                {
                    case KOLEJNOSC.GORA:
                        nowy.Wspolrzedne.Y = _obecny.Wspolrzedne.Y - 1;
                        nowy.Wspolrzedne.X = _obecny.Wspolrzedne.X;
                        break;
                    case KOLEJNOSC.GORA_PRAWO:
                        nowy.Wspolrzedne.Y = _obecny.Wspolrzedne.Y - 1;
                        nowy.Wspolrzedne.X = _obecny.Wspolrzedne.X + 1;
                        break;
                    case KOLEJNOSC.PRAWO:
                        nowy.Wspolrzedne.Y = _obecny.Wspolrzedne.Y;
                        nowy.Wspolrzedne.X = _obecny.Wspolrzedne.X + 1;
                        break;
                    case KOLEJNOSC.DOL_PRAWO:
                        nowy.Wspolrzedne.Y = _obecny.Wspolrzedne.Y + 1;
                        nowy.Wspolrzedne.X = _obecny.Wspolrzedne.X + 1;
                        break;
                    case KOLEJNOSC.DOL:
                        nowy.Wspolrzedne.Y = _obecny.Wspolrzedne.Y + 1;
                        nowy.Wspolrzedne.X = _obecny.Wspolrzedne.X;
                        break;
                    case KOLEJNOSC.DOL_LEWO:
                        nowy.Wspolrzedne.Y = _obecny.Wspolrzedne.Y + 1;
                        nowy.Wspolrzedne.X = _obecny.Wspolrzedne.X - 1;
                        break;
                    case KOLEJNOSC.LEWO:
                        nowy.Wspolrzedne.Y = _obecny.Wspolrzedne.Y;
                        nowy.Wspolrzedne.X = _obecny.Wspolrzedne.X - 1;
                        break;
                    case KOLEJNOSC.GORA_LEWO:
                        nowy.Wspolrzedne.Y = _obecny.Wspolrzedne.Y - 1;
                        nowy.Wspolrzedne.X = _obecny.Wspolrzedne.X - 1;
                        break;
                }

                // Jeśli nie powiodło się obliczenie współrzędnych nowego węzła.
                if ((nowy.Wspolrzedne.X == -1) || (nowy.Wspolrzedne.Y == -1))
                {
                    continue;
                }

                nowy.Waga = kosztSciezki(_obecny) + funkcjaHeurystyczna(_obecny.Wspolrzedne, _warunekStopu);
                nowy.OstatniRuch = obliczRuch(_obecny.Wspolrzedne, nowy.Wspolrzedne);

                if (wezelJuzIstnieje(nowy))
                {
                    //Połączenie węzłów ojca i dziecka.
                    _obecny.Dzieci.Add(nowy);
                    nowy.Ojciec = _obecny;

                    sciezkaPrzeszukiwana.Add(nowy);
                }

                // Sprawdzenie, czy nie odnaleziono rozwiązania.
                if ((nowy.Wspolrzedne.X == _warunekStopu.X) && (nowy.Wspolrzedne.Y == _warunekStopu.Y))
                {
                    Wezel licznikSciezki = nowy;

                    while (licznikSciezki.Ojciec != null)
                    {
                        licznikSciezki.NalezyDoRozwiazania = true;
                        licznikSciezki = licznikSciezki.Ojciec;
                    }

                    return true;
                }
            }

            return false;
        }
Exemple #6
0
 private double funkcjaHeurystyczna(Wspolrzedne _obecny, Wspolrzedne _koniec)
 {
     return Math.Abs(_obecny.X - _koniec.X) + Math.Abs(_obecny.Y - _koniec.Y);
 }
Exemple #7
0
        private bool czySciana(Wspolrzedne _obecny, KOLEJNOSC _ruch)
        {
            switch (_ruch)
            {
                case KOLEJNOSC.GORA:
                    return !((_obecny.Y - 1 >= 0) && (mapa[_obecny.X, _obecny.Y - 1] == 0));
                case KOLEJNOSC.GORA_PRAWO:
                    return !((_obecny.Y - 1 >= 0) && (_obecny.X + 1 < wymiarX / SKALA) && (mapa[_obecny.X + 1, _obecny.Y - 1] == 0));
                case KOLEJNOSC.PRAWO:
                    return !((_obecny.X + 1 < wymiarX / SKALA) && (mapa[_obecny.X + 1, _obecny.Y] == 0));
                case KOLEJNOSC.DOL_PRAWO:
                    return !((_obecny.Y + 1 < wymiarY / SKALA) && (_obecny.X + 1 < wymiarX / SKALA) && (mapa[_obecny.X + 1, _obecny.Y + 1] == 0));
                case KOLEJNOSC.DOL:
                    return !((_obecny.Y + 1 < wymiarY / SKALA) && (mapa[_obecny.X, _obecny.Y + 1] == 0));
                case KOLEJNOSC.DOL_LEWO:
                    return !((_obecny.Y + 1 < wymiarY / SKALA) && (_obecny.X - 1 >= 0) && (mapa[_obecny.X - 1, _obecny.Y + 1] == 0));
                case KOLEJNOSC.LEWO:
                    return !((_obecny.X - 1 >= 0) && (mapa[_obecny.X + 1, _obecny.Y] == 0));
                case KOLEJNOSC.GORA_LEWO:
                    return !((_obecny.Y - 1 >= 0) && (_obecny.X - 1 >= 0) && (mapa[_obecny.X - 1, _obecny.Y + 1] == 0));
            }

            return false;
        }
Exemple #8
0
        public override void HandleEvent(GameTime gameTime)
        {
            EventManager.FindMessagesByDestination(this, messages);
            FindDoubledMessages();

            //for (int i = 0; i < 0; i++)
            if (messages.Count > 0)
            {
                int i = 0;
                if (!messages[i].Done)
                    switch (messages[i].Type)
                    {
                        #region HandleEvent.Selected/Unselected
                        case (int)EventManager.Events.Selected:
                            selected = true;
                            messages[i].Done = true;
                            GUIEventManager.CreateMessage(new Message((int)GUIEventManager.Events.GuiUP, this, null, null));
                            break;

                        case (int)EventManager.Events.Unselected:
                            selected = false;
                            messages[i].Done = true;
                            GUIEventManager.CreateMessage(new Message((int)GUIEventManager.Events.GuiDOWN, this, null, null));
                            break;
                        #endregion

                        #region HandleEvent.Interaction
                        case (int)EventManager.Events.Interaction:

                            Console.WriteLine("Jednostka - interakcja z" + messages[i].Destination.ToString());
                            EventManager.CreateMessage(new Message((int)EventManager.Events.Interaction, this, messages[i].Payload, null));
                            messages[i].Done = true;
                            break;
                        #endregion

                        #region HandleEvent.MoveUnit
                        case (int)EventManager.Events.MoveUnit:

                            //////nowa wersja////////
                            if (destinyPoints == null)
                            {
                                setWalk();
                                Laikos.PathFiding.Wspolrzedne wspBegin = new Laikos.PathFiding.Wspolrzedne((int)this.Position.X, (int)this.Position.Z);
                                Laikos.PathFiding.Wspolrzedne wspEnd = new Laikos.PathFiding.Wspolrzedne((int)((Vector3)messages[i].Payload).X, (int)(((Vector3)messages[i].Payload).Z));
                                // Console.WriteLine("A: " + wspBegin.X + ", " + wspBegin.Y + ", " + Map.WalkMeshMap[wspBegin.X / Map.SKALA, wspBegin.Y / Map.SKALA]
                                //  + " B: " + wspEnd.X + ", " + wspEnd.Y + ", " + Map.WalkMeshMap[wspEnd.X / Map.SKALA, wspEnd.Y / Map.SKALA]);
                                this.destinyPoints = this.pathFiding.obliczSciezke(wspBegin, wspEnd);
                                this.destinyPointer = null;
                            }
                            /////////nowa wersja///////////

                            if (destinyPoints.Count > 0)
                            {
                                if ((destinyPoints != null) && (destinyPoints.Count > 0) && (destinyPointer == null))
                                {
                                    destinyPointer = destinyPoints.GetEnumerator();
                                    destinyPointer.MoveNext();
                                    Vector3 vecTmp = new Vector3(destinyPointer.Current.X, 0.0f, destinyPointer.Current.Y);
                                    direction = vecTmp - Position;
                                }

                                if
                                (
                                    (!Double.IsNaN(direction.X)) &&
                                    (!Double.IsNaN(direction.Y)) &&
                                    (!Double.IsNaN(direction.Z))
                                )
                                {
                                    direction.Normalize();

                                    PositionOld = Position;

                                    Position.X += direction.X * (float)gameTime.ElapsedGameTime.TotalMilliseconds / 50.0f;
                                    Position.Z += direction.Z * (float)gameTime.ElapsedGameTime.TotalMilliseconds / 50.0f;

                                    ChangeDirection();

                                }

                                if ((destinyPointer != null) && (Math.Abs(Position.X - destinyPointer.Current.X) < 0.5f) && (Math.Abs(Position.Z - destinyPointer.Current.Y) < 0.5f))
                                {
                                    // Next step walk.
                                    if (!destinyPointer.MoveNext())
                                    {
                                        EndMove(messages[i]);

                                        setIdle();
                                       // Console.WriteLine("done");
                                    }
                                    else
                                    {
                                        Vector3 vecTmp = new Vector3(destinyPointer.Current.X, 0.0f, destinyPointer.Current.Y);
                                        direction = vecTmp - Position;
                                    }
                                }
                            }
                            else
                            {
                                messages[i].Done = true;
                            }

                            foreach (Message _msg in messages)
                            {
                                if
                                (
                                    (!_msg.Done)
                                    &&
                                    (_msg.Type == (int)EventManager.Events.FixCollisions)
                                )
                                {
                                    _msg.Done = true;
                                }
                            }

                            break;
                        #endregion

                        #region HandleEvent.MoveToBuild
                        case (int)EventManager.Events.MoveToBuild:

                            if (EventManager.MessageToOld(gameTime, messages[i], 4000))
                            {
                                messages[i].Done = true;
                                break;
                            }
                            if (budowniczy == true)
                            {
                                //////nowa wersja////////
                                if (destinyPoints == null)
                                {
                                   /* Vector3 stay_here = new Vector3(((WhereToBuild)messages[i].Payload).position.X, ((WhereToBuild)messages[i].Payload).position.Y, ((WhereToBuild)messages[i].Payload).position.Z);
                                    Building temp = new Building(game, player, ((WhereToBuild)messages[i].Payload).building.type, Vector3.Zero, ((WhereToBuild)messages[i].Payload).building.type.Scale, false);

                                    if (MathUtils.RandomNumber(1, 2) == 1) //czy x czy Z
                                    {
                                        if (MathUtils.RandomNumber(1, 2) == 1) // czy + czy -
                                            stay_here.X += BoundingSphere.CreateFromBoundingBox(temp.boundingBox).Radius / 4 * 3;

                                        else
                                            stay_here.X -= BoundingSphere.CreateFromBoundingBox(temp.boundingBox).Radius / 4 * 3;

                                        stay_here.Z = MathUtils.RandomNumber((int)(stay_here.Z - BoundingSphere.CreateFromBoundingBox(temp.boundingBox).Radius / 4 * 3),
                                            (int)(stay_here.Z + BoundingSphere.CreateFromBoundingBox(temp.boundingBox).Radius / 4 * 3));

                                    }
                                    else
                                    {
                                        if (MathUtils.RandomNumber(1, 2) == 1) // czy + czy -
                                            stay_here.Z += BoundingSphere.CreateFromBoundingBox(temp.boundingBox).Radius / 4 * 3;
                                        else
                                            stay_here.Z -= BoundingSphere.CreateFromBoundingBox(temp.boundingBox).Radius / 4 * 3;

                                        stay_here.X = MathUtils.RandomNumber((int)(stay_here.X - BoundingSphere.CreateFromBoundingBox(temp.boundingBox).Radius / 4 * 3),
                                            (int)(stay_here.X + BoundingSphere.CreateFromBoundingBox(temp.boundingBox).Radius / 4 * 3));
                                    }*/

                                    setWalk();
                                    Laikos.PathFiding.Wspolrzedne wspBegin = new Laikos.PathFiding.Wspolrzedne((int)this.Position.X, (int)this.Position.Z);
                                     Laikos.PathFiding.Wspolrzedne wspEnd = new Laikos.PathFiding.Wspolrzedne((int)((WhereToBuild)messages[i].Payload).position.X, (int)(((WhereToBuild)messages[i].Payload).position.Z));
                                    //Laikos.PathFiding.Wspolrzedne wspEnd = new Laikos.PathFiding.Wspolrzedne((int)stay_here.X, (int)stay_here.Z);

                                    this.destinyPoints = this.pathFiding.obliczSciezke(wspBegin, wspEnd);
                                    this.destinyPointer = null;
                                }
                                /////////nowa wersja///////////
                                if (destinyPoints.Count > 0)
                                {

                                    if ((destinyPoints != null) && (destinyPoints.Count > 0) && (destinyPointer == null))
                                    {
                                        destinyPointer = destinyPoints.GetEnumerator();
                                        destinyPointer.MoveNext();
                                        Vector3 vecTmp = new Vector3(destinyPointer.Current.X, 0.0f, destinyPointer.Current.Y);
                                        direction = vecTmp - Position;
                                    }

                                    if
                                    (
                                        (!Double.IsNaN(direction.X)) &&
                                        (!Double.IsNaN(direction.Y)) &&
                                        (!Double.IsNaN(direction.Z))
                                    )
                                    {
                                        direction.Normalize();

                                        PositionOld = Position;

                                        Position.X += direction.X * (float)gameTime.ElapsedGameTime.TotalMilliseconds / 50.0f;
                                        Position.Z += direction.Z * (float)gameTime.ElapsedGameTime.TotalMilliseconds / 50.0f;

                                        ChangeDirection();
                                    }

                                    if ((destinyPointer != null) && (Math.Abs(Position.X - destinyPointer.Current.X) < 12.0f) && (Math.Abs(Position.Z - destinyPointer.Current.Y) < 12.0f))
                                    {
                                        // Next step walk.

                                        if (!destinyPointer.MoveNext())
                                        {
                                            destinyPoints = null;
                                            destinyPointer = null;

                                            direction.X = 0.0f;
                                            direction.Z = 0.0f;

                                            messages[i].Done = true;
                                            EventManager.CreateMessage(new Message((int)EventManager.Events.Build, this, this, messages[i].Payload));

                                            timeSpan = TimeSpan.FromMilliseconds(((WhereToBuild)messages[i].Payload).building.buildtime);
                                            setAttack();
                                        }
                                        else
                                        {
                                            Vector3 vecTmp = new Vector3(destinyPointer.Current.X, 0.0f, destinyPointer.Current.Y);
                                            direction = vecTmp - Position;
                                        }
                                    }
                                }
                                else
                                {
                                    messages[i].Done = true;
                                }
                            }
                            messages[i].timer = gameTime.TotalGameTime;
                            break;
                        #endregion

                        #region HandleEvent.Build
                        case (int)EventManager.Events.Build:
                            if (EventManager.MessageToOld(gameTime, messages[i], 100))
                            {
                                messages[i].Done = true;
                                break;
                            }
                            if (budowniczy == true)
                            {
                                timeSpan -= gameTime.ElapsedGameTime;
                                if (timeSpan < TimeSpan.Zero)
                                {
                                    player.Build(((WhereToBuild)messages[i].Payload).building.type, ((WhereToBuild)messages[i].Payload).position);
                                    messages[i].Done = true;
                                    setIdle();
                                }
                            }
                            messages[i].timer = gameTime.TotalGameTime;
                            break;
                        #endregion

                        #region HandleEvent.Gathering
                        case (int)EventManager.Events.Gather:
                            ///////BREAK MESSAGE
                            if (EventManager.MessageToOld(gameTime, messages[i], 3000))
                            {
                                messages[i].Done = true;

                                break;
                            }
                            /////////////////////

                            if (budowniczy == true)
                            {
                                //////////MOVE
                                if (destinyPoints == null)
                                {
                                    setWalk();
                                    Laikos.PathFiding.Wspolrzedne wspBegin = new Laikos.PathFiding.Wspolrzedne((int)this.Position.X, (int)this.Position.Z);
                                    Laikos.PathFiding.Wspolrzedne wspEnd = new Laikos.PathFiding.Wspolrzedne((int)((Building)messages[i].Sender).Position.X, (int)((Building)messages[i].Sender).Position.Z);
                                    this.destinyPoints = this.pathFiding.obliczSciezke(wspBegin, wspEnd);
                                    this.destinyPointer = null;
                                }
                                if (this.destinyPoints.Count > 0)
                                {
                                    if ((destinyPoints != null) && (destinyPoints.Count > 0) && (destinyPointer == null))
                                    {
                                        destinyPointer = destinyPoints.GetEnumerator();
                                        destinyPointer.MoveNext();
                                        Vector3 vecTmp = new Vector3(destinyPointer.Current.X, 0.0f, destinyPointer.Current.Y);
                                        direction = vecTmp - Position;
                                    }

                                    direction.Normalize();

                                    PositionOld = Position;

                                    Position.X += direction.X * (float)gameTime.ElapsedGameTime.TotalMilliseconds / 50.0f;
                                    Position.Z += direction.Z * (float)gameTime.ElapsedGameTime.TotalMilliseconds / 50.0f;

                                    ChangeDirection();

                                    if ((destinyPointer != null) && (Math.Abs(Position.X - destinyPointer.Current.X) < 0.5f) && (Math.Abs(Position.Z - destinyPointer.Current.Y) < 0.5f))
                                    {

                                        //JESTES U CELU
                                        if (!destinyPointer.MoveNext())
                                        {

                                            destinyPoints = null;
                                            destinyPointer = null;
                                            direction.X = 0.0f;
                                            direction.Z = 0.0f;
                                            setAttack();

                                            //OBSŁUGA ZBIERANIA
                                            timeSpan -= gameTime.ElapsedGameTime;
                                            if (((Building)messages[i].Sender).Souls > 0) //czy budynek ma narobione dusze
                                            {
                                                if (this.Souls_owned < Souls_cap) //czy mamy miejsce
                                                {

                                                    //if (timeSpan < TimeSpan.Zero) //jesli czas pakowania minal dodajemy dusze
                                                    //{
                                                        if (Souls_cap - this.Souls_owned >= ((Building)messages[i].Sender).Souls) //ilosc miejsca wieksza niz ilosc dusz w budynku
                                                        {
                                                            this.Souls_owned += ((Building)messages[i].Sender).Souls; //dodajemy wszystkie dusze z budynku
                                                            ((Building)messages[i].Sender).Souls = 0;
                                                        }
                                                        else //ilosc miejsca mniejsza niz ilosc dusz w budynku
                                                        {
                                                            ((Building)messages[i].Sender).Souls -= Souls_cap - this.Souls_owned; //dobieramy tyle ile sie da
                                                            this.Souls_owned += Souls_cap - this.Souls_owned;
                                                        }
                                                        foreach (Building building in player.BuildingList)
                                                        {
                                                            if (building.type.Name.Contains("Pałac rady")) //odsylamy do skladowania
                                                            {
                                                                EventManager.CreateMessage(new Message((int)EventManager.Events.Store, messages[i].Sender, this, building));
                                                                messages[i].Done = true;
                                                                break;
                                                            }
                                                        }
                                                    //}
                                                }
                                                else //jak nie mamy miejsca to odnosimy
                                                {

                                                    foreach (Building building in player.BuildingList)
                                                    {
                                                        if (building.type.Name.Contains("Pałac rady")) //odsylamy do skladowania
                                                        {
                                                            setWalk();
                                                            EventManager.CreateMessage(new Message((int)EventManager.Events.Store, this, this, building));
                                                            messages[i].Done = true;
                                                            break;
                                                        }
                                                    }
                                                }
                                            }
                                            else //jak nie ma dusz to koniec zadania
                                            {
                                                messages[i].Done = true;
                                                break;
                                            }
                                        }
                                        else
                                        {
                                            Vector3 vecTmp = new Vector3(destinyPointer.Current.X, 0.0f, destinyPointer.Current.Y);
                                            direction = vecTmp - Position;
                                        }
                                    }
                                    setWalk();
                                }
                                else
                                {
                                    messages[i].Done = true;
                                }
                            }
                            messages[i].timer = gameTime.TotalGameTime;
                            break;
                        #endregion

                        #region HandleEvent.Storing
                        case (int)EventManager.Events.Store:
                            ///////BREAK MESSAGE
                            if (EventManager.MessageToOld(gameTime, messages[i], 3000))
                            {
                                messages[i].Done = true;
                                break;
                            }
                            /////////////////////

                            if (budowniczy == true)
                            {
                                //////////MOVE
                                if (destinyPoints == null)
                                {

                                    setWalk();
                                    Laikos.PathFiding.Wspolrzedne wspBegin = new Laikos.PathFiding.Wspolrzedne((int)this.Position.X, (int)this.Position.Z);
                                    Laikos.PathFiding.Wspolrzedne wspEnd = new Laikos.PathFiding.Wspolrzedne((int)((Building)messages[i].Payload).Position.X, (int)((Building)messages[i].Payload).Position.Z);

                                    this.destinyPoints = this.pathFiding.obliczSciezke(wspBegin, wspEnd);
                                    this.destinyPointer = null;
                                }
                                if (this.destinyPoints.Count > 0)
                                {
                                    if ((destinyPoints != null) && (destinyPoints.Count > 0) && (destinyPointer == null))
                                    {
                                        destinyPointer = destinyPoints.GetEnumerator();
                                        destinyPointer.MoveNext();
                                        Vector3 vecTmp = new Vector3(destinyPointer.Current.X, 0.0f, destinyPointer.Current.Y);
                                        direction = vecTmp - Position;
                                    }

                                    PositionOld = Position;

                                    Position.X += direction.X * (float)gameTime.ElapsedGameTime.TotalMilliseconds / 50.0f;
                                    Position.Z += direction.Z * (float)gameTime.ElapsedGameTime.TotalMilliseconds / 50.0f;

                                  //  ChangeDirection();

                                    if ((destinyPointer != null) && (Math.Abs(Position.X - destinyPointer.Current.X) < 0.5f) && (Math.Abs(Position.Z - destinyPointer.Current.Y) < 0.5f))
                                    {
                                        // Next step walk.
                                        if (!destinyPointer.MoveNext())
                                        {
                                            EndMove(messages[i]);

                                            player.Souls += this.Souls_owned;
                                            this.Souls_owned = 0;
                                            setWalk();
                                            EventManager.CreateMessage(new Message((int)EventManager.Events.Gather, messages[i].Sender, this, null));

                                            timeSpan = TimeSpan.FromMilliseconds(3000);
                                            //Console.WriteLine("done");
                                        }
                                        else
                                        {
                                            Vector3 vecTmp = new Vector3(destinyPointer.Current.X, 0.0f, destinyPointer.Current.Y);
                                            direction = vecTmp - Position;
                                        }
                                    }

                                    setWalk();
                                }
                                else
                                {
                                    messages[i].Done = true;
                                }
                            }
                            messages[i].timer = gameTime.TotalGameTime;
                            break;
                        #endregion

                        #region Move To Attack
                        case (int)EventManager.Events.MoveToAttack:

                            if (range <= 0)
                            {
                                messages[i].Done = true;
                                break;
                            }

                            GameObject targetMoveAttack = (GameObject)messages[i].Payload;

                            if (destinyPoints == null)
                            {
                                setWalk();
                                Laikos.PathFiding.Wspolrzedne wspBegin = new Laikos.PathFiding.Wspolrzedne((int)this.Position.X, (int)this.Position.Z);
                                Laikos.PathFiding.Wspolrzedne wspEnd = new Laikos.PathFiding.Wspolrzedne((int)(targetMoveAttack.Position.X), (int)(targetMoveAttack.Position.Z));

                                this.destinyPoints = this.pathFiding.obliczSciezke(wspBegin, wspEnd);
                                this.destinyPointer = null;
                            }

                            if (messages[i].Payload is Unit)
                            {
                                destinyUnit = (Unit)messages[i].Payload;
                                destinyBuilding = null;
                            }
                            else if (messages[i].Payload is Building)
                            {
                                destinyUnit = null;
                                destinyBuilding = (Building)messages[i].Payload;
                            }

                            if ((destinyPoints != null) && (destinyPoints.Count > 0))
                            {
                                if
                                (
                                    (
                                        (destinyUnit != null)
                                        &&
                                        (Math.Abs(Position.X - destinyUnit.Position.X) < range)
                                    )
                                    ||
                                    (
                                        (destinyBuilding != null)
                                        &&
                                        (Math.Abs(Position.Z - destinyBuilding.Position.Z) < range)
                                    )
                                )
                                {
                                    EndMove(messages[i]);

                                    setAttack();
                                    EventManager.CreateMessage(new Message((int)EventManager.Events.Attack, null, this, messages[i].Payload));
                                    break;
                                }

                                if ((destinyPointer == null) && (destinyPoints != null) && (destinyPoints.Count > 0))
                                {
                                    destinyPointer = destinyPoints.GetEnumerator();
                                    destinyPointer.MoveNext();
                                    Vector3 vecTmp = new Vector3(destinyPointer.Current.X, 0.0f, destinyPointer.Current.Y);
                                    direction = vecTmp - Position;
                                }

                                if
                                (
                                    (!Double.IsNaN(direction.X)) &&
                                    (!Double.IsNaN(direction.Y)) &&
                                    (!Double.IsNaN(direction.Z))
                                )
                                {
                                    direction.Normalize();

                                    PositionOld = Position;

                                    Position.X += direction.X * (float)gameTime.ElapsedGameTime.TotalMilliseconds / 50.0f;
                                    Position.Z += direction.Z * (float)gameTime.ElapsedGameTime.TotalMilliseconds / 50.0f;

                                    ChangeDirection();
                                }

                                if
                                (
                                    (destinyPointer != null) &&
                                    (Math.Abs(Position.X - destinyPointer.Current.X) < 0.5f) &&
                                    (Math.Abs(Position.Z - destinyPointer.Current.Y) < 0.5f)
                                )
                                {
                                    // Next step walk.
                                    if (!destinyPointer.MoveNext())
                                    {
                                        EndMove(messages[i]);

                                        setIdle();
                                        //Console.WriteLine("done");
                                    }
                                    else
                                    {
                                        Vector3 vecTmp = new Vector3(destinyPointer.Current.X, 0.0f, destinyPointer.Current.Y);
                                        direction = vecTmp - Position;
                                    }
                                }
                            }
                            else
                            {
                                EndMove(messages[i]);
                            }
                            break;
                        #endregion Move To Attack

                        #region Attack
                        case (int)EventManager.Events.Attack:

                            if (range <= 0)
                            {
                                messages[i].Done = true;
                                break;
                            }

                            if (messages[i].Payload is Unit)
                            {
                                destinyUnit = (Unit)messages[i].Payload;
                                destinyBuilding = null;
                            }
                            else if (messages[i].Payload is Building)
                            {
                                destinyUnit = null;
                                destinyBuilding = (Building)messages[i].Payload;
                            }

                            if
                            (
                                    (
                                        (destinyUnit != null)
                                        &&
                                        (Math.Abs(Position.X - destinyUnit.Position.X) < range)
                                    )
                                    ||
                                    (
                                        (destinyBuilding != null)
                                        &&
                                        (Math.Abs(Position.Z - destinyBuilding.Position.Z) < range)
                                    )
                                )
                            {

                                if (EventManager.MessageToOld(gameTime, messages[i], ratio))
                                {
                                    if ((GameObject)messages[i].Payload is Unit)
                                    {
                                        ((Unit)messages[i].Payload).HP -= damage;

                                        if (((Unit)messages[i].Payload).dead)
                                        {
                                            messages[i].Done = true;
                                            setIdle();
                                            break;
                                        }
                                    }
                                    else if ((GameObject)messages[i].Payload is Building)
                                    {
                                        ((Building)messages[i].Payload).HP -= damage;

                                        if (((Building)messages[i].Payload).dead)
                                        {
                                            messages[i].Done = true;
                                            setIdle();
                                            break;
                                        }
                                    }

                                    messages[i].timer = gameTime.TotalGameTime;
                                    Game1.sounds[0].Play(1.0f, 0.0f, 0.0f);
                                    //Console.WriteLine("Attack!");
                                }

                                if (messages[i].timer == TimeSpan.Zero)
                                {
                                    messages[i].timer = gameTime.TotalGameTime;
                                }
                            }
                            else
                            {
                                messages[i].Done = true;
                                setIdle();

                                if (messages[i].Payload is Unit)
                                {
                                    EventManager.CreateMessage(new Message((int)EventManager.Events.MoveToAttack, null, this, destinyUnit));
                                }
                                else if (messages[i].Payload is Building)
                                {
                                    EventManager.CreateMessage(new Message((int)EventManager.Events.MoveToAttack, null, this, destinyBuilding));
                                }
                            }

                            break;
                        #endregion Attack

                        #region FixCollisions
                        case (int)EventManager.Events.FixCollisions:

                            if (EventManager.MessageToOld(gameTime, messages[i], 5000))
                            {
                                messages[i].Done = true;
                                break;
                            }

                            foreach (Message _msg in messages)
                            {
                                if (!_msg.Done)
                                {
                                    switch (_msg.Type)
                                    {
                                        case (int)EventManager.Events.MoveUnit:
                                        case (int)EventManager.Events.MoveToAttack:
                                        case (int)EventManager.Events.MoveToBuild:

                                            Unit sen = ((Unit)messages[i].Sender);

                                            if ((destinyPoints != null) && (destinyPoints.Count > 0))
                                            {
                                                if
                                                (
                                                    (sen.Position.X - destinyPoints[destinyPoints.Count - 1].X < 5.0f)
                                                    &&
                                                    (sen.Position.Z - destinyPoints[destinyPoints.Count - 1].Y < 5.0f)
                                                )
                                                {
                                                    messages[i].Done = true;

                                                    EndMove(_msg);

                                                    break;
                                                }

                                                int[,] map = Map.WalkMeshMap;

                                                map[(int)sen.Position.X / Map.SKALA, (int)sen.Position.Z / Map.SKALA] = 1;

                                                Laikos.PathFiding.Wspolrzedne wspBegin = new Laikos.PathFiding.Wspolrzedne((int)this.Position.X, (int)this.Position.Z);
                                                Laikos.PathFiding.Wspolrzedne wspEnd = new Laikos.PathFiding.Wspolrzedne(destinyPoints[destinyPoints.Count - 1].X, destinyPoints[destinyPoints.Count - 1].Y);

                                                destinyPoints = pathFiding.obliczSciezke(wspBegin, wspEnd, map);
                                                destinyPointer = null;

                                                if ((destinyPoints != null) && (destinyPoints.Count > 0) && (destinyPointer == null))
                                                {
                                                    destinyPointer = destinyPoints.GetEnumerator();
                                                    destinyPointer.MoveNext();
                                                    Vector3 vecTmp = new Vector3(destinyPointer.Current.X, 0.0f, destinyPointer.Current.Y);
                                                    direction = vecTmp - Position;
                                                }
                                            }
                                            else
                                            {
                                                EndMove(_msg);

                                                messages[i].Done = true;
                                            }

                                            messages[i].Done = true;

                                            break;
                                    }
                                }
                            }

                            break;
                        #endregion FixCollisions
                    }
            }
        }