Changeset d05c484 in network-game

Timestamp:

Jan 19, 2014, 7:40:55 PM (11 years ago)

Author:

dportnoy <dmp1488@…>

Branches:

master

Children:

e5697b1

Parents:

6054f1e

Message:

Some game-specific functions moved from server.cpp to the Game class and a function moved to the MessageProcessor class

Files:

• common/Game.cpp (modified) (5 diffs)
• common/Game.h (modified) (4 diffs)
• common/MessageProcessor.cpp (modified) (1 diff)
• common/MessageProcessor.h (modified) (2 diffs)
• server/makefile (modified) (1 diff)
• server/server.cpp (modified) (24 diffs)

common/Game.cpp

@@ -1 +1 @@
 #include "Game.h"
+
+#include <iostream>
+#include <cstring>
 
 #include "Common.h"
@@ -11 +14 @@
    this->redScore = 0;
    this->worldMap = NULL;
-}
-
-Game::Game(string name, string filepath) {
+   this->msgProcessor = NULL;
+}
+
+Game::Game(string name, string filepath, MessageProcessor* msgProcessor) {
    this->id = 0;
    this->name = name;
@@ -19 +23 @@
    this->redScore = 0;
    this->worldMap = WorldMap::loadMapFromFile(filepath);
+   this->msgProcessor = msgProcessor;
 }
 
@@ -95 +100 @@
 void Game::setBlueScore(unsigned int score) {
    this->blueScore = score;
+}
+
+void Game::addObjectToMap(WorldMap::ObjectType objectType, int x, int y) {
+   NETWORK_MSG serverMsg;
+
+   this->getMap()->addObject(objectType, x, y);
+
+   serverMsg.type = MSG_TYPE_OBJECT;
+   this->worldMap->getObjects()->back().serialize(serverMsg.buffer);
+
+   this->msgProcessor->broadcastMessage(serverMsg, this->players);
 }
 
@@ -175 +191 @@
 }
 
