Changeset 95ffe57 in network-game


Ignore:
Timestamp:
Oct 4, 2013, 5:06:20 PM (11 years ago)
Author:
dportnoy <dmp1488@…>
Branches:
master
Children:
90eaad2
Parents:
e6c26b8
Message:

The server now has a map of Player pointers instead of Players and MSG_TYPE_PLAYER is sent to notify a player joining a game about the players already in the game

Files:
2 edited

Legend:

Unmodified
Added
Removed

  • client/Client/main.cpp

    re6c26b8 r95ffe57  
    674674               {
    675675                  wndCurrent = wndLobby;
    676                  
    677                   Player p("", "");
    678                   p.deserialize(msg.buffer);
    679 
    680                   if (mapPlayers.find(p.id) != mapPlayers.end())
    681                      delete mapPlayers[p.id];
    682                   mapPlayers[p.id] = new Player(p);
    683                   curPlayerId = p.id;
     676               
     677                  // this message should only be sent when a player first logs in so they know their id
     678 
     679                  Player* p = new Player("", "");
     680                  p->deserialize(msg.buffer);
     681
     682                  if (mapPlayers.find(p->id) != mapPlayers.end())
     683                     delete mapPlayers[p->id];
     684                  mapPlayers[p->id] = p;
     685                  curPlayerId = p->id;
    684686
    685687                  cout << "Got a valid login response with the player" << endl;
    686688                  cout << "Player id: " << curPlayerId << endl;
    687                   cout << "Player health: " << p.health << endl;
     689                  cout << "Player health: " << p->health << endl;
    688690                  cout << "player map size: " << mapPlayers.size() << endl;
    689691               }
    … …  
    708710               cout << "Received MSG_TYPE_PLAYER" << endl;
    709711
    710                Player p("", "");
    711                p.deserialize(msg.buffer);
    712                p.timeLastUpdated = getCurrentMillis();
    713                p.isChasing = false;
    714                if (p.health <= 0)
    715                   p.isDead = true;
     712               Player* p = new Player("", "");
     713               p->deserialize(msg.buffer);
     714               p->timeLastUpdated = getCurrentMillis();
     715               p->isChasing = false;
     716               if (p->health <= 0)
     717                  p->isDead = true;
    716718               else
    717                   p.isDead = false;
    718 
    719                if (mapPlayers.find(p.id) != mapPlayers.end())
    720                     delete mapPlayers[p.id];
    721                mapPlayers[p.id] = new Player(p);
     719                  p->isDead = false;
     720
     721               if (mapPlayers.find(p->id) != mapPlayers.end())
     722                    delete mapPlayers[p->id];
     723               mapPlayers[p->id] = p;
    722724
    723725               break;

  • server/server.cpp

    re6c26b8 r95ffe57  
    4545// from used to be const. Removed that so I could take a reference
    4646// and use it to send messages
    47 bool processMessage(const NETWORK_MSG &clientMsg, struct sockaddr_in &from, MessageProcessor &msgProcessor, map<unsigned int, Player>& mapPlayers, map<string, Game*>& mapGames, WorldMap* gameMap, unsigned int& unusedPlayerId, NETWORK_MSG &serverMsg, int sock, int &scoreBlue, int &scoreRed, ofstream& outputLog);
    48 
    49 void updateUnusedPlayerId(unsigned int& id, map<unsigned int, Player>& mapPlayers);
     47bool processMessage(const NETWORK_MSG &clientMsg, struct sockaddr_in &from, MessageProcessor &msgProcessor, map<unsigned int, Player*>& mapPlayers, map<string, Game*>& mapGames, WorldMap* gameMap, unsigned int& unusedPlayerId, NETWORK_MSG &serverMsg, int sock, int &scoreBlue, int &scoreRed, ofstream& outputLog);
     48
     49void updateUnusedPlayerId(unsigned int& id, map<unsigned int, Player*>& mapPlayers);
    5050void updateUnusedProjectileId(unsigned int& id, map<unsigned int, Projectile>& mapProjectiles);
     51Player *findPlayerByName(map<unsigned int, Player*> &m, string name);
     52Player *findPlayerByAddr(map<unsigned int, Player*> &m, const sockaddr_in &addr);
    5153void damagePlayer(Player *p, int damage);
    5254
    53 void addObjectToMap(WorldMap::ObjectType objectType, int x, int y, WorldMap* gameMap, map<unsigned int, Player>& mapPlayers, MessageProcessor &msgProcessor, int sock, ofstream& outputLog);
     55void addObjectToMap(WorldMap::ObjectType objectType, int x, int y, WorldMap* gameMap, map<unsigned int, Player*>& mapPlayers, MessageProcessor &msgProcessor, int sock, ofstream& outputLog);
    5456
    5557// this should probably go somewhere in the common folder
    … …  
    5860    perror(msg);
    5961    exit(0);
    60 }
    61 
    62 Player *findPlayerByName(map<unsigned int, Player> &m, string name)
    63 {
    64    map<unsigned int, Player>::iterator it;
    65 
    66    for (it = m.begin(); it != m.end(); it++)
    67    {
    68       if ( it->second.name.compare(name) == 0 )
    69          return &(it->second);
    70    }
    71 
    72    return NULL;
    73 }
    74 
    75 Player *findPlayerByAddr(map<unsigned int, Player> &m, const sockaddr_in &addr)
    76 {
    77    map<unsigned int, Player>::iterator it;
    78 
    79    for (it = m.begin(); it != m.end(); it++)
    80    {
    81       if ( it->second.addr.sin_addr.s_addr == addr.sin_addr.s_addr &&
    82            it->second.addr.sin_port == addr.sin_port )
    83          return &(it->second);
    84    }
    85 
    86    return NULL;
    8762}
    8863
    … …  
    9873   NETWORK_MSG clientMsg, serverMsg;
    9974   MessageProcessor msgProcessor;
    100    map<unsigned int, Player> mapPlayers;
     75   map<unsigned int, Player*> mapPlayers;
    10176   map<unsigned int, Projectile> mapProjectiles;
    10277   map<string, Game*> mapGames;
    … …  
    11691   //OpenSSL_add_all_algorithms();
    11792
    118    if (argc < 2) {
    119       cerr << "ERROR, no port provided" << endl;
     93   if (argc != 2)
     94   {
     95      cerr << "ERROR, expected server [domain] [port]" << endl;
    12096      exit(1);
    12197   }
    … …  
    128104   // add some items to the map. They will be sent out
    129105   // to players when they login
    130    for (int y=0; y<gameMap->height; y++) {
    131       for (int x=0; x<gameMap->width; x++) {
    132          switch (gameMap->getStructure(x, y)) {
     106   for (int y=0; y<gameMap->height; y++)
     107   {
     108      for (int x=0; x<gameMap->width; x++)
     109      {
     110         switch (gameMap->getStructure(x, y))
     111         {
    133112            case WorldMap::STRUCTURE_BLUE_FLAG:
    134113               gameMap->addObject(WorldMap::OBJECT_BLUE_FLAG, x*25+12, y*25+12);
    … …  
    157136   timespec ts;
    158137   int timeLastUpdated = 0, curTime = 0, timeLastBroadcast = 0;
    159    while (!done) {
     138   while (!done)
     139   {
    160140
    161141      usleep(5000);
    … …  
    166146      curTime = ts.tv_sec*1000 + ts.tv_nsec/1000000;
    167147
    168       if (timeLastUpdated == 0 || (curTime-timeLastUpdated) >= 50) {
     148      if (timeLastUpdated == 0 || (curTime-timeLastUpdated) >= 50)
     149      {
    169150         timeLastUpdated = curTime;
    170151
    … …  
    172153         msgProcessor.resendUnackedMessages(sock, &outputLog);
    173154
    174          map<unsigned int, Player>::iterator it;
     155         map<unsigned int, Player*>::iterator it;
    175156
    176157         // set targets for all chasing players (or make them attack if they're close enough)
    177          for (it = mapPlayers.begin(); it != mapPlayers.end(); it++) {
     158         for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
     159         {
    178160            // check if it's time to revive dead players
    179             if (it->second.isDead) {
    180                if (getCurrentMillis() - it->second.timeDied >= 10000) {
    181                   it->second.isDead = false;
     161            if (it->second->isDead)
     162            {
     163               if (getCurrentMillis() - it->second->timeDied >= 10000)
     164               {
     165                  it->second->isDead = false;
    182166
    183167                  POSITION spawnPos;
    184168 
    185                   switch (it->second.team) {
     169                  switch (it->second->team)
     170                  {
    186171                  case 0:// blue team
    187172                     spawnPos = gameMap->getStructureLocation(WorldMap::STRUCTURE_BLUE_FLAG);
    … …  
    200185                  spawnPos.y = spawnPos.y * 25 + 12;
    201186
    202                   it->second.pos = spawnPos.toFloat();
    203                   it->second.target = spawnPos;
    204                   it->second.health = it->second.maxHealth;
     187                  it->second->pos = spawnPos.toFloat();
     188                  it->second->target = spawnPos;
     189                  it->second->health = it->second->maxHealth;
    205190
    206191                  serverMsg.type = MSG_TYPE_PLAYER;
    207                   it->second.serialize(serverMsg.buffer);
    208 
    209                   map<unsigned int, Player>::iterator it2;
     192                  it->second->serialize(serverMsg.buffer);
     193
     194                  map<unsigned int, Player*>::iterator it2;
    210195                  for (it2 = mapPlayers.begin(); it2 != mapPlayers.end(); it2++)
    211196                  {
    212                      if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second.addr), &outputLog) < 0 )
     197                     if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
    213198                        error("sendMessage");
    214199                  }
    … …  
    218203            }
    219204
    220             if (it->second.updateTarget(mapPlayers)) {
     205            if (it->second->updateTarget(mapPlayers))
     206            {
    221207               serverMsg.type = MSG_TYPE_PLAYER;
    222                it->second.serialize(serverMsg.buffer);
    223 
    224                map<unsigned int, Player>::iterator it2;
     208               it->second->serialize(serverMsg.buffer);
     209
     210               map<unsigned int, Player*>::iterator it2;
    225211               for (it2 = mapPlayers.begin(); it2 != mapPlayers.end(); it2++)
    226212               {
    227                   if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second.addr), &outputLog) < 0 )
     213                  if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
    228214                     error("sendMessage");
    229215               }
    … …  
    235221         FLOAT_POSITION oldPos;
    236222         bool broadcastMove = false;
    237          for (it = mapPlayers.begin(); it != mapPlayers.end(); it++) {
    238             oldPos = it->second.pos;
    239             if (it->second.move(gameMap)) {
     223         for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
     224         {
     225            oldPos = it->second->pos;
     226            if (it->second->move(gameMap)) {
    240227
    241228               // check if the move needs to be canceled
    242                switch(gameMap->getElement(it->second.pos.x/25, it->second.pos.y/25)) {
     229               switch(gameMap->getElement(it->second->pos.x/25, it->second->pos.y/25))
     230               {
    243231                  case WorldMap::TERRAIN_NONE:
    244232                  case WorldMap::TERRAIN_OCEAN:
    245233                  case WorldMap::TERRAIN_ROCK:
    246234                  {
    247                      it->second.pos = oldPos;
    248                      it->second.target.x = it->second.pos.x;
    249                      it->second.target.y = it->second.pos.y;
    250                      it->second.isChasing = false;
     235                     it->second->pos = oldPos;
     236                     it->second->target.x = it->second->pos.x;
     237                     it->second->target.y = it->second->pos.y;
     238                     it->second->isChasing = false;
    251239                     broadcastMove = true;
    252240                     break;
    … …  
    263251               bool ownFlagAtBase = false;
    264252       
    265                switch(gameMap->getStructure(it->second.pos.x/25, it->second.pos.y/25)) {
     253               switch(gameMap->getStructure(it->second->pos.x/25, it->second->pos.y/25))
     254               {
    266255                  case WorldMap::STRUCTURE_BLUE_FLAG:
    267256                  {
    268                      if (it->second.team == 0 && it->second.hasRedFlag)
     257                     if (it->second->team == 0 && it->second->hasRedFlag)
    269258                     {
    270259                        // check that your flag is at your base
    … …  
    274263                        vector<WorldMap::Object>::iterator itObjects;
    275264
    276                         for (itObjects = vctObjects->begin(); itObjects != vctObjects->end(); itObjects++) {
    277                            if (itObjects->type == WorldMap::OBJECT_BLUE_FLAG) {
    278                               if (itObjects->pos.x == pos.x*25+12 && itObjects->pos.y == pos.y*25+12) {
     265                        for (itObjects = vctObjects->begin(); itObjects != vctObjects->end(); itObjects++)
     266                        {
     267                           if (itObjects->type == WorldMap::OBJECT_BLUE_FLAG)
     268                           {
     269                              if (itObjects->pos.x == pos.x*25+12 && itObjects->pos.y == pos.y*25+12)
     270                              {
    279271                                 ownFlagAtBase = true;
    280272                                 break;
    … …  
    283275                        }
    284276
    285                         if (ownFlagAtBase) {
    286                            it->second.hasRedFlag = false;
     277                        if (ownFlagAtBase)
     278                        {
     279                           it->second->hasRedFlag = false;
    287280                           flagType = WorldMap::OBJECT_RED_FLAG;
    288281                           pos = gameMap->getStructureLocation(WorldMap::STRUCTURE_RED_FLAG);
    … …  
    296289                  case WorldMap::STRUCTURE_RED_FLAG:
    297290                  {
    298                      if (it->second.team == 1 && it->second.hasBlueFlag)
     291                     if (it->second->team == 1 && it->second->hasBlueFlag)
    299292                     {
    300293                        // check that your flag is at your base
    … …  
    304297                        vector<WorldMap::Object>::iterator itObjects;
    305298
    306                         for (itObjects = vctObjects->begin(); itObjects != vctObjects->end(); itObjects++) {
    307                            if (itObjects->type == WorldMap::OBJECT_RED_FLAG) {
    308                               if (itObjects->pos.x == pos.x*25+12 && itObjects->pos.y == pos.y*25+12) {
     299                        for (itObjects = vctObjects->begin(); itObjects != vctObjects->end(); itObjects++)
     300                        {
     301                           if (itObjects->type == WorldMap::OBJECT_RED_FLAG)
     302                           {
     303                              if (itObjects->pos.x == pos.x*25+12 && itObjects->pos.y == pos.y*25+12)
     304                              {
    309305                                 ownFlagAtBase = true;
    310306                                 break;
    … …  
    313309                        }
    314310
    315                         if (ownFlagAtBase) {
    316                            it->second.hasBlueFlag = false;
     311                        if (ownFlagAtBase)
     312                        {
     313                           it->second->hasBlueFlag = false;
    317314                           flagType = WorldMap::OBJECT_BLUE_FLAG;
    318315                           pos = gameMap->getStructureLocation(WorldMap::STRUCTURE_BLUE_FLAG);
    … …  
    326323               }
    327324
    328                if (flagTurnedIn) {
     325               if (flagTurnedIn)
     326               {
    329327                  // send an OBJECT message to add the flag back to its spawn point
    330328                  pos.x = pos.x*25+12;
    … …  
    335333                  gameMap->getObjects()->back().serialize(serverMsg.buffer);
    336334
    337                   map<unsigned int, Player>::iterator it2;
     335                  map<unsigned int, Player*>::iterator it2;
    338336                  for (it2 = mapPlayers.begin(); it2 != mapPlayers.end(); it2++)
    339337                  {
    340                      if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second.addr), &outputLog) < 0 )
     338                     if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
    341339                        error("sendMessage");
    342340                  }
    … …  
    348346                  for (it2 = mapPlayers.begin(); it2 != mapPlayers.end(); it2++)
    349347                  {
    350                      if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second.addr), &outputLog) < 0 )
     348                     if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
    351349                        error("sendMessage");
    352350                  }
    … …  
    361359               POSITION structPos;
    362360
    363                for (itObjects = vctObjects->begin(); itObjects != vctObjects->end(); itObjects++) {
     361               for (itObjects = vctObjects->begin(); itObjects != vctObjects->end(); itObjects++)
     362               {
    364363                  POSITION pos = itObjects->pos;
    365364
    366                   if (posDistance(it->second.pos, pos.toFloat()) < 10) {
    367                      if (it->second.team == 0 &&
    368                         itObjects->type == WorldMap::OBJECT_BLUE_FLAG) {
     365                  if (posDistance(it->second->pos, pos.toFloat()) < 10)
     366                  {
     367                     if (it->second->team == 0 &&
     368                         itObjects->type == WorldMap::OBJECT_BLUE_FLAG)
     369                     {
    369370                        structPos = gameMap->getStructureLocation(WorldMap::STRUCTURE_BLUE_FLAG);
    370371                        flagReturned = true;
    371372                        break;
    372                      } else if (it->second.team == 1 &&
    373                         itObjects->type == WorldMap::OBJECT_RED_FLAG) {
     373                     }
     374                     else if (it->second->team == 1 &&
     375                              itObjects->type == WorldMap::OBJECT_RED_FLAG)
     376                     {
    374377                        structPos = gameMap->getStructureLocation(WorldMap::STRUCTURE_RED_FLAG);
    375378                        flagReturned = true;
    … …  
    379382               }
    380383
    381                if (flagReturned) {
     384               if (flagReturned)
     385               {
    382386                  itObjects->pos.x = structPos.x*25+12;
    383387                  itObjects->pos.y = structPos.y*25+12;
    … …  
    386390                  itObjects->serialize(serverMsg.buffer);
    387391
    388                   map<unsigned int, Player>::iterator it2;
     392                  map<unsigned int, Player*>::iterator it2;
    389393                  for (it2 = mapPlayers.begin(); it2 != mapPlayers.end(); it2++)
    390394                  {
    391                      if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second.addr), &outputLog) < 0 )
     395                     if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
    392396                        error("sendMessage");
    393397                  }
    394398               }
    395399
    396                if (broadcastMove) {
     400               if (broadcastMove)
     401               {
    397402                  serverMsg.type = MSG_TYPE_PLAYER;
    398                   it->second.serialize(serverMsg.buffer);
     403                  it->second->serialize(serverMsg.buffer);
    399404
    400405                  cout << "about to broadcast move" << endl;
    401                   map<unsigned int, Player>::iterator it2;
     406                  map<unsigned int, Player*>::iterator it2;
    402407                  for (it2 = mapPlayers.begin(); it2 != mapPlayers.end(); it2++)
    403408                  {
    404                      if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second.addr), &outputLog) < 0 )
     409                     if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
    405410                        error("sendMessage");
    406411                  }
    … …  
    409414
    410415            // check if the player's attack animation is complete
    411             if (it->second.isAttacking && it->second.timeAttackStarted+it->second.attackCooldown <= getCurrentMillis()) {
    412                it->second.isAttacking = false;
     416            if (it->second->isAttacking && it->second->timeAttackStarted+it->second->attackCooldown <= getCurrentMillis())
     417            {
     418               it->second->isAttacking = false;
    413419               cout << "Attack animation is complete" << endl;
    414420
    … …  
    417423
    418424               serverMsg.type = MSG_TYPE_ATTACK;
    419                memcpy(serverMsg.buffer, &it->second.id, 4);
    420                memcpy(serverMsg.buffer+4, &it->second.targetPlayer, 4);
    421 
    422                map<unsigned int, Player>::iterator it2;
     425               memcpy(serverMsg.buffer, &it->second->id, 4);
     426               memcpy(serverMsg.buffer+4, &it->second->targetPlayer, 4);
     427
     428               map<unsigned int, Player*>::iterator it2;
    423429               for (it2 = mapPlayers.begin(); it2 != mapPlayers.end(); it2++)
    424430               {
    425                   if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second.addr), &outputLog) < 0 )
     431                  if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
    426432                     error("sendMessage");
    427433               }
    428434
    429                if (it->second.attackType == Player::ATTACK_MELEE) {
     435               if (it->second->attackType == Player::ATTACK_MELEE)
     436               {
    430437                  cout << "Melee attack" << endl;
    431438
    432                   Player* target = &mapPlayers[it->second.targetPlayer];
    433                   damagePlayer(target, it->second.damage);
    434 
    435                   if (target->isDead) {
     439                  Player* target = mapPlayers[it->second->targetPlayer];
     440                  damagePlayer(target, it->second->damage);
     441
     442                  if (target->isDead)
     443                  {
    436444                     WorldMap::ObjectType flagType = WorldMap::OBJECT_NONE;
    437445                     if (target->hasBlueFlag)
    … …  
    447455                  serverMsg.type = MSG_TYPE_PLAYER;
    448456                  target->serialize(serverMsg.buffer);
    449                }else if (it->second.attackType == Player::ATTACK_RANGED) {
     457               }
     458               else if (it->second->attackType == Player::ATTACK_RANGED)
     459               {
    450460                  cout << "Ranged attack" << endl;
    451461
    452                   Projectile proj(it->second.pos.x, it->second.pos.y, it->second.targetPlayer, it->second.damage);
     462                  Projectile proj(it->second->pos.x, it->second->pos.y, it->second->targetPlayer, it->second->damage);
    453463                  proj.id = unusedProjectileId;
    454464                  updateUnusedProjectileId(unusedProjectileId, mapProjectiles);
    455465                  mapProjectiles[proj.id] = proj;
    456466
    457                   int x = it->second.pos.x;
    458                   int y = it->second.pos.y;
     467                  int x = it->second->pos.x;
     468                  int y = it->second->pos.y;
    459469
    460470                  serverMsg.type = MSG_TYPE_PROJECTILE;
    … …  
    462472                  memcpy(serverMsg.buffer+4, &x, 4);
    463473                  memcpy(serverMsg.buffer+8, &y, 4);
    464                   memcpy(serverMsg.buffer+12, &it->second.targetPlayer, 4);
    465                }else {
    466                   cout << "Invalid attack type: " << it->second.attackType << endl;
    467                }
     474                  memcpy(serverMsg.buffer+12, &it->second->targetPlayer, 4);
     475               }
     476               else
     477                  cout << "Invalid attack type: " << it->second->attackType << endl;
    468478
    469479               // broadcast either a PLAYER or PROJECTILE message
    … …  
    471481               for (it2 = mapPlayers.begin(); it2 != mapPlayers.end(); it2++)
    472482               {
    473                   if (msgProcessor.sendMessage(&serverMsg, sock, &(it2->second.addr), &outputLog) < 0 )
     483                  if (msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
    474484                     error("sendMessage");
    475485               }
    … …  
    480490         // move all projectiles
    481491         map<unsigned int, Projectile>::iterator itProj;
    482          for (itProj = mapProjectiles.begin(); itProj != mapProjectiles.end(); itProj++) {
     492         for (itProj = mapProjectiles.begin(); itProj != mapProjectiles.end(); itProj++)
     493         {
    483494            cout << "About to call projectile move" << endl;
    484             if (itProj->second.move(mapPlayers)) {
     495            if (itProj->second.move(mapPlayers))
     496            {
    485497               // send a REMOVE_PROJECTILE message
    486498               cout << "send a REMOVE_PROJECTILE message" << endl;
    … …  
    489501               mapProjectiles.erase(itProj->second.id);
    490502
    491                map<unsigned int, Player>::iterator it2;
     503               map<unsigned int, Player*>::iterator it2;
    492504               cout << "Broadcasting REMOVE_PROJECTILE" << endl;
    493505               for (it2 = mapPlayers.begin(); it2 != mapPlayers.end(); it2++)
    494506               {
    495                   if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second.addr), &outputLog) < 0 )
     507                  if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
    496508                     error("sendMessage");
    497509               }
    … …  
    499511               cout << "send a PLAYER message after dealing damage" << endl;
    500512               // send a PLAYER message after dealing damage
    501                Player* target = &mapPlayers[itProj->second.target];
     513               Player* target = mapPlayers[itProj->second.target];
    502514
    503515               damagePlayer(target, itProj->second.damage);
    504516
    505                if (target->isDead) {
     517               if (target->isDead)
     518               {
    506519                  WorldMap::ObjectType flagType = WorldMap::OBJECT_NONE;
    507520                  if (target->hasBlueFlag)
    … …  
    510523                     flagType = WorldMap::OBJECT_RED_FLAG;
    511524
    512                   if (flagType != WorldMap::OBJECT_NONE) {
     525                  if (flagType != WorldMap::OBJECT_NONE)
    513526                     addObjectToMap(flagType, target->pos.x, target->pos.y, gameMap, mapPlayers, msgProcessor, sock, outputLog);
    514                   }
    515527               }
    516528
    … …  
    521533               for (it2 = mapPlayers.begin(); it2 != mapPlayers.end(); it2++)
    522534               {
    523                   if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second.addr), &outputLog) < 0 )
     535                  if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
    524536                     error("sendMessage");
    525537               }
    … …  
    531543      n = msgProcessor.receiveMessage(&clientMsg, sock, &from, &outputLog);
    532544
    533       if (n >= 0) {
     545      if (n >= 0)
     546      {
    534547         broadcastResponse = processMessage(clientMsg, from, msgProcessor, mapPlayers, mapGames, gameMap, unusedPlayerId, serverMsg, sock, scoreBlue, scoreRed, outputLog);
    535548
    … …  
    538551            cout << "Should be broadcasting the message" << endl;
    539552
    540             map<unsigned int, Player>::iterator it;
     553            map<unsigned int, Player*>::iterator it;
    541554            for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
    542555            {
    543                cout << "Sent message back to " << it->second.name << endl;
    544                if ( msgProcessor.sendMessage(&serverMsg, sock, &(it->second.addr), &outputLog) < 0 )
     556               cout << "Sent message back to " << it->second->name << endl;
     557               if ( msgProcessor.sendMessage(&serverMsg, sock, &(it->second->addr), &outputLog) < 0 )
    545558                  error("sendMessage");
    546559            }
    … …  
    561574   // delete all games
    562575   map<string, Game*>::iterator itGames;
    563    for (itGames = mapGames.begin(); itGames != mapGames.end(); itGames++) {
     576   for (itGames = mapGames.begin(); itGames != mapGames.end(); itGames++)
     577   {
    564578      delete itGames->second;
    565579   }
    566580
     581   map<unsigned int, Player*>::iterator itPlayers;
     582   for (itPlayers = mapPlayers.begin(); itPlayers != mapPlayers.end(); itPlayers++)
     583   {
     584      delete itPlayers->second;
     585   }
     586
    567587   return 0;
    568588}
    569589
    570 bool processMessage(const NETWORK_MSG &clientMsg, struct sockaddr_in &from, MessageProcessor &msgProcessor, map<unsigned int, Player>& mapPlayers, map<string, Game*>& mapGames, WorldMap* gameMap, unsigned int& unusedPlayerId, NETWORK_MSG &serverMsg, int sock, int &scoreBlue, int &scoreRed, ofstream& outputLog)
     590bool processMessage(const NETWORK_MSG &clientMsg, struct sockaddr_in &from, MessageProcessor &msgProcessor, map<unsigned int, Player*>& mapPlayers, map<string, Game*>& mapGames, WorldMap* gameMap, unsigned int& unusedPlayerId, NETWORK_MSG &serverMsg, int sock, int &scoreBlue, int &scoreRed, ofstream& outputLog)
    571591{
    572592   DataAccess da;
    … …  
    593613         memcpy(&playerClass, clientMsg.buffer+username.length()+password.length()+2, 4);
    594614         serverMsg.type = MSG_TYPE_REGISTER;
    595 
    596615
    597616         cout << "username: " << username << endl;
    … …  
    629648         {
    630649            strcpy(serverMsg.buffer, "Incorrect username or password");
     650            if (p != NULL)
     651               delete(p);
    631652         }
    632653         else if(findPlayerByName(mapPlayers, username) != NULL)
    633654         {
    634655            strcpy(serverMsg.buffer, "Player has already logged in.");
     656            delete(p);
    635657         }
    636658         else
    … …  
    649671            cout << "Sending other players to new player" << endl;
    650672
    651             map<unsigned int, Player>::iterator it;
     673            map<unsigned int, Player*>::iterator it;
    652674            for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
    653675            {
    654                it->second.serialize(serverMsg.buffer);
    655 
    656                cout << "sending info about " << it->second.name  << endl;
    657                cout << "sending id " << it->second.id  << endl;
     676               it->second->serialize(serverMsg.buffer);
     677
     678               cout << "sending info about " << it->second->name  << endl;
     679               cout << "sending id " << it->second->id  << endl;
    658680               if ( msgProcessor.sendMessage(&serverMsg, sock, &from, &outputLog) < 0 )
    659681                  error("sendMessage");
    … …  
    686708            for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
    687709            {
    688                cout << "Sent message back to " << it->second.name << endl;
    689                if ( msgProcessor.sendMessage(&serverMsg, sock, &(it->second.addr), &outputLog) < 0 )
     710               cout << "Sent message back to " << it->second->name << endl;
     711               if ( msgProcessor.sendMessage(&serverMsg, sock, &(it->second->addr), &outputLog) < 0 )
    690712                  error("sendMessage");
    691713            }
    692714
    693             mapPlayers[unusedPlayerId] = *p;
     715            mapPlayers[unusedPlayerId] = p;
    694716         }
    695717
    696718         serverMsg.type = MSG_TYPE_LOGIN;
    697          delete(p);
    698719
    699720         break;
    … …  
    734755               unusedPlayerId = p->id;
    735756            mapPlayers.erase(p->id);
     757            delete p;
    736758            strcpy(serverMsg.buffer, "You have successfully logged out.");
    737759         }
    … …  
    779801         cout << "id: " << id << endl;
    780802         
    781          if ( mapPlayers[id].addr.sin_addr.s_addr == from.sin_addr.s_addr &&
    782               mapPlayers[id].addr.sin_port == from.sin_port )
     803         Player* p = mapPlayers[id];
     804
     805         if ( p->addr.sin_addr.s_addr == from.sin_addr.s_addr &&
     806              p->addr.sin_port == from.sin_port )
    783807         {
    784808            // we need to make sure the player can move here
    … …  
    788812               cout << "valid terrain" << endl;
    789813
    790                mapPlayers[id].target.x = x;
    791                mapPlayers[id].target.y = y;
    792 
    793                mapPlayers[id].isChasing = false;
    794                mapPlayers[id].isAttacking = false;
     814               p->target.x = x;
     815               p->target.y = y;
     816
     817               p->isChasing = false;
     818               p->isAttacking = false;
    795819
    796820               serverMsg.type = MSG_TYPE_PLAYER_MOVE;
    797821               
    798822               memcpy(serverMsg.buffer, &id, 4);
    799                memcpy(serverMsg.buffer+4, &mapPlayers[id].target.x, 4);
    800                memcpy(serverMsg.buffer+8, &mapPlayers[id].target.y, 4);
     823               memcpy(serverMsg.buffer+4, &p->target.x, 4);
     824               memcpy(serverMsg.buffer+8, &p->target.y, 4);
    801825
    802826               broadcastResponse = true;
    … …  
    820844         cout << "id: " << id << endl;
    821845
     846         Player* p = mapPlayers[id];
     847
    822848         vector<WorldMap::Object>* vctObjects = gameMap->getObjects();
    823849         vector<WorldMap::Object>::iterator itObjects;
    … …  
    827853            bool gotFlag = false;
    828854
    829             if (posDistance(mapPlayers[id].pos, pos.toFloat()) < 10) {
     855            if (posDistance(p->pos, pos.toFloat()) < 10) {
    830856               switch (itObjects->type) {
    831857                  case WorldMap::OBJECT_BLUE_FLAG:
    832                      if (mapPlayers[id].team == 1) {
     858                     if (p->team == 1) {
    833859                        gotFlag = true;
    834                         mapPlayers[id].hasBlueFlag = true;
     860                        p->hasBlueFlag = true;
    835861                        broadcastResponse = true;
    836862                     }
    837863                     break;
    838864                  case WorldMap::OBJECT_RED_FLAG:
    839                      if (mapPlayers[id].team == 0) {
     865                     if (p->team == 0) {
    840866                        gotFlag = true;
    841                         mapPlayers[id].hasRedFlag = true;
     867                        p->hasRedFlag = true;
    842868                        broadcastResponse = true;
    843869                     }
    … …  
    849875                  memcpy(serverMsg.buffer, &itObjects->id, 4);
    850876
    851                   map<unsigned int, Player>::iterator it;
     877                  map<unsigned int, Player*>::iterator it;
    852878                  for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
    853879                  {
    854                      if ( msgProcessor.sendMessage(&serverMsg, sock, &(it->second.addr), &outputLog) < 0 )
     880                     if ( msgProcessor.sendMessage(&serverMsg, sock, &(it->second->addr), &outputLog) < 0 )
    855881                        error("sendMessage");
    856882                  }
    … …  
    868894
    869895         serverMsg.type = MSG_TYPE_PLAYER;
    870          mapPlayers[id].serialize(serverMsg.buffer);
     896         p->serialize(serverMsg.buffer);
    871897
    872898         break;
    … …  
    882908         cout << "id: " << id << endl;
    883909
     910         Player* p = mapPlayers[id];
     911
    884912         WorldMap::ObjectType flagType = WorldMap::OBJECT_NONE;
    885          if (mapPlayers[id].hasBlueFlag)
     913         if (p->hasBlueFlag)
    886914            flagType = WorldMap::OBJECT_BLUE_FLAG;
    887          else if (mapPlayers[id].hasRedFlag)
     915         else if (p->hasRedFlag)
    888916            flagType = WorldMap::OBJECT_RED_FLAG;
    889917
    890          addObjectToMap(flagType, mapPlayers[id].pos.x, mapPlayers[id].pos.y, gameMap, mapPlayers, msgProcessor, sock, outputLog);
    891 
    892          mapPlayers[id].hasBlueFlag = false;
    893          mapPlayers[id].hasRedFlag = false;
     918         addObjectToMap(flagType, p->pos.x, p->pos.y, gameMap, mapPlayers, msgProcessor, sock, outputLog);
     919
     920         p->hasBlueFlag = false;
     921         p->hasRedFlag = false;
    894922
    895923         serverMsg.type = MSG_TYPE_PLAYER;
    896          mapPlayers[id].serialize(serverMsg.buffer);
     924         p->serialize(serverMsg.buffer);
    897925
    898926         broadcastResponse = true;
    … …  
    909937         memcpy(&targetId, clientMsg.buffer+4, 4);
    910938
    911          Player* source = &mapPlayers[id];
     939         Player* source = mapPlayers[id];
    912940         source->targetPlayer = targetId;
    913941         source->isChasing = true;
    … …  
    10101038         cout << "Game name: " << g->getName() << endl;
    10111039         p->currentGame = NULL;
     1040
     1041         serverMsg.type = MSG_TYPE_LEAVE_GAME;
     1042         memcpy(serverMsg.buffer, &p->id, 4);
     1043         strcpy(serverMsg.buffer+4, g->getName().c_str());
     1044
     1045         map<unsigned int, Player*>& players = g->getPlayers();
     1046
     1047         map<unsigned int, Player*>::iterator it;
     1048         for (it = players.begin(); it != players.end(); it++)
     1049         {
     1050            if ( msgProcessor.sendMessage(&serverMsg, sock, &(it->second->addr), &outputLog) < 0 )
     1051               error("sendMessage");
     1052         }
     1053
    10121054         g->removePlayer(p->id);
    10131055
    … …  
    10481090         // tell the new player about all the existing players
    10491091         cout << "Sending other players to new player" << endl;
    1050          serverMsg.type = MSG_TYPE_LOGIN;
     1092         serverMsg.type = MSG_TYPE_PLAYER;
    10511093
    10521094         map<unsigned int, Player*>::iterator it;
    … …  
    11201162}
    11211163
    1122 void updateUnusedPlayerId(unsigned int& id, map<unsigned int, Player>& mapPlayers)
     1164void updateUnusedPlayerId(unsigned int& id, map<unsigned int, Player*>& mapPlayers)
    11231165{
    11241166   while (mapPlayers.find(id) != mapPlayers.end())
    … …  
    11301172   while (mapProjectiles.find(id) != mapProjectiles.end())
    11311173      id++;
     1174}
     1175
     1176Player *findPlayerByName(map<unsigned int, Player*> &m, string name)
     1177{
     1178   map<unsigned int, Player*>::iterator it;
     1179
     1180   for (it = m.begin(); it != m.end(); it++)
     1181   {
     1182      if ( it->second->name.compare(name) == 0 )
     1183         return it->second;
     1184   }
     1185
     1186   return NULL;
     1187}
     1188
     1189Player *findPlayerByAddr(map<unsigned int, Player*> &m, const sockaddr_in &addr)
     1190{
     1191   map<unsigned int, Player*>::iterator it;
     1192
     1193   for (it = m.begin(); it != m.end(); it++)
     1194   {
     1195      if ( it->second->addr.sin_addr.s_addr == addr.sin_addr.s_addr &&
     1196           it->second->addr.sin_port == addr.sin_port )
     1197         return it->second;
     1198   }
     1199
     1200   return NULL;
    11321201}
    11331202
    … …  
    11431212}
    11441213
    1145 void addObjectToMap(WorldMap::ObjectType objectType, int x, int y, WorldMap* gameMap, map<unsigned int, Player>& mapPlayers, MessageProcessor &msgProcessor, int sock, ofstream& outputLog) {
     1214void addObjectToMap(WorldMap::ObjectType objectType, int x, int y, WorldMap* gameMap, map<unsigned int, Player*>& mapPlayers, MessageProcessor &msgProcessor, int sock, ofstream& outputLog) {
    11461215   NETWORK_MSG serverMsg;
    11471216
    … …  
    11521221   gameMap->getObjects()->back().serialize(serverMsg.buffer);
    11531222
    1154    map<unsigned int, Player>::iterator it;
     1223   map<unsigned int, Player*>::iterator it;
    11551224   for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
    11561225   {
    1157       if ( msgProcessor.sendMessage(&serverMsg, sock, &(it->second.addr), &outputLog) < 0 )
     1226      if ( msgProcessor.sendMessage(&serverMsg, sock, &(it->second->addr), &outputLog) < 0 )
    11581227         error("sendMessage");
    11591228   }
Note: See TracChangeset for help on using the changeset viewer.