Changeset 8554263 in network-game for server


Ignore:
Timestamp:
Dec 24, 2013, 8:06:30 PM (11 years ago)
Author:
dportnoy <dmp1488@…>
Branches:
master
Children:
9c18cb7
Parents:
68d94de
Message:

Restructuring and code cleanup

File:
1 edited

Legend:

Unmodified
Added
Removed

  • server/server.cpp

    r68d94de r8554263  
    4646// from used to be const. Removed that so I could take a reference
    4747// and use it to send messages
    48 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);
    49 
     48void 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 &scoreBlue, int &scoreRed);
     49
     50void broadcastMessage(MessageProcessor &msgProcessor, NETWORK_MSG &serverMsg, map<unsigned int, Player*>& players);
    5051void updateUnusedPlayerId(unsigned int& id, map<unsigned int, Player*>& mapPlayers);
    5152Player *findPlayerByName(map<unsigned int, Player*> &m, string name);
    … …  
    5354void damagePlayer(Player *p, int damage);
    5455
    55 void addObjectToMap(WorldMap::ObjectType objectType, int x, int y, WorldMap* gameMap, map<unsigned int, Player*>& mapPlayers, MessageProcessor &msgProcessor, int sock, ofstream& outputLog);
    56 
    57 // this should probably go somewhere in the common folder
    58 void error(const char *msg)
    59 {
    60     perror(msg);
    61     exit(0);
    62 }
     56void addObjectToMap(WorldMap::ObjectType objectType, int x, int y, WorldMap* gameMap, map<unsigned int, Player*>& mapPlayers, MessageProcessor &msgProcessor);
    6357
    6458void quit(int sig) {
    … …  
    6862int main(int argc, char *argv[])
    6963{
    70    int sock, length, n;
     64   int sock, length;
    7165   struct sockaddr_in server;
    7266   struct sockaddr_in from; // info of client sending the message
    … …  
    133127   set_nonblock(sock);
    134128
    135    bool broadcastResponse;
     129   msgProcessor = MessageProcessor(sock, &outputLog);
     130
    136131   timespec ts;
    137132   int timeLastUpdated = 0, curTime = 0, timeLastBroadcast = 0;
    … …  
    149144         timeLastUpdated = curTime;
    150145
    151          msgProcessor.cleanAckedMessages(&outputLog);
    152          msgProcessor.resendUnackedMessages(sock, &outputLog);
     146         msgProcessor.cleanAckedMessages();
     147         msgProcessor.resendUnackedMessages();
    153148
    154149         map<unsigned int, Player*>::iterator it;
    … …  
    157152
    158153         // set targets for all chasing players (or make them attack if they're close enough)
     154         // this should be moved into the games loop
    159155         for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
    160156         {
    … …  
    197193                  p->serialize(serverMsg.buffer);
    198194
    199                   map<unsigned int, Player*>::iterator it2;
    200                   for (it2 = p->currentGame->getPlayers().begin(); it2 != p->currentGame->getPlayers().end(); it2++)
    201                   {
    202                      if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
    203                         error("sendMessage");
    204                   }
     195                  broadcastMessage(msgProcessor, serverMsg, p->currentGame->getPlayers());
    205196               }
    206197
    … …  
    215206                  p->serialize(serverMsg.buffer);
    216207
    217                   map<unsigned int, Player*>::iterator it2;
    218                   for (it2 = playersInGame.begin(); it2 != playersInGame.end(); it2++)
    219                   {
    220                      if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
    221                         error("sendMessage");
    222                   }
     208                  broadcastMessage(msgProcessor, serverMsg, playersInGame);
    223209               }
    224210            }
    … …  
    257243                      broadcastMove = true;
    258244                  cout << "player move processed" << endl;
    259 
    260245
    261246                  WorldMap::ObjectType flagType;
    … …  
    348333                     serverMsg.type = MSG_TYPE_OBJECT;
    349334                     gameMap->getObjects()->back().serialize(serverMsg.buffer);
    350 
    351                      map<unsigned int, Player*>::iterator it2;
    352                  
    353                      for (it2 = playersInGame.begin(); it2 != playersInGame.end(); it2++)
    354                      {
    355                         if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
    356                            error("sendMessage");
    357                      }
     335                     broadcastMessage(msgProcessor, serverMsg, playersInGame);
    358336
    359337                     serverMsg.type = MSG_TYPE_SCORE;
    360338                     memcpy(serverMsg.buffer, &scoreBlue, 4);
    361339                     memcpy(serverMsg.buffer+4, &scoreRed, 4);
    362 
    363                      for (it2 = playersInGame.begin(); it2 != playersInGame.end(); it2++)
    364                      {
    365                         if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
    366                            error("sendMessage");
    367                      }
     340                     broadcastMessage(msgProcessor, serverMsg, playersInGame);
    368341
    369342                     // check to see if the game should end
    … …  
    385358                        memcpy(serverMsg.buffer+8, &scoreRed, 4);
    386359                        strcpy(serverMsg.buffer+12, game->getName().c_str());
    387 
    388                         for (it2 = playersInGame.begin(); it2 != playersInGame.end(); it2++)
    389                         {
    390                            if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
    391                               error("sendMessage");
    392                         }
     360                        broadcastMessage(msgProcessor, serverMsg, playersInGame);
    393361                     }
    394362
    … …  
    432400                     serverMsg.type = MSG_TYPE_OBJECT;
    433401                     itObjects->serialize(serverMsg.buffer);
    434 
    435                      map<unsigned int, Player*>::iterator it2;
    436                      for (it2 = playersInGame.begin(); it2 != playersInGame.end(); it2++)
    437                      {
    438                         if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
    439                            error("sendMessage");
    440                      }
     402                     broadcastMessage(msgProcessor, serverMsg, playersInGame);
    441403                  }
    442404
    443405                  if (broadcastMove)
    444406                  {
    445                      cout << "broadcasting player move" << endl;
    446407                     serverMsg.type = MSG_TYPE_PLAYER;
    447408                     p->serialize(serverMsg.buffer);
    448 
    449                      // only broadcast message to other players in the same game
    450                      cout << "about to broadcast move" << endl;
    451 
    452                      map<unsigned int, Player*>::iterator it2;
    453                      for (it2 = playersInGame.begin(); it2 != playersInGame.end(); it2++)
    454                      {
    455                         if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
    456                            error("sendMessage");
    457                      }
    458                      cout << "done broadcasting player move" << endl;
     409                     broadcastMessage(msgProcessor, serverMsg, playersInGame);
    459410                  }
    460411               }
    … …  
    474425                  memcpy(serverMsg.buffer, &p->id, 4);
    475426                  memcpy(serverMsg.buffer+4, &p->targetPlayer, 4);
    476 
    477                   map<unsigned int, Player*>::iterator it2;
    478                   for (it2 = playersInGame.begin(); it2 != playersInGame.end(); it2++)
    479                   {
    480                      if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
    481                         error("sendMessage");
    482                   }
     427                  broadcastMessage(msgProcessor, serverMsg, playersInGame);
    483428
    484429                  if (p->attackType == Player::ATTACK_MELEE)
    … …  
    498443
    499444                        if (flagType != WorldMap::OBJECT_NONE) {
    500                            addObjectToMap(flagType, target->pos.x, target->pos.y, gameMap, playersInGame, msgProcessor, sock, outputLog);
     445                           addObjectToMap(flagType, target->pos.x, target->pos.y, gameMap, playersInGame, msgProcessor);
    501446                        }
    502447                     }
    … …  
    525470                     cout << "Invalid attack type: " << p->attackType << endl;
    526471
    527                   // broadcast either a PLAYER or PROJECTILE message
    528                   cout << "Broadcasting player or projectile message" << endl;
    529                   for (it2 = playersInGame.begin(); it2 != playersInGame.end(); it2++)
    530                   {
    531                      if (msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
    532                         error("sendMessage");
    533                   }
    534                   cout << "Done broadcasting" << endl;
     472                  broadcastMessage(msgProcessor, serverMsg, playersInGame);
    535473               }
    536474            }
    … …  
    541479               serverMsg.type = MSG_TYPE_GAME_INFO;
    542480               memcpy(serverMsg.buffer, &numPlayers, 4);
    543 
    544                map<unsigned int, Player*>::iterator it2;
    545                for (it2 = mapPlayers.begin(); it2 != mapPlayers.end(); it2++)
    546                {
    547                   if (it2->second->currentGame == game)
    548                       it2->second->currentGame = NULL;
    549                   if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
    550                      error("sendMessage");
    551                }
     481               broadcastMessage(msgProcessor, serverMsg, mapPlayers);
    552482
    553483               // erase game from server
    … …  
    576506                  memcpy(serverMsg.buffer, &itProj->second.id, 4);
    577507                  game->removeProjectile(itProj->second.id);
    578 
    579                   map<unsigned int, Player*>::iterator it2;
    580                   cout << "Broadcasting REMOVE_PROJECTILE" << endl;
    581                   for (it2 = game->getPlayers().begin(); it2 != game->getPlayers().end(); it2++)
    582                   {
    583                      if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
    584                         error("sendMessage");
    585                   }
    586 
    587                   cout << "send a PLAYER message after dealing damage" << endl;
    588                   // send a PLAYER message after dealing damage
     508                  broadcastMessage(msgProcessor, serverMsg, game->getPlayers());
     509
    589510                  Player* target = game->getPlayers()[itProj->second.target];
    590 
    591511                  damagePlayer(target, itProj->second.damage);
    592512
    … …  
    600520
    601521                     if (flagType != WorldMap::OBJECT_NONE)
    602                         addObjectToMap(flagType, target->pos.x, target->pos.y, game->getMap(), game->getPlayers(), msgProcessor, sock, outputLog);
     522                        addObjectToMap(flagType, target->pos.x, target->pos.y, game->getMap(), game->getPlayers(), msgProcessor);
    603523                  }
    604524
     525                  // send a PLAYER message after dealing damage
    605526                  serverMsg.type = MSG_TYPE_PLAYER;
    606527                  target->serialize(serverMsg.buffer);
    607 
    608                   cout << "Sending a PLAYER message" << endl;
    609                   for (it2 = game->getPlayers().begin(); it2 != game->getPlayers().end(); it2++)
    610                   {
    611                      if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
    612                         error("sendMessage");
    613                   }
     528                  broadcastMessage(msgProcessor, serverMsg, game->getPlayers());
    614529               }
    615                cout << "Projectile was not moved" << endl;
    616530            }
    617531         }
    618532      }
    619533
    620       n = msgProcessor.receiveMessage(&clientMsg, sock, &from, &outputLog);
    621 
    622       if (n >= 0)
    623       {
    624          broadcastResponse = processMessage(clientMsg, from, msgProcessor, mapPlayers, mapGames, gameMap, unusedPlayerId, serverMsg, sock, scoreBlue, scoreRed, outputLog);
    625 
    626          if (broadcastResponse)
    627          {
    628             cout << "Should be broadcasting the message" << endl;
    629 
    630             // needs to be updated to use the players from the game
    631             map<unsigned int, Player*>::iterator it;
    632             for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
    633             {
    634                cout << "Sent message back to " << it->second->name << endl;
    635                if ( msgProcessor.sendMessage(&serverMsg, sock, &(it->second->addr), &outputLog) < 0 )
    636                   error("sendMessage");
    637             }
    638          }
    639          else
    640          {
    641             cout << "Should be sending back the message" << endl;
    642 
    643             if ( msgProcessor.sendMessage(&serverMsg, sock, &from, &outputLog) < 0 )
    644                error("sendMessage");
    645          }
     534      if (msgProcessor.receiveMessage(&clientMsg, &from) >= 0)
     535      {
     536         processMessage(clientMsg, from, msgProcessor, mapPlayers, mapGames, gameMap, unusedPlayerId, serverMsg, scoreBlue, scoreRed);
    646537
    647538         cout << "Finished processing the message" << endl;
    … …  
    668559}
    669560
    670 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)
     561void 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 &scoreBlue, int &scoreRed)
    671562{
    672563   DataAccess da;
    … …  
    677568   cout << "MSG: type: " << clientMsg.type << endl;
    678569   cout << "MSG contents: " << clientMsg.buffer << endl;
    679 
    680    // maybe we should make a message class and have this be a member
    681    bool broadcastResponse = false;
    682570
    683571   // Check that if an invalid message is sent, the client will correctly
    … …  
    691579         Player::PlayerClass playerClass;
    692580
    693          serverMsg.type = MSG_TYPE_REGISTER;
    694581         memcpy(&playerClass, clientMsg.buffer+username.length()+password.length()+2, 4);
    695582
    … …  
    697584         cout << "password: " << password << endl;
    698585
    699          if (playerClass == Player::CLASS_WARRIOR)
    700             cout << "class: WARRIOR" << endl;
    701          else if (playerClass == Player::CLASS_RANGER)
    702             cout << "class: RANGER" << endl;
    703          else {
    704             cout << "Unknown player class detected" << endl;
     586         bool validClass = false;
     587
     588         switch(playerClass) {
     589            case Player::CLASS_WARRIOR:
     590            case Player::CLASS_RANGER:
     591               validClass = true;
     592               break;
     593            default:
     594               validClass = false;
     595               break;
     596         }
     597
     598         serverMsg.type = MSG_TYPE_REGISTER;
     599
     600         if (validClass) {
     601            int error = da.insertPlayer(username, password, playerClass);
     602
     603            if (error)
     604               strcpy(serverMsg.buffer, "Registration failed. Please try again.");
     605            else
     606               strcpy(serverMsg.buffer, "Registration successful.");
     607         }else
    705608            strcpy(serverMsg.buffer, "You didn't select a class");
    706             break;
    707          }
    708 
    709          int error = da.insertPlayer(username, password, playerClass);
    710 
    711          if (error)
    712             strcpy(serverMsg.buffer, "Registration failed. Please try again.");
    713          else
    714             strcpy(serverMsg.buffer, "Registration successful.");
     609
     610         msgProcessor.sendMessage(&serverMsg, &from);
    715611
    716612         break;
    … …  
    748644
    749645            serverMsg.type = MSG_TYPE_PLAYER;
    750 
    751646            // tell the new player about all the existing players
    752647            cout << "Sending other players to new player" << endl;
    … …  
    759654               cout << "sending info about " << it->second->name  << endl;
    760655               cout << "sending id " << it->second->id  << endl;
    761                if ( msgProcessor.sendMessage(&serverMsg, sock, &from, &outputLog) < 0 )
    762                   error("sendMessage");
     656               msgProcessor.sendMessage(&serverMsg, &from);
    763657            }
    764658
    … …  
    772666               itObjects->serialize(serverMsg.buffer);
    773667               cout << "sending item id " << itObjects->id  << endl;
    774                if ( msgProcessor.sendMessage(&serverMsg, sock, &from, &outputLog) < 0 )
    775                   error("sendMessage");
     668               msgProcessor.sendMessage(&serverMsg, &from);
    776669            }
    777670
    … …  
    788681               memcpy(serverMsg.buffer, &numPlayers, 4);
    789682               strcpy(serverMsg.buffer+4, g->getName().c_str());
    790                if ( msgProcessor.sendMessage(&serverMsg, sock, &from, &outputLog) < 0 )
    791                   error("sendMessage");
     683               msgProcessor.sendMessage(&serverMsg, &from);
    792684            }
    793685
    … …  
    796688            memcpy(serverMsg.buffer, &scoreBlue, 4);
    797689            memcpy(serverMsg.buffer+4, &scoreRed, 4);
    798             if ( msgProcessor.sendMessage(&serverMsg, sock, &from, &outputLog) < 0 )
    799                error("sendMessage");
     690            msgProcessor.sendMessage(&serverMsg, &from);
    800691
    801692            serverMsg.type = MSG_TYPE_PLAYER;
    802693            p->serialize(serverMsg.buffer);
    803             cout << "Should be broadcasting the message" << endl;
    804 
    805             for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
    806             {
    807                cout << "Sent message back to " << it->second->name << endl;
    808                if ( msgProcessor.sendMessage(&serverMsg, sock, &(it->second->addr), &outputLog) < 0 )
    809                   error("sendMessage");
    810             }
     694            broadcastMessage(msgProcessor, serverMsg, mapPlayers);
    811695
    812696            mapPlayers[unusedPlayerId] = p;
    … …  
    814698
    815699         serverMsg.type = MSG_TYPE_LOGIN;
     700         msgProcessor.sendMessage(&serverMsg, &from);
    816701
    817702         break;
    … …  
    845730
    846731               if (flagType != WorldMap::OBJECT_NONE) {
    847                   addObjectToMap(flagType, p->pos.x, p->pos.y, gameMap, mapPlayers, msgProcessor, sock, outputLog);
     732                  addObjectToMap(flagType, p->pos.x, p->pos.y, gameMap, mapPlayers, msgProcessor);
    848733               }
    849734            }
    … …  
    853738            memcpy(serverMsg.buffer, &p->id, 4);
    854739
    855             map<unsigned int, Player*>::iterator it;
    856             for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
    857             {
    858                cout << "Sent message back to " << it->second->name << endl;
    859                if ( msgProcessor.sendMessage(&serverMsg, sock, &(it->second->addr), &outputLog) < 0 )
    860                   error("sendMessage");
    861             }
     740            broadcastMessage(msgProcessor, serverMsg, mapPlayers);
    862741
    863742            if (p->id < unusedPlayerId)
    864743               unusedPlayerId = p->id;
     744
    865745            mapPlayers.erase(p->id);
    866746            delete p;
     747
    867748            strcpy(serverMsg.buffer+4, "You have successfully logged out.");
    868749         }
    869750
    870751         serverMsg.type = MSG_TYPE_LOGOUT;
     752         msgProcessor.sendMessage(&serverMsg, &from);
    871753
    872754         break;
    … …  
    875757      {
    876758         cout << "Got a chat message" << endl;
     759
     760         serverMsg.type = MSG_TYPE_CHAT;
    877761
    878762         Player *p = findPlayerByAddr(mapPlayers, from);
    … …  
    881765         {
    882766            strcpy(serverMsg.buffer, "No player is logged in using this connection. This is either a bug, or you're trying to hack the server.");
     767            msgProcessor.sendMessage(&serverMsg, &from);
    883768         }
    884769         else
    885770         {
    886             broadcastResponse = true;
    887 
    888771            ostringstream oss;
    889772            oss << p->name << ": " << clientMsg.buffer;
    890773
    891774            strcpy(serverMsg.buffer, oss.str().c_str());
     775            broadcastMessage(msgProcessor, serverMsg, mapPlayers);
    892776         }     
    893 
    894          serverMsg.type = MSG_TYPE_CHAT;
    895777
    896778         break;
    … …  
    911793         
    912794         Player* p = mapPlayers[id];
     795         bool validMessage = false;
    913796
    914797         if ( p->addr.sin_addr.s_addr == from.sin_addr.s_addr &&
    … …  
    922805               memcpy(serverMsg.buffer+8, &p->target.y, 4);
    923806
    924                broadcastResponse = true;
     807               broadcastMessage(msgProcessor, serverMsg, mapPlayers);
     808
     809               validMessage = true;
    925810            }
    926811            else
    927812               cout << "Bad terrain detected" << endl;
    928813         }
    929          else  // nned to send back a message indicating failure
     814         else
    930815            cout << "Player id (" << id << ") doesn't match sender" << endl;
     816
     817         if (!validMessage)
     818            msgProcessor.sendMessage(&serverMsg, &from);
    931819
    932820         break;
    … …  
    946834
    947835         if (objectId >= 0) {
     836            map<unsigned int, Player*> players = p->currentGame->getPlayers();
     837
    948838            serverMsg.type = MSG_TYPE_REMOVE_OBJECT;
    949839            memcpy(serverMsg.buffer, &objectId, 4);
    950 
    951             map<unsigned int, Player*> players = p->currentGame->getPlayers();
    952             map<unsigned int, Player*>::iterator it;
    953             for (it = players.begin(); it != players.end(); it++)
    954             {
    955                if ( msgProcessor.sendMessage(&serverMsg, sock, &(it->second->addr), &outputLog) < 0 )
    956                   error("sendMessage");
    957             }
    958 
    959          }
    960 
    961          // if there was no flag to pickup, we really don't need to send a message
    962          serverMsg.type = MSG_TYPE_PLAYER;
    963          p->serialize(serverMsg.buffer);
    964 
    965          broadcastResponse = true;
     840            broadcastMessage(msgProcessor, serverMsg, players);
     841
     842            serverMsg.type = MSG_TYPE_PLAYER;
     843            p->serialize(serverMsg.buffer);
     844            broadcastMessage(msgProcessor, serverMsg, players);
     845         }
    966846
    967847         break;
    … …  
    985865            flagType = WorldMap::OBJECT_RED_FLAG;
    986866
    987          addObjectToMap(flagType, p->pos.x, p->pos.y, p->currentGame->getMap(), p->currentGame->getPlayers(), msgProcessor, sock, outputLog);
     867         map<unsigned int, Player*> players = p->currentGame->getPlayers();
     868
     869         addObjectToMap(flagType, p->pos.x, p->pos.y, p->currentGame->getMap(), players, msgProcessor);
    988870
    989871         p->hasBlueFlag = false;
    … …  
    992874         serverMsg.type = MSG_TYPE_PLAYER;
    993875         p->serialize(serverMsg.buffer);
    994 
    995          broadcastResponse = true;
     876         broadcastMessage(msgProcessor, serverMsg, players);
    996877
    997878         break;
    … …  
    1008889         // need to make sure the target is in the sender's game
    1009890
    1010          Player* source = mapPlayers[id];
    1011          source->targetPlayer = targetId;
    1012          source->isChasing = true;
    1013 
    1014          // this is irrelevant since the client doesn't even listen for START_ATTACK messages
    1015          // actually, the client should not ignore this and should instead perform the same movement
    1016          // algorithm on its end (following the target player until in range) that the server does.
    1017          // Once the attacker is in range, the client should stop movement and wait for messages
    1018          // from the server
     891         Player* p = mapPlayers[id];
     892         p->targetPlayer = targetId;
     893         p->isChasing = true;
     894
     895         map<unsigned int, Player*> players = p->currentGame->getPlayers();
     896
    1019897         serverMsg.type = MSG_TYPE_START_ATTACK;
    1020898         memcpy(serverMsg.buffer, &id, 4);
    1021899         memcpy(serverMsg.buffer+4, &targetId, 4);
    1022          broadcastResponse = true;
    1023 
    1024          break;
    1025       }
    1026       case MSG_TYPE_ATTACK:
    1027       {
    1028          cout << "Received am ATTACK message" << endl;
    1029          cout << "ERROR: Clients should not send ATTACK messages" << endl;
     900         broadcastMessage(msgProcessor, serverMsg, players);
    1030901
    1031902         break;
    … …  
    1042913            cout << "Error: Game already exists" << endl;
    1043914            serverMsg.type = MSG_TYPE_JOIN_GAME_FAILURE;
    1044             broadcastResponse = false;
    1045             return broadcastResponse;
    1046          }
    1047 
    1048          Game* g = new Game(gameName, "../data/map.txt");
    1049          mapGames[gameName] = g;
    1050 
    1051          // add flag objects to the map
    1052          WorldMap* m = g->getMap();
    1053          for (int y=0; y<m->height; y++) {
    1054             for (int x=0; x<m->width; x++) {
    1055                switch (m->getStructure(x, y)) {
    1056                   case WorldMap::STRUCTURE_BLUE_FLAG:
    1057                      m->addObject(WorldMap::OBJECT_BLUE_FLAG, x*25+12, y*25+12);
    1058                      break;
    1059                   case WorldMap::STRUCTURE_RED_FLAG:
    1060                      m->addObject(WorldMap::OBJECT_RED_FLAG, x*25+12, y*25+12);
    1061                      break;
     915         }else {
     916            Game* g = new Game(gameName, "../data/map.txt");
     917            mapGames[gameName] = g;
     918
     919            // add flag objects to the map
     920            WorldMap* m = g->getMap();
     921            for (int y=0; y<m->height; y++) {
     922               for (int x=0; x<m->width; x++) {
     923                  switch (m->getStructure(x, y)) {
     924                     case WorldMap::STRUCTURE_BLUE_FLAG:
     925                        m->addObject(WorldMap::OBJECT_BLUE_FLAG, x*25+12, y*25+12);
     926                        break;
     927                     case WorldMap::STRUCTURE_RED_FLAG:
     928                        m->addObject(WorldMap::OBJECT_RED_FLAG, x*25+12, y*25+12);
     929                        break;
     930                  }
    1062931               }
    1063932            }
    1064          }
    1065 
    1066          serverMsg.type = MSG_TYPE_JOIN_GAME_SUCCESS;
    1067          strcpy(serverMsg.buffer, gameName.c_str());
    1068          broadcastResponse = false;
     933
     934            serverMsg.type = MSG_TYPE_JOIN_GAME_SUCCESS;
     935            strcpy(serverMsg.buffer, gameName.c_str());
     936         }
     937
     938         msgProcessor.sendMessage(&serverMsg, &from);
    1069939
    1070940         break;
    … …  
    1081951            cout << "Error: Game does not exist" << endl;
    1082952            serverMsg.type = MSG_TYPE_JOIN_GAME_FAILURE;
    1083             broadcastResponse = false;
    1084             return broadcastResponse;
    1085          }
    1086 
    1087          Game* g = mapGames[gameName];
    1088          map<unsigned int, Player*>& players = g->getPlayers();
    1089          Player* p = findPlayerByAddr(mapPlayers, from);
    1090 
    1091          if (players.find(p->id) != players.end()) {
    1092             cout << "Player " << p->name << " trying to join a game he's already in" << endl;
    1093             serverMsg.type = MSG_TYPE_JOIN_GAME_FAILURE;
    1094             broadcastResponse = false;
    1095             return broadcastResponse;
    1096          }
    1097 
    1098          serverMsg.type = MSG_TYPE_JOIN_GAME_SUCCESS;
    1099          strcpy(serverMsg.buffer, gameName.c_str());
    1100          broadcastResponse = false;
     953         }else {
     954            Game* g = mapGames[gameName];
     955            map<unsigned int, Player*>& players = g->getPlayers();
     956            Player* p = findPlayerByAddr(mapPlayers, from);
     957
     958            if (players.find(p->id) != players.end()) {
     959               cout << "Player " << p->name << " trying to join a game he's already in" << endl;
     960               serverMsg.type = MSG_TYPE_JOIN_GAME_FAILURE;
     961            }else {
     962               serverMsg.type = MSG_TYPE_JOIN_GAME_SUCCESS;
     963               strcpy(serverMsg.buffer, gameName.c_str());
     964            }
     965         }
     966
     967         msgProcessor.sendMessage(&serverMsg, &from);
    1101968
    1102969         break;
    … …  
    1113980
    1114981            /// should send a response back, maybe a new message type is needed
    1115 
    1116             break;
    1117          }
    1118 
    1119          cout << "Game name: " << g->getName() << endl;
    1120          p->currentGame = NULL;
    1121 
    1122          serverMsg.type = MSG_TYPE_LEAVE_GAME;
    1123          memcpy(serverMsg.buffer, &p->id, 4);
    1124          strcpy(serverMsg.buffer+4, g->getName().c_str());
    1125 
    1126          map<unsigned int, Player*>& players = g->getPlayers();
    1127 
    1128          map<unsigned int, Player*>::iterator it;
    1129          for (it = players.begin(); it != players.end(); it++)
    1130          {
    1131             if ( msgProcessor.sendMessage(&serverMsg, sock, &(it->second->addr), &outputLog) < 0 )
    1132                error("sendMessage");
    1133          }
    1134 
    1135          g->removePlayer(p->id);
    1136 
    1137          int numPlayers = g->getNumPlayers();
    1138 
    1139          serverMsg.type = MSG_TYPE_GAME_INFO;
    1140          memcpy(serverMsg.buffer, &numPlayers, 4);
    1141          strcpy(serverMsg.buffer+4, g->getName().c_str());
    1142          broadcastResponse = true;
    1143 
    1144          // if there are no more players in the game, remove it
    1145          if (numPlayers == 0) {
    1146             mapGames.erase(g->getName());
    1147             delete g;
     982            // not sure what to do here
     983         }else {
     984            cout << "Game name: " << g->getName() << endl;
     985            p->currentGame = NULL;
     986
     987            serverMsg.type = MSG_TYPE_LEAVE_GAME;
     988            memcpy(serverMsg.buffer, &p->id, 4);
     989            strcpy(serverMsg.buffer+4, g->getName().c_str());
     990            broadcastMessage(msgProcessor, serverMsg, g->getPlayers());
     991
     992            g->removePlayer(p->id);
     993
     994            int numPlayers = g->getNumPlayers();
     995
     996            serverMsg.type = MSG_TYPE_GAME_INFO;
     997            memcpy(serverMsg.buffer, &numPlayers, 4);
     998            strcpy(serverMsg.buffer+4, g->getName().c_str());
     999            broadcastMessage(msgProcessor, serverMsg, mapPlayers);
     1000
     1001            // if there are no more players in the game, remove it
     1002            if (numPlayers == 0) {
     1003               mapGames.erase(g->getName());
     1004               delete g;
     1005            }
    11481006         }
    11491007
    … …  
    11601018         if (mapGames.find(gameName) == mapGames.end()) {
    11611019            serverMsg.type = MSG_TYPE_JOIN_GAME_FAILURE;
    1162             broadcastResponse = false;
    1163             return broadcastResponse;
     1020
     1021            msgProcessor.sendMessage(&serverMsg, &from);
    11641022         }
    11651023
    … …  
    11801038            itObjects->serialize(serverMsg.buffer);
    11811039            cout << "sending item id " << itObjects->id  << endl;
    1182             if ( msgProcessor.sendMessage(&serverMsg, sock, &from, &outputLog) < 0 )
    1183                error("sendMessage");
     1040            msgProcessor.sendMessage(&serverMsg, &from);
    11841041         }
    11851042
    … …  
    11931050         memcpy(serverMsg.buffer+4, &game_redScore, 4);
    11941051
    1195          if ( msgProcessor.sendMessage(&serverMsg, sock, &from, &outputLog) < 0 )
    1196             error("sendMessage");
    1197 
     1052         msgProcessor.sendMessage(&serverMsg, &from);
     1053
     1054         // send info to other players
    11981055         serverMsg.type = MSG_TYPE_PLAYER_JOIN_GAME;
    11991056         p->serialize(serverMsg.buffer);
    12001057         cout << "Should be broadcasting the message" << endl;
    1201 
    1202          map<unsigned int, Player*>& otherPlayers = g->getPlayers();
    1203          map<unsigned int, Player*>::iterator it;
    1204          for (it = otherPlayers.begin(); it != otherPlayers.end(); it++)
    1205          {
    1206             cout << "Sent message back to " << it->second->name << endl;
    1207             if ( msgProcessor.sendMessage(&serverMsg, sock, &(it->second->addr), &outputLog) < 0 )
    1208                error("sendMessage");
    1209          }
     1058         broadcastMessage(msgProcessor, serverMsg, g->getPlayers());
    12101059
    12111060         g->addPlayer(p);
    12121061
    1213          map<unsigned int, Player*>& allPlayers = g->getPlayers();
    12141062
    12151063         // tell the new player about all the players in the game (including himself)
    … …  
    12171065         serverMsg.type = MSG_TYPE_PLAYER_JOIN_GAME;
    12181066
     1067         
     1068         map<unsigned int, Player*>& allPlayers = g->getPlayers();
     1069         map<unsigned int, Player*>::iterator it;
    12191070         for (it = allPlayers.begin(); it != allPlayers.end(); it++)
    12201071         {
    … …  
    12231074            cout << "sending info about " << it->second->name  << endl;
    12241075            cout << "sending id " << it->second->id  << endl;
    1225             if ( msgProcessor.sendMessage(&serverMsg, sock, &from, &outputLog) < 0 )
    1226                error("sendMessage");
     1076            msgProcessor.sendMessage(&serverMsg, &from);
    12271077         }
    12281078
    … …  
    12321082         memcpy(serverMsg.buffer, &numPlayers, 4);
    12331083         strcpy(serverMsg.buffer+4, gameName.c_str());
    1234          broadcastResponse = true;
     1084         broadcastMessage(msgProcessor, serverMsg, mapPlayers);
    12351085
    12361086         break;
    … …  
    12381088      default:
    12391089      {
     1090         // probably want to log the error rather than sending a chat message,
     1091         // especially since chat isn't currently visible on all screens
     1092
    12401093         serverMsg.type = MSG_TYPE_CHAT;
    12411094         strcpy(serverMsg.buffer, "Server error occured. Report this please.");
    … …  
    12441097      }
    12451098   }
    1246 
    1247    return broadcastResponse;
     1099}
     1100
     1101void broadcastMessage(MessageProcessor &msgProcessor, NETWORK_MSG &serverMsg, map<unsigned int, Player*>& players) {
     1102   map<unsigned int, Player*>::iterator it;
     1103   for (it = players.begin(); it != players.end(); it++) {
     1104      msgProcessor.sendMessage(&serverMsg, &(it->second->addr));
     1105   }
    12481106}
    12491107
    … …  
    12921150}
    12931151
    1294 void addObjectToMap(WorldMap::ObjectType objectType, int x, int y, WorldMap* gameMap, map<unsigned int, Player*>& mapPlayers, MessageProcessor &msgProcessor, int sock, ofstream& outputLog) {
     1152void addObjectToMap(WorldMap::ObjectType objectType, int x, int y, WorldMap* gameMap, map<unsigned int, Player*>& mapPlayers, MessageProcessor &msgProcessor) {
    12951153   NETWORK_MSG serverMsg;
    12961154
    12971155   gameMap->addObject(objectType, x, y);
    12981156
    1299    // need to send the OBJECT message too
    13001157   serverMsg.type = MSG_TYPE_OBJECT;
    13011158   gameMap->getObjects()->back().serialize(serverMsg.buffer);
    13021159
    1303    map<unsigned int, Player*>::iterator it;
    1304    for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
    1305    {
    1306       if ( msgProcessor.sendMessage(&serverMsg, sock, &(it->second->addr), &outputLog) < 0 )
    1307          error("sendMessage");
    1308    }
     1160   broadcastMessage(msgProcessor, serverMsg, mapPlayers);
    13091161}
Note: See TracChangeset for help on using the changeset viewer.