+void Game::dealDamageToPlayer(Player* p, int damage) {
+   p->takeDamage(damage);
+
+   if (p->isDead)
+   {
+      WorldMap::ObjectType flagType = WorldMap::OBJECT_NONE;
+      if (p->hasBlueFlag)
+         flagType = WorldMap::OBJECT_BLUE_FLAG;
+      else if (p->hasRedFlag)
+         flagType = WorldMap::OBJECT_RED_FLAG;
+
+      if (flagType != WorldMap::OBJECT_NONE)
+         this->addObjectToMap(flagType, p->pos.x, p->pos.y);
+   }
+
+   // send a PLAYER message after dealing damage
+   NETWORK_MSG serverMsg;
+   serverMsg.type = MSG_TYPE_PLAYER;
+   p->serialize(serverMsg.buffer);
+   msgProcessor->broadcastMessage(serverMsg, this->players);
+}
+
+bool Game::handleGameEvents() {
+   NETWORK_MSG serverMsg;
+   map<unsigned int, Player*>::iterator it;
+   bool gameFinished = false;
+
+   for (it = this->getPlayers().begin(); it != this->getPlayers().end(); it++)
+   {
+      gameFinished = gameFinished ||
+         this->handlePlayerEvents(it->second);
+   }
+
+   if (gameFinished) {
+      for (it = this->players.begin(); it != this->players.end(); it++)
+      {
+         it->second->currentGame = NULL;
+      }
+   }
+
+   return gameFinished;
+}
+
+bool Game::handlePlayerEvents(Player* p) {
+   NETWORK_MSG serverMsg;
+   FLOAT_POSITION oldPos;
+   bool gameFinished = false;
+   bool broadcastMove = false;
+
+   cout << "moving player" << endl;
+
+   // move player and perform associated tasks
+   oldPos = p->pos;
+   if (p->move(this->worldMap)) {
+
+      cout << "player moved" << endl;
+      if (this->processPlayerMovement(p, oldPos))
+         broadcastMove = true;
+      cout << "player move processed" << endl;
+
+      WorldMap::ObjectType flagType;
+      POSITION pos;
+      bool flagTurnedIn = false;
+      bool flagReturned = false;
+      bool ownFlagAtBase = false;
+
+      switch(this->worldMap->getStructure(p->pos.x/25, p->pos.y/25))
+      {
+         case WorldMap::STRUCTURE_BLUE_FLAG:
+         {
+            if (p->team == 0 && p->hasRedFlag)
+            {
+               // check that your flag is at your base
+               pos = this->worldMap->getStructureLocation(WorldMap::STRUCTURE_BLUE_FLAG);
+                           
+               vector<WorldMap::Object>* vctObjects = this->worldMap->getObjects();
+               vector<WorldMap::Object>::iterator itObjects;
+
+               for (itObjects = vctObjects->begin(); itObjects != vctObjects->end(); itObjects++)
+               {
+                  if (itObjects->type == WorldMap::OBJECT_BLUE_FLAG)
+                  {
+                     if (itObjects->pos.x == pos.x*25+12 && itObjects->pos.y == pos.y*25+12)
+                     {
+                        ownFlagAtBase = true;
+                        break;
+                     }
+                  }
+               }
+
+               if (ownFlagAtBase)
+               {
+                  p->hasRedFlag = false;
+                  flagType = WorldMap::OBJECT_RED_FLAG;
+                  pos = this->worldMap->getStructureLocation(WorldMap::STRUCTURE_RED_FLAG);
+                  flagTurnedIn = true;
+                  this->blueScore++;
+               }
+            }
+
+            break;
+         }
+         case WorldMap::STRUCTURE_RED_FLAG:
+         {
+            if (p->team == 1 && p->hasBlueFlag)
+            {
+               // check that your flag is at your base
+               pos = this->worldMap->getStructureLocation(WorldMap::STRUCTURE_RED_FLAG);
+                        
+               vector<WorldMap::Object>* vctObjects = this->worldMap->getObjects();
+               vector<WorldMap::Object>::iterator itObjects;
+
+               for (itObjects = vctObjects->begin(); itObjects != vctObjects->end(); itObjects++)
+               {
+                  if (itObjects->type == WorldMap::OBJECT_RED_FLAG)
+                  {
+                     if (itObjects->pos.x == pos.x*25+12 && itObjects->pos.y == pos.y*25+12)
+                     {
+                        ownFlagAtBase = true;
+                        break;
+                     }
+                  }
+               }
+
+               if (ownFlagAtBase)
+               {
+                  p->hasBlueFlag = false;
+                  flagType = WorldMap::OBJECT_BLUE_FLAG;
+                  pos = this->worldMap->getStructureLocation(WorldMap::STRUCTURE_BLUE_FLAG);
+                  flagTurnedIn = true;
+                  this->redScore++;
+               }
+            }
+
+            break;
+         }
+      }
+
+      if (flagTurnedIn)
+      {
+         unsigned int blueScore = this->blueScore;
+         unsigned int redScore = this->redScore;
+
+         pos.x = pos.x*25+12;
+         pos.y = pos.y*25+12;
+         this->addObjectToMap(flagType, pos.x, pos.y);
+
+         serverMsg.type = MSG_TYPE_SCORE;
+         memcpy(serverMsg.buffer, &blueScore, 4);
+         memcpy(serverMsg.buffer+4, &redScore, 4);
+         msgProcessor->broadcastMessage(serverMsg, this->players);
+
+         // check to see if the game should end
+         // move to its own method
+         if (this->blueScore == 3 || this->redScore == 3) {
+            gameFinished = true;
+
+            unsigned int winningTeam;
+            if (this->blueScore == 3)
+               winningTeam = 0;
+            else if (this->redScore == 3)
+               winningTeam = 1;
+
+            serverMsg.type = MSG_TYPE_FINISH_GAME;
+
+            // I should create an instance of the GameSummary object here and just serialize it into this message
+            memcpy(serverMsg.buffer, &winningTeam, 4);
+            memcpy(serverMsg.buffer+4, &blueScore, 4);
+            memcpy(serverMsg.buffer+8, &redScore, 4);
+            strcpy(serverMsg.buffer+12, this->getName().c_str());
+            msgProcessor->broadcastMessage(serverMsg, this->players);
+         }
+
+         // this means a PLAYER message will be sent
+         broadcastMove = true;
+      }
+
+      // go through all objects and check if the player is close to one and if its their flag
+      vector<WorldMap::Object>* vctObjects = this->worldMap->getObjects();
+      vector<WorldMap::Object>::iterator itObjects;
+      POSITION structPos;
+
+      for (itObjects = vctObjects->begin(); itObjects != vctObjects->end(); itObjects++)
+      {
+         POSITION pos = itObjects->pos;
+
+         if (posDistance(p->pos, pos.toFloat()) < 10)
+         {
+            if (p->team == 0 && 
+                itObjects->type == WorldMap::OBJECT_BLUE_FLAG)
+            {
+               structPos = this->worldMap->getStructureLocation(WorldMap::STRUCTURE_BLUE_FLAG);
+               flagReturned = true;
+               break;
+            }
+            else if (p->team == 1 &&
+                     itObjects->type == WorldMap::OBJECT_RED_FLAG)
+            {
+               structPos = this->worldMap->getStructureLocation(WorldMap::STRUCTURE_RED_FLAG);
+               flagReturned = true;
+               break;
+            }
+         }
+      }
+
+      if (flagReturned)
+      {
+         itObjects->pos.x = structPos.x*25+12;
+         itObjects->pos.y = structPos.y*25+12;
+
+         serverMsg.type = MSG_TYPE_OBJECT;
+         itObjects->serialize(serverMsg.buffer);
+         msgProcessor->broadcastMessage(serverMsg, this->players);
+      }
+
+      if (broadcastMove)
+      {
+         serverMsg.type = MSG_TYPE_PLAYER;
+         p->serialize(serverMsg.buffer);
+         msgProcessor->broadcastMessage(serverMsg, this->players);
+      }
+   }
+
+   cout << "processing player attack" << endl;
+
+   // check if the player's attack animation is complete
+   if (p->isAttacking && p->timeAttackStarted+p->attackCooldown <= getCurrentMillis())
+   {
+      p->isAttacking = false;
+      cout << "Attack animation is complete" << endl;
+
+      //send everyone an ATTACK message
+      cout << "about to broadcast attack" << endl;
+
+      if (p->attackType == Player::ATTACK_MELEE)
+      {
+         cout << "Melee attack" << endl;
+
+         Player* target = players[p->targetPlayer];
+         this->dealDamageToPlayer(target, p->damage);
+      }
+      else if (p->attackType == Player::ATTACK_RANGED)
+      {
+         cout << "Ranged attack" << endl;
+
+         Projectile proj(p->pos.x, p->pos.y, p->targetPlayer, p->damage);
+         this->assignProjectileId(&proj);
+         this->addProjectile(proj);
+
+         int x = p->pos.x;
+         int y = p->pos.y;
+
+         serverMsg.type = MSG_TYPE_PROJECTILE;
+         memcpy(serverMsg.buffer, &proj.id, 4);
+         memcpy(serverMsg.buffer+4, &x, 4);
+         memcpy(serverMsg.buffer+8, &y, 4);
+         memcpy(serverMsg.buffer+12, &p->targetPlayer, 4);
+         msgProcessor->broadcastMessage(serverMsg, players);
+      }
+      else
+         cout << "Invalid attack type: " << p->attackType << endl;
+   }
+
+   return gameFinished;
+}
+
 void Game::assignProjectileId(Projectile* p) {
    p->id = unusedProjectileId;

common/Game.h

@@ -14 +14 @@
 #include "WorldMap.h"
 #include "Projectile.h"
+#include "MessageProcessor.h"
 
 using namespace std;
@@ -27 +28 @@
    unsigned int redScore;
    unsigned int unusedProjectileId;
+   MessageProcessor* msgProcessor;
 
 public:
    Game();
-   Game(string name, string filepath);
+   Game(string name, string filepath, MessageProcessor* msgProcessor);
 
    ~Game();
@@ -44 +46 @@
    void setRedScore(unsigned int score);
 
+   void addObjectToMap(WorldMap::ObjectType objectType, int x, int y);
+
    map<unsigned int, Player*>& getPlayers();
    bool addPlayer(Player* p);
@@ -55 +59 @@
    bool processPlayerMovement(Player* p, FLOAT_POSITION oldPos);
    int processFlagPickupRequest(Player* p);
+   void dealDamageToPlayer(Player* p, int damage);
+
+   bool handleGameEvents();
+   bool handlePlayerEvents(Player* p);
 
    void assignProjectileId(Projectile* p);

common/MessageProcessor.cpp

@@ -95 +95 @@
 }
 
