int main()
{
    //------------------------------- Rhenn enemy world / Source C++ by lanky ---------------------------------
    int TEMP = 0;
    int iii = 0;
    bool IDMB = false;
    bool Wroc1 = true, Wroc2 = true;
    bool KolR = false, PressR = false;  // do kolizji....
    bool KolL = false, PressL = false;
    bool KolU = false, PressU = false;
    bool KolD = false, PressD = false;
    bool Stop = true; // do animacji Playera

    float speed = 0;
    float speedE1 = 1;

    sf::IpAddress ip =  getip("ip.txt"); // lub sf::IpAddress ip("192.168.0.10");
    std::string publicIP = ip.toString();
    sf::TcpSocket socket;
    bool done = false;
    std::string id, id2, id3; // id Playerów
    bool id2B = false, id3B = false;
    std::string czat;
    std::string mojtext = ""; // do czata (player1)
    bool mojTextRun = false;
    short int gol = 0;

    id = "enemy";
    std::string text = "";
    ip = sf::IpAddress(publicIP);
    
    enum Direction {Down, Left, Right, Up}; // 0, 1, 2, 3 (odwracanie playera)
    //enum Direction2 {Down2, Left2, Right2, Up2}; // 0, 1, 2, 3
    //int sourceX = 1, sourceY = Down;
    sf::Vector2f prevPosition;
    sf::Vector2f prevPositionE1;

    sf::Vector2i source(1, Down); // (odwracanie playera)
    sf::Vector2i source2(1, Down);
    sf::Vector2i source3(1, Down);

    sf::Vector2i sourceE1(4, Down); //(odwracanie enemy)

    float frameCounter = 0, switchFrame = 100;  // speed do animacji playera1
    float frameCounter2 = 0; // speed do animacji playera2 (multiplayer)
    float frameCounter3 = 0;
    float frameCounterRun = 0, switchFrameRun = 100, frameSpeedRun = 25000; // speed do pozycji playera1

    float frameRespawn = 0;


    string lokS;
    string stopS = "mapy/mapa"; // 1-stop.tmx;
    string enemyS = "mapy/mapa";  // 1-enemy.tmx;

    cout << "Enemy 1.9.4 Running for Windows" << endl;
    cout << "Jaka Mapa? (1,2,3)" << endl;
    cin >> lokS;

    if (lokS == "1" || lokS == "2" || lokS == "3")
    {
       socket.connect(ip, getport("ip.txt"));
       cout << "ok" << endl;
    } else

    {
       cout << "error" << endl;
    }

    stopS += lokS + "-stop.tmx";
    enemyS += lokS + "-enemy.tmx";

    mapCol(stopS.c_str());       // ok
    mapEnemy(enemyS.c_str());    // ok

    int LOKAL = atoi(lokS.c_str());

    closed_nodes_map = new int * [MapSize];
    open_nodes_map = new int * [MapSize];
    dir_map = new int * [MapSize];

    for (int i = 0; i < MapSize; i++)
    {
      closed_nodes_map[i] = new int[MapSize];
      open_nodes_map[i] = new int[MapSize];
      dir_map[i] = new int[MapSize];
    }


    sf::Clock clockServer;       // Do sprawdzania czy server czynny
    float frameServer = 0; // Do sprawdzania czy server czynny

    bool FPS = true;       // fps
    float frame = 0;       // fps
    sf::Clock fraps;       // fps

    vector <EnemyR> Boty; // wczytywanie enemy z mapy
    vector <string> idOnline; // lista PLayer Online
    vector <Multi > PlayerM;

    short int idName = -1;

    for(int i = 0; i < MapSize; i++) // Y
        {
            for(int j = 0; j < MapSize; j++) // X
            {

              if (enemyMap[i][j] > 0)
              {
                idName++;

                ostringstream ss;
                ss << idName;

                Boty.push_back(EnemyR (EnemyR(enemyMap[i][j], j, i)));
                Boty[idName].name += ss.str();
                //Boty[idName].Hp = 115
                //cout << Boty[idName].name << endl;
              }
            }


        }
      cout << Boty[idName].name << endl;

      vector <bool> atakE1; // false;
      vector <short int> xAGlob;
      vector <short int> yAGlob;
      vector <sf::Vector2f> prev;
      vector <short int> xA;
      vector <short int> yA;
      vector <short int> xAOld;
      vector <short int> yAOld;
      vector <short int> jjjOld;

      vector <sf::Clock> RespawnClock;
      vector <bool> RespawnB;
      vector <short int> liczE1; // liczy po jakim czasie ma dostać obrażenia od Playera

      for (int i=0; i < Boty.size(); i++)
      {
        atakE1.push_back(false);
       // wrocilem.push_back(true);
        xAGlob.push_back(Boty[i].pozX); // z jakiej pozycji startuje enemy (mogłem to dodać do klasy!)
        yAGlob.push_back(Boty[i].pozY); // z jakiej pozycji startuje enemy
        prev.push_back(sf::Vector2f(0, 0));
        xA.push_back(0);
        yA.push_back(0);
        xAOld.push_back(0);
        yAOld.push_back(0);
        jjjOld.push_back(0);
        RespawnB.push_back(false);
        liczE1.push_back(0);
        RespawnClock.push_back(sf::Clock());

      }



    sf::Vector2f posOld(0,0); // stara poz. playera2 (do odwracania. Right, Left, itp.)
    sf::Vector2f posOld3(0,0); // stara poz. playera3 (do odwracania. Right, Left, itp.)


	sf::Packet packet;  // ##### multiplayer ######
    packet << id;
    socket.send(packet);
    socket.setBlocking(false);
//    Window.setTitle("ENEMY");

	sf::Vector2f position;


/// -------------------------------------[Timer]-----------------------------------------------

while (true) //  while (Window.isOpen())
{

 usleep(1); // usleep(microseconds); (1000 microseconds = 1 millisecond.)

 if (FPS)
  {
      //cout << RespawnClock[0].getElapsedTime().asSeconds() << endl;

      for (int i=0; i < RespawnClock.size(); i++) // Respawn Enemy po 30 sekundzie.
      {
          if( Boty[i].Respawn == true )
          {

              //cout << "czeka" << endl;
              if(!RespawnB[i])
              {
                 RespawnB[i] = true;
                 RespawnClock[i].restart().asSeconds();

              }

              if ( (RespawnClock[i].getElapsedTime().asSeconds() > 29) &&
                   (RespawnClock[i].getElapsedTime().asSeconds() < 31) )
              {
                Boty[i].Respawn = false;
                RespawnB[i] = false;

                sf::Packet Ennn;

                short int whatt = 5; // 5 to enemy
                string jakiEn = Boty[i].name;

                sf::Vector2f pozEnnn(0 ,0);


                pozEnnn.x = xAGlob[i] * 32;
                pozEnnn.y = yAGlob[i] * 32;
                //pozEnnn.x = Boty[i].wrog.getPosition().x; //e1.enemy.getPosition().x; // poz enemy
                //pozEnnn.y = Boty[i].wrog.getPosition().y;

			    Ennn << whatt << pozEnnn.x << pozEnnn.y << jakiEn << Boty[i].HpMax; // bylo Boty[i].Hp
			    socket.send(Ennn);
                Ennn.clear();
                //cout << "wyslalem" << endl;
              }


           }

       }


           sf::Packet packetP;

           float jakaObr, ileHPP;  // tak aby tylko wypakowac
           bool pvp;  // tak aby tylko wypakowac
           short int jakiAva; // tak aby tylko wypakowac
           short int lok = 1; // lokalizacja playera (na jakiej mapie sie znajduje)
           short int lvl = 1;

           short int coo = 0;
           float jakiHit = 0; // odbiera jaki hit zadał player
           sf::Vector2f poza(0, 0);
           string idas = "";
           string kogoDIE = "";
           //  if (packetP >> coo)


/// multiplayer - ######################  (odbieranie pakietów !!!)  ###################################

if (socket.receive(packetP) == sf::Socket::Done)
 do
  {
    packetP >> coo;

    if (coo == 7)
    {                                                                               // wypakuj reszte
       packetP >> idas >> lok >> lvl >> poza.x >> poza.y >> kogoDIE >> jakiHit >> jakiAva >> pvp >> jakaObr >> ileHPP;
       IDMB = false;

       //idOnline.push_back("oko");
       for (int i=0 ; i < idOnline.size(); i++) // sprawdza czy player jest na liscie (online)
       {
           if (idOnline[i] == idas) IDMB = true; // jeśli jest to true;
       }

       if (IDMB) // gdy true to pokazuj jego pozycje
       {

           for (int i=0; i < PlayerM.size(); i++) // sprawdź z jakim playerem mamy do czynienia
           {

              if (poza.x == 1 && poza.y == 1) // Odłączył od Serwera!  (x=1 && y=1)
              {

                  for (int ol=0 ; ol < idOnline.size(); ol++) // sprawdza kto OFFLINE
                  {
                       if (idOnline[ol] == idas)
                       {
                           idOnline.erase( idOnline.begin() + ol); // usuń z listy online
                           PlayerM.erase( PlayerM.begin() + ol); // usuń playera.
                       }
                  }


                  for (int rez=0; rez < Boty.size(); rez++) // wyłącz rezerwacje enemy dla tego playera
                  {
                       if (Boty[rez].Rezerwacja == idas) Boty[rez].Rezerwacja = "";
                  }

                  cout << "--------------------------------" << endl;
                  cout << idas << " Disconnect" << endl;
                  cout << " Na serwerze zostało graczy: " << PlayerM.size() << endl;
                  //cout << " Na serwerze zostało online: " << idOnline.size() << endl;
                  cout << "--------------------------------" << endl;

              } else

              if (poza.x == 0 && poza.y == 0) //Zmienił mape!
              {

                  for (int rez=0; rez < Boty.size(); rez++) // wyłącz rezerwacje enemy dla tego playera
                  {
                       if (Boty[rez].Rezerwacja == idas) Boty[rez].Rezerwacja = "";
                  }

              } else

              if (poza.x > 1 && idas == PlayerM[i].name) // gdy się porusza.. // było poza.x > 0 - 1.9.2
              {
//                PlayerM[i].multiS.setPosition(poza);
                  PlayerM[i].multiPoz.x = poza.x;
                  PlayerM[i].multiPoz.y = poza.y;

                  PlayerM[i].lok = lok;

                  for (int i=0; i < Boty.size(); i++)
                  {
                     if (Boty[i].name == kogoDIE)
                     Boty[i].Hp = Boty[i].Hp - jakiHit;
                  }

//                  PlayerM[i].multiS.setTextureRect(sf::IntRect(PlayerM[i].sourceAnim.x *32, // wytnij klatke
//                   PlayerM[i].sourceAnim.y *32, 32, 32));

              }



            } // for

       } else  // Gdy nie ma playera to go dodaj! [ CREATE PLAYER ONLINE! ]

       {
            sf::Vector2f mpos(150, 250);

            idOnline.push_back(idas); // Dodaj do listy Online!
            PlayerM.push_back(Multi (Multi(idas, mpos))); // Stwórz Postać Online.

            cout << idas << " Connect!" << endl;
            cout << " Na serwerze graczy jest: " << PlayerM.size() << endl;
            //cout << " Na serwerze online jest: " << idOnline.size() << endl;
       }

    //cout << PlayerM.size() << endl;
    } else

      if (coo == 1)
      {
         string serwerek;
         packetP >> serwerek;

         cout << "Połaczono z serverem" << endl;
      } else

      if (coo == 0)   // sprawdza czy server ok!
      {
          cout << "server ok..." << endl;

      }


 } while (socket.receive(packetP) == sf::Socket::Done);



/// ########################################################################################################
///  #################################### (A* + Wysyłanie Pakietów) ########################################
/// ########################################################################################################

    string route;

    for (int i=0; i < Boty.size(); i++) // ------------ [GET POSITION ENEMY] ---------
    {
//      prev[i] = Boty[i].wrog.getPosition();
        prev[i].x = Boty[i].Wrog.x;
        prev[i].y = Boty[i].Wrog.y;

//      xA[i] = (int)(Boty[i].wrog.getPosition().x+16) / 32;
//      yA[i] = (int)(Boty[i].wrog.getPosition().y+16) / 32;
        xA[i] = (int)(Boty[i].Wrog.x+16) / 32;
        yA[i] = (int)(Boty[i].Wrog.y+16) / 32;

    }

    for (int pi=0; pi < PlayerM.size(); pi++)
    {
       PlayerM[pi].UpdatePoz(); // (1.9.3)

       for (int i=0; i < Boty.size(); i++) // -------- [ A* A_STAR ] ----------
       {

          PlayerM[pi].blisko = false;
          PlayerM[pi].atak = false;
          PlayerM[pi].wrocilem = true;

          //gdy enemy jest blisko playera i nie jest daleko od swojej bazy to ....
          if(PlayerM[pi].pozX+5 > xA[i] && PlayerM[pi].pozX-5 < xA[i] && PlayerM[pi].pozY+5 > yA[i] &&
          PlayerM[pi].pozY-5 < yA[i] && PlayerM[pi].pozX < xAGlob[i]+15 && PlayerM[pi].pozX > xAGlob[i]-15 &&
          PlayerM[pi].pozY < yAGlob[i]+15 && PlayerM[pi].pozY > yAGlob[i]-15 && PlayerM[pi].lok == LOKAL)
          {

            if (Boty[i].Rezerwacja == "")  // Gdy ten enemy nie jest zarezerwowany to zarezerwuj
                Boty[i].Rezerwacja = PlayerM[pi].name;


            if ( (Boty[i].Rezerwacja == PlayerM[pi].name) && (!Boty[i].Respawn) )  // gdy jest mój to atakuj
            {

               PlayerM[pi].atak = true; // poinformuj ,że go atakuje
               PlayerM[pi].blisko = true; // poinformuj ,że jest blisko ciebie


               if (xAOld[i] != xA[i] || yAOld[i] != yA[i]) // do optymalizacji (aby SI nie wykonywało się tak samo)
               {
                   route = pathFind(xA[i], yA[i], PlayerM[pi].pozX, PlayerM[pi].pozY, MapSize, MapSize); //Wykonaj A*
                   int jjj; // do A*
                   char ccc; // do A*

                   if (route.length() > 0)
                   {
                      ccc = route.at(0);
                      jjj = atoi(&ccc);
                   } // dałem tu klamre {} 1.9.2 test 3

                   //Boty[i].wrog.move(dx[jjj], dy[jjj]); // Enemy wykonuje ruch podążając za graczem.
                   Boty[i].Wrog.x += dx[jjj];
                   Boty[i].Wrog.y += dy[jjj];
                   jjjOld[i] = jjj;                           // do optymalizacji
                   xAOld[i] = (int)(Boty[i].Wrog.x+16) / 32;  // do optymalizacji
                   yAOld[i] = (int)(Boty[i].Wrog.y+16) / 32;  // do optymalizacji
               } else
               {
                   Boty[i].Wrog.x += dx[jjjOld[i]];           // do optymalizacji
                   Boty[i].Wrog.y += dy[jjjOld[i]];           // do optymalizacji
               }
               //cout <<  Boty[i].wrog.getPosition().x << " X " << Boty[i].wrog.getPosition().y << endl;
            }

          }



          if ( (Boty[i].Rezerwacja == PlayerM[pi].name) && (!Boty[i].Respawn) ) // gdy jest mój to..
          {

            if (!PlayerM[pi].blisko) // Enemy wraca na swoją pozycje!
            {

                PlayerM[pi].atak = false; // poinformuj ,że cie już nie atakuje

                if (xAOld[i] != xA[i] || yAOld[i] != yA[i]) // do optymalizacji (aby SI nie wykonywało się tak samo)
                {
                   // Enemy wraca - A* (szuka drogi do bazy)
                   route = pathFind(xA[i], yA[i], xAGlob[i], yAGlob[i], MapSize, MapSize); 
                   int jjj;    // do A*
                   string ccc; // do A*

                   if (route.length() > 0) // Gdy jeszcze enemy wraca do swojej bazy to..
                   {
                       PlayerM[pi].wrocilem = false; // poinformuj ,że jeszcze nie dotarł do bazy
                       ccc = route.at(0);
                       jjj = atoi(ccc.c_str());  // (1.9.3)

                       Boty[i].Wrog.x += dx[jjj];
                       Boty[i].Wrog.y += dy[jjj];
                       jjjOld[i] = jjj;                           // do optymalizacji
                       xAOld[i] = (int)(Boty[i].Wrog.x+16) / 32;  // do optymalizacji
                       yAOld[i] = (int)(Boty[i].Wrog.y+16) / 32;  // do optymalizacji

                       for (int pii=0; pii < PlayerM.size(); pii++)
                       {
                          if (pii == pi) continue; // jeśli to nie jesteś ty to..
                          if(PlayerM[pii].pozX+5 > xA[i] && PlayerM[pii].pozX-5 < xA[i] && PlayerM[pii].pozY+5 > yA[i]
                           && PlayerM[pii].pozY-5 < yA[i])
                          Boty[i].Rezerwacja = ""; // zwolnij rezerwacje jeśli napotkasz po drodze innego playera
                       }

                    }  else

                    {
                       PlayerM[pi].wrocilem = true; // [else] poinformuj ,że enemy wrócił
                       Boty[i].Rezerwacja = "";     // zwolnij rezerwacje (bo juz cie nie goni)
                       Boty[i].Hp = Boty[i].HpMax;  // v1.9.1
                    }
                 } else

                 {
                    PlayerM[pi].wrocilem = false;
                    Boty[i].Wrog.x += dx[jjjOld[i]];           // do optymalizacji
                    Boty[i].Wrog.y += dy[jjjOld[i]];           // do optymalizacji
                 }

             } // Enemy wraca na swoją pozycje!


//           if(prev[i] != Boty[i].wrog.getPosition()) /// Gdy pozycja enemy sie zmieniła [ WYŚLIJ PACKET !!!]
             if(prev[i].x != Boty[i].Wrog.x || prev[i].y != Boty[i].Wrog.y)
             {


                  // wyslij poz. gdy goni playera lub wraca.
                  if (PlayerM[pi].wrocilem == false || PlayerM[pi].atak == true) 
                  {

                     sf::Packet EnE;
                     short int what = 5; // 5 to enemy
                     string jakiE = Boty[i].name;
                     sf::Vector2f pozEnE(0 ,0);

//                   pozEnE.x = Boty[i].wrog.getPosition().x; //e1.enemy.getPosition().x; // poz enemy
//			         pozEnE.y = Boty[i].wrog.getPosition().y;
                     pozEnE.x = Boty[i].Wrog.x;               // poz enemy
			         pozEnE.y = Boty[i].Wrog.y;

			         EnE << what << pozEnE.x << pozEnE.y << jakiE << Boty[i].Hp;
			         socket.send(EnE);
			         EnE.clear();


			         if (Boty[i].Hp < 0)
                     {
                        Boty[i].Hp = Boty[i].HpMax;
                        Boty[i].Respawn = true; // zarezerwuj
//                      Boty[i].wrog.setPosition(sf::Vector2f(xAGlob[i]*32, yAGlob[i]*32));
                        Boty[i].Wrog.x = xAGlob[i]*32;
                        Boty[i].Wrog.y = yAGlob[i]*32;
                     }
                  }

              }

        } // dalsza rezerwacja (od wracam do wyslij pakiet)

      } // for (int i=0; i < Boty.size(); i++)

    } // for (int pi=0; pi < PlayerM.size(); pi++)


//Window.display();

///............................................................................................................
  frameServer = clockServer.getElapsedTime().asSeconds();

  if(frameServer > 10)         // Co 10 sekund
  {
      sf::Packet servON;       // Sprawdza czy server ON!
      short int whatON = 0;

      servON << whatON;
      socket.send(servON);
      servON.clear();
      clockServer.restart().asSeconds();
  }



  }  // mój FPS

   frame = fraps.getElapsedTime().asSeconds();
   //cout << frame << endl;


    if (frame > 0.009) // 0.010 = 100fps
      {
         FPS = true;
         fraps.restart().asSeconds(); // na dzień 10.10.2013
      }  else

      {
         FPS = false;

      }


 } // if true - timer


    return 0;
}