+void MessageProcessor::broadcastMessage(NETWORK_MSG &msg, map<unsigned int, Player*>& players) {
+   map<unsigned int, Player*>::iterator it;
+   for (it = players.begin(); it != players.end(); it++) {
+      this->sendMessage(&msg, &(it->second->addr));
+   }
+}
+
 void MessageProcessor::resendUnackedMessages() {
    map<unsigned int, map<unsigned long, MessageContainer> >::iterator it;

common/MessageProcessor.h

@@ -5 +5 @@
 
 #include "MessageContainer.h"
+#include "Player.h"
 
 using namespace std;
@@ -29 +30 @@
    int sendMessage(NETWORK_MSG *msg, struct sockaddr_in *dest);
    int receiveMessage(NETWORK_MSG *msg, struct sockaddr_in *source);
+   void broadcastMessage(NETWORK_MSG &msg, map<unsigned int, Player*>& players);
    void resendUnackedMessages();
    void cleanAckedMessages();

server/makefile

@@ -2 +2 @@
 #LIB_FLAGS = -lssl -lmysqlclient -lcrypt -lrt
 LIB_FLAGS = -lmysqlclient -lcrypt -lrt
-FLAGS = $(LIB_FLAGS)
+FLAGS = -Wall $(LIB_FLAGS)
 COMMON_PATH = ../common
 DEPENDENCIES = Common.o MessageContainer.o MessageProcessor.o Player.o WorldMap.o DataAccess.o Projectile.o Game.o GameSummary.o

server/server.cpp

@@ -46 +46 @@
 void processMessage(const NETWORK_MSG& clientMsg, struct sockaddr_in& from, MessageProcessor& msgProcessor, map<unsigned int, Player*>& mapPlayers, map<string, Game*>& mapGames, unsigned int& unusedPlayerId);
 
-bool handleGameEvents(Game* game, map<unsigned int, Player*>& mapPlayers, MessageProcessor& msgPocessor);
-bool handlePlayerEvents(Player* p, Game* game, MessageProcessor& msgProcessor);
-
-void broadcastMessage(MessageProcessor &msgProcessor, NETWORK_MSG &serverMsg, map<unsigned int, Player*>& players);
 void updateUnusedPlayerId(unsigned int& id, map<unsigned int, Player*>& mapPlayers);
 Player *findPlayerByName(map<unsigned int, Player*> &m, string name);
 Player *findPlayerByAddr(map<unsigned int, Player*> &m, const sockaddr_in &addr);
-
-void addObjectToMap(WorldMap::ObjectType objectType, int x, int y, WorldMap* gameMap, map<unsigned int, Player*>& mapPlayers, MessageProcessor &msgProcessor);
 
 void quit(int sig);
@@ -70 +64 @@
    map<unsigned int, Projectile> mapProjectiles;
    map<string, Game*> mapGames;
-   unsigned int unusedPlayerId = 1, unusedProjectileId = 1;
+   unsigned int unusedPlayerId = 1;
    ofstream outputLog;
 
@@ -106 +100 @@
 
    timespec ts;
-   int timeLastUpdated = 0, curTime = 0, timeLastBroadcast = 0;
+   int timeLastUpdated = 0, curTime = 0;
    while (!done)
    {
@@ -169 +163 @@
                   p->serialize(serverMsg.buffer);
 
-                  broadcastMessage(msgProcessor, serverMsg, p->currentGame->getPlayers());
+                  msgProcessor.broadcastMessage(serverMsg, p->currentGame->getPlayers());
                }
 
@@ -181 +175 @@
                   serverMsg.type = MSG_TYPE_PLAYER;
                   p->serialize(serverMsg.buffer);
-                  broadcastMessage(msgProcessor, serverMsg, playersInGame);
+                  msgProcessor.broadcastMessage(serverMsg, playersInGame);
                }
             }
@@ -193 +187 @@
 
          for (itGames = mapGames.begin(); itGames != mapGames.end();) { 
-            if (handleGameEvents(itGames->second, mapPlayers, msgProcessor)) {
+            game = itGames->second;
+            if (game->handleGameEvents()) {
+               // send a GAME_INFO message with 0 players to force clients to delete the game
+               int numPlayers = 0;
+               serverMsg.type = MSG_TYPE_GAME_INFO;
+               memcpy(serverMsg.buffer, &numPlayers, 4);
+               strcpy(serverMsg.buffer+4, game->getName().c_str());
+               msgProcessor.broadcastMessage(serverMsg, mapPlayers);
+
                delete itGames->second;
                mapGames.erase(itGames++);
@@ -218 +220 @@
                   memcpy(serverMsg.buffer, &itProj->second.id, 4);
                   game->removeProjectile(itProj->second.id);
-                  broadcastMessage(msgProcessor, serverMsg, game->getPlayers());
+                  msgProcessor.broadcastMessage(serverMsg, game->getPlayers());
 
                   Player* target = game->getPlayers()[itProj->second.target];
-                  target->takeDamage(itProj->second.damage);
-
-                  if (target->isDead)
-                  {
-                     WorldMap::ObjectType flagType = WorldMap::OBJECT_NONE;
-                     if (target->hasBlueFlag)
-                        flagType = WorldMap::OBJECT_BLUE_FLAG;
-                     else if (target->hasRedFlag)
-                        flagType = WorldMap::OBJECT_RED_FLAG;
-
-                     if (flagType != WorldMap::OBJECT_NONE)
-                        addObjectToMap(flagType, target->pos.x, target->pos.y, game->getMap(), game->getPlayers(), msgProcessor);
-                  }
-
-                  // send a PLAYER message after dealing damage
-                  serverMsg.type = MSG_TYPE_PLAYER;
-                  target->serialize(serverMsg.buffer);
-                  broadcastMessage(msgProcessor, serverMsg, game->getPlayers());
+                  game->dealDamageToPlayer(target, itProj->second.damage);
                }
             }
@@ -387 +372 @@
             serverMsg.type = MSG_TYPE_PLAYER;
             p->serialize(serverMsg.buffer);
-            broadcastMessage(msgProcessor, serverMsg, mapPlayers);
+            msgProcessor.broadcastMessage(serverMsg, mapPlayers);
 
             mapPlayers[unusedPlayerId] = p;
@@ -421 +406 @@
             memcpy(serverMsg.buffer, &p->id, 4);
 
-            broadcastMessage(msgProcessor, serverMsg, mapPlayers);
+            msgProcessor.broadcastMessage(serverMsg, mapPlayers);
 
             if (p->id < unusedPlayerId)
@@ -456 +441 @@
 
             strcpy(serverMsg.buffer, oss.str().c_str());
-            broadcastMessage(msgProcessor, serverMsg, mapPlayers);
+            msgProcessor.broadcastMessage(serverMsg, mapPlayers);
          }      
 
@@ -488 +473 @@
                memcpy(serverMsg.buffer+8, &p->target.y, 4);
 
-               broadcastMessage(msgProcessor, serverMsg, mapPlayers);
+               msgProcessor.broadcastMessage(serverMsg, mapPlayers);
 
                validMessage = true;
@@ -521 +506 @@
             serverMsg.type = MSG_TYPE_REMOVE_OBJECT;
             memcpy(serverMsg.buffer, &objectId, 4);
-            broadcastMessage(msgProcessor, serverMsg, players);
+            msgProcessor.broadcastMessage(serverMsg, players);
 
             serverMsg.type = MSG_TYPE_PLAYER;
             p->serialize(serverMsg.buffer);
-            broadcastMessage(msgProcessor, serverMsg, players);
+            msgProcessor.broadcastMessage(serverMsg, players);
          }
 
@@ -550 +535 @@
          map<unsigned int, Player*> players = p->currentGame->getPlayers();
 
-         addObjectToMap(flagType, p->pos.x, p->pos.y, p->currentGame->getMap(), players, msgProcessor);
+         p->currentGame->addObjectToMap(flagType, p->pos.x, p->pos.y);
 
          p->hasBlueFlag = false;
@@ -557 +542 @@
          serverMsg.type = MSG_TYPE_PLAYER;
          p->serialize(serverMsg.buffer);
-         broadcastMessage(msgProcessor, serverMsg, players);
+         msgProcessor.broadcastMessage(serverMsg, players);
 
          break;
@@ -581 +566 @@
          memcpy(serverMsg.buffer, &id, 4);
          memcpy(serverMsg.buffer+4, &targetId, 4);
-         broadcastMessage(msgProcessor, serverMsg, players);
+         msgProcessor.broadcastMessage(serverMsg, players);
 
          break;
@@ -597 +582 @@
             serverMsg.type = MSG_TYPE_JOIN_GAME_FAILURE;
          }else {
-            Game* g = new Game(gameName, "../data/map.txt");
+            Game* g = new Game(gameName, "../data/map.txt", &msgProcessor);
             mapGames[gameName] = g;
 
@@ -611 +596 @@
                         m->addObject(WorldMap::OBJECT_RED_FLAG, x*25+12, y*25+12);
                         break;
+                     case WorldMap::STRUCTURE_NONE:
+                        break;
                   }
                }
@@ -674 +661 @@
                   flagType = WorldMap::OBJECT_RED_FLAG;
 
-               if (flagType != WorldMap::OBJECT_NONE) {
-                  addObjectToMap(flagType, p->pos.x, p->pos.y, g->getMap(), g->getPlayers(), msgProcessor);
-               }
+               if (flagType != WorldMap::OBJECT_NONE)
+                  g->addObjectToMap(flagType, p->pos.x, p->pos.y);
             }
 
@@ -685 +671 @@
             memcpy(serverMsg.buffer, &p->id, 4);
             strcpy(serverMsg.buffer+4, g->getName().c_str());
-            broadcastMessage(msgProcessor, serverMsg, g->getPlayers());
+            msgProcessor.broadcastMessage(serverMsg, g->getPlayers());
 
             int numPlayers = g->getNumPlayers();
@@ -692 +678 @@
             memcpy(serverMsg.buffer, &numPlayers, 4);
             strcpy(serverMsg.buffer+4, g->getName().c_str());
-            broadcastMessage(msgProcessor, serverMsg, mapPlayers);
+            msgProcessor.broadcastMessage(serverMsg, mapPlayers);
 
             // if there are no more players in the game, remove it
@@ -751 +737 @@
          p->serialize(serverMsg.buffer);
          cout << "Should be broadcasting the message" << endl;
-         broadcastMessage(msgProcessor, serverMsg, g->getPlayers());
+         msgProcessor.broadcastMessage(serverMsg, g->getPlayers());
 
          g->addPlayer(p);
@@ -777 +763 @@
          memcpy(serverMsg.buffer, &numPlayers, 4);
          strcpy(serverMsg.buffer+4, gameName.c_str());
-         broadcastMessage(msgProcessor, serverMsg, mapPlayers);
+         msgProcessor.broadcastMessage(serverMsg, mapPlayers);
 
          break;
@@ -791 +777 @@
          break;
       }
-   }
-}
-
-bool handleGameEvents(Game* game, map<unsigned int, Player*>& mapPlayers, MessageProcessor& msgProcessor) {
-   NETWORK_MSG serverMsg;
-   map<unsigned int, Player*>::iterator it;
-   bool gameFinished = false;
-
-   for (it = game->getPlayers().begin(); it != game->getPlayers().end(); it++)
-   {
-      gameFinished = gameFinished ||
-         handlePlayerEvents(it->second, game, msgProcessor);
-   }
-
-   // set each player's current game to null
-   if (gameFinished) {
-      // send a GAME_INFO message with 0 players to force clients to delete the game
-      int numPlayers = 0;
-      serverMsg.type = MSG_TYPE_GAME_INFO;
-      memcpy(serverMsg.buffer, &numPlayers, 4);
-      strcpy(serverMsg.buffer+4, game->getName().c_str());
-      broadcastMessage(msgProcessor, serverMsg, mapPlayers);
-
-      for (it = game->getPlayers().begin(); it != game->getPlayers().end(); it++)
-      {
-         it->second->currentGame = NULL;
-      }
-   }
-
-   return gameFinished;
-}
-
-bool handlePlayerEvents(Player* p, Game* game, MessageProcessor& msgProcessor) {
-   NETWORK_MSG serverMsg;
-   WorldMap* gameMap = game->getMap();
-   map<unsigned int, Player*>& playersInGame = game->getPlayers();
-   bool gameFinished = false;
-   FLOAT_POSITION oldPos;
-
-   cout << "moving player" << endl;
-   bool broadcastMove = false;
-
-   // move player and perform associated tasks
-   oldPos = p->pos;
-   if (p->move(gameMap)) {
-
-      cout << "player moved" << endl;
-      if (game->processPlayerMovement(p, oldPos))
-         broadcastMove = true;
-      cout << "player move processed" << endl;
-
-      WorldMap::ObjectType flagType;
-      POSITION pos;
-      bool flagTurnedIn = false;
-      bool flagReturned = false;
-      bool ownFlagAtBase = false;
-
-      // need to figure out how to move this to a different file
-      // while still sending back flag type and position
-      switch(gameMap->getStructure(p->pos.x/25, p->pos.y/25))
-      {
-         case WorldMap::STRUCTURE_BLUE_FLAG:
-         {
-            if (p->team == 0 && p->hasRedFlag)
-            {
-               // check that your flag is at your base
-               pos = gameMap->getStructureLocation(WorldMap::STRUCTURE_BLUE_FLAG);
-                           
-               vector<WorldMap::Object>* vctObjects = gameMap->getObjects();
-               vector<WorldMap::Object>::iterator itObjects;
-
-               for (itObjects = vctObjects->begin(); itObjects != vctObjects->end(); itObjects++)
-               {
-                  if (itObjects->type == WorldMap::OBJECT_BLUE_FLAG)
-                  {
-                     if (itObjects->pos.x == pos.x*25+12 && itObjects->pos.y == pos.y*25+12)
-                     {
-                        ownFlagAtBase = true;
-                        break;
-                     }
-                  }
-               }
-
-               if (ownFlagAtBase)
-               {
-                  p->hasRedFlag = false;
-                  flagType = WorldMap::OBJECT_RED_FLAG;
-                  pos = gameMap->getStructureLocation(WorldMap::STRUCTURE_RED_FLAG);
-                  flagTurnedIn = true;
-                  game->setBlueScore(game->getBlueScore()+1);
-               }
-            }
-
-            break;
-         }
-         case WorldMap::STRUCTURE_RED_FLAG:
-         {
-            if (p->team == 1 && p->hasBlueFlag)
-            {
-               // check that your flag is at your base
-               pos = gameMap->getStructureLocation(WorldMap::STRUCTURE_RED_FLAG);
-                        
-               vector<WorldMap::Object>* vctObjects = gameMap->getObjects();
-               vector<WorldMap::Object>::iterator itObjects;
-
-               for (itObjects = vctObjects->begin(); itObjects != vctObjects->end(); itObjects++)
-               {
-                  if (itObjects->type == WorldMap::OBJECT_RED_FLAG)
-                  {
-                     if (itObjects->pos.x == pos.x*25+12 && itObjects->pos.y == pos.y*25+12)
-                     {
-                        ownFlagAtBase = true;
-                        break;
-                     }
-                  }
-               }
-
-               if (ownFlagAtBase)
-               {
-                  p->hasBlueFlag = false;
-                  flagType = WorldMap::OBJECT_BLUE_FLAG;
-                  pos = gameMap->getStructureLocation(WorldMap::STRUCTURE_BLUE_FLAG);
-                  flagTurnedIn = true;
-                  game->setRedScore(game->getRedScore()+1);
-               }
-            }
-
-            break;
-         }
-      }
-
-      if (flagTurnedIn)
-      {
-         unsigned int blueScore = game->getBlueScore();
-         unsigned int redScore = game->getRedScore();
-
-         // send an OBJECT message to add the flag back to its spawn point
-         pos.x = pos.x*25+12;
-         pos.y = pos.y*25+12;
-         gameMap->addObject(flagType, pos.x, pos.y);
-
-         serverMsg.type = MSG_TYPE_OBJECT;
-         gameMap->getObjects()->back().serialize(serverMsg.buffer);
-         broadcastMessage(msgProcessor, serverMsg, playersInGame);
-
-         serverMsg.type = MSG_TYPE_SCORE;
-         memcpy(serverMsg.buffer, &blueScore, 4);
-         memcpy(serverMsg.buffer+4, &redScore, 4);
-         broadcastMessage(msgProcessor, serverMsg, playersInGame);
-
-         // check to see if the game should end
-         // move to its own method
-         if (game->getBlueScore() == 3 || game->getRedScore() == 3) {
-            gameFinished = true;
-
-            unsigned int winningTeam;
-            if (game->getBlueScore() == 3)
-               winningTeam = 0;
-            else if (game->getRedScore() == 3)
-               winningTeam = 1;
-
-            serverMsg.type = MSG_TYPE_FINISH_GAME;
-
-            // I should create an instance of the GameSummary object here and just serialize it into this message
-            memcpy(serverMsg.buffer, &winningTeam, 4);
-            memcpy(serverMsg.buffer+4, &blueScore, 4);
-            memcpy(serverMsg.buffer+8, &redScore, 4);
-            strcpy(serverMsg.buffer+12, game->getName().c_str());
-            broadcastMessage(msgProcessor, serverMsg, playersInGame);
-         }
-
-         // this means a PLAYER message will be sent
-         broadcastMove = true;
-      }
-
-      // go through all objects and check if the player is close to one and if its their flag
-      vector<WorldMap::Object>* vctObjects = gameMap->getObjects();
-      vector<WorldMap::Object>::iterator itObjects;
-      POSITION structPos;
-
-      for (itObjects = vctObjects->begin(); itObjects != vctObjects->end(); itObjects++)
-      {
-         POSITION pos = itObjects->pos;
-
-         if (posDistance(p->pos, pos.toFloat()) < 10)
-         {
-            if (p->team == 0 && 
-                itObjects->type == WorldMap::OBJECT_BLUE_FLAG)
-            {
-               structPos = gameMap->getStructureLocation(WorldMap::STRUCTURE_BLUE_FLAG);
-               flagReturned = true;
-               break;
-            }
-            else if (p->team == 1 &&
-                     itObjects->type == WorldMap::OBJECT_RED_FLAG)
-            {
-               structPos = gameMap->getStructureLocation(WorldMap::STRUCTURE_RED_FLAG);
-               flagReturned = true;
-               break;
-            }
-         }
-      }
-
-      if (flagReturned)
-      {
-         itObjects->pos.x = structPos.x*25+12;
-         itObjects->pos.y = structPos.y*25+12;
-
-         serverMsg.type = MSG_TYPE_OBJECT;
-         itObjects->serialize(serverMsg.buffer);
-         broadcastMessage(msgProcessor, serverMsg, playersInGame);
-      }
-
-      if (broadcastMove)
-      {
-         serverMsg.type = MSG_TYPE_PLAYER;
-         p->serialize(serverMsg.buffer);
-         broadcastMessage(msgProcessor, serverMsg, playersInGame);
-      }
-   }
-
-   cout << "processing player attack" << endl;
-
-   // check if the player's attack animation is complete
-   if (p->isAttacking && p->timeAttackStarted+p->attackCooldown <= getCurrentMillis())
-   {
-      p->isAttacking = false;
-      cout << "Attack animation is complete" << endl;
-
-      //send everyone an ATTACK message
-      cout << "about to broadcast attack" << endl;
-
-      if (p->attackType == Player::ATTACK_MELEE)
-      {
-         cout << "Melee attack" << endl;
-
-         Player* target = playersInGame[p->targetPlayer];
-         target->takeDamage(p->damage);
-
-         if (target->isDead)
-         {
-            WorldMap::ObjectType flagType = WorldMap::OBJECT_NONE;
-            if (target->hasBlueFlag)
-               flagType = WorldMap::OBJECT_BLUE_FLAG;
-            else if (target->hasRedFlag)
-               flagType = WorldMap::OBJECT_RED_FLAG;
-
-            if (flagType != WorldMap::OBJECT_NONE) {
-               addObjectToMap(flagType, target->pos.x, target->pos.y, gameMap, playersInGame, msgProcessor);
-            }
-         }
-
-         serverMsg.type = MSG_TYPE_PLAYER;
-         target->serialize(serverMsg.buffer);
-      }
-      else if (p->attackType == Player::ATTACK_RANGED)
-      {
-         cout << "Ranged attack" << endl;
-
-         Projectile proj(p->pos.x, p->pos.y, p->targetPlayer, p->damage);
-         game->assignProjectileId(&proj);
-         game->addProjectile(proj);
-
-         int x = p->pos.x;
-         int y = p->pos.y;
-
-         serverMsg.type = MSG_TYPE_PROJECTILE;
-         memcpy(serverMsg.buffer, &proj.id, 4);
-         memcpy(serverMsg.buffer+4, &x, 4);
-         memcpy(serverMsg.buffer+8, &y, 4);
-         memcpy(serverMsg.buffer+12, &p->targetPlayer, 4);
-      }
-      else
-         cout << "Invalid attack type: " << p->attackType << endl;
-
-      broadcastMessage(msgProcessor, serverMsg, playersInGame);
-   }
-
-   return gameFinished;
-}
-
-void broadcastMessage(MessageProcessor &msgProcessor, NETWORK_MSG &serverMsg, map<unsigned int, Player*>& players) {
-   map<unsigned int, Player*>::iterator it;
-   for (it = players.begin(); it != players.end(); it++) {
-      msgProcessor.sendMessage(&serverMsg, &(it->second->addr));
    }
 }
@@ -1112 +813 @@
 }
 
-void addObjectToMap(WorldMap::ObjectType objectType, int x, int y, WorldMap* gameMap, map<unsigned int, Player*>& mapPlayers, MessageProcessor &msgProcessor) {
-   NETWORK_MSG serverMsg;
-
-   gameMap->addObject(objectType, x, y);
-
-   serverMsg.type = MSG_TYPE_OBJECT;
-   gameMap->getObjects()->back().serialize(serverMsg.buffer);
-
-   broadcastMessage(msgProcessor, serverMsg, mapPlayers);
-}
-
 void quit(int sig) {
    done = true;