Index: common/Common.cpp
===================================================================
--- common/Common.cpp	(revision 68d94de7bbe815d1c0be9b36199a2411f78823b3)
+++ common/Common.cpp	(revision 8554263f37bc4e15ded77204278d53ae15d0375a)
@@ -13,4 +13,6 @@
 #include <cmath>
 #include <ctime>
+#include <cstdlib>
+#include <cstdio>
 
 using namespace std;
@@ -30,4 +32,11 @@
 
    return position;
+}
+
+// This might not be cross-platform. Verify that this works correctly or fix it.
+void error(const char *msg)
+{
+    perror(msg);
+    exit(0);
 }
 
Index: common/Common.h
===================================================================
--- common/Common.h	(revision 68d94de7bbe815d1c0be9b36199a2411f78823b3)
+++ common/Common.h	(revision 8554263f37bc4e15ded77204278d53ae15d0375a)
@@ -20,4 +20,5 @@
 };
 
+void error(const char *msg);
 void set_nonblock(int sock);
 unsigned long long getCurrentMillis();
Index: common/MessageProcessor.cpp
===================================================================
--- common/MessageProcessor.cpp	(revision 68d94de7bbe815d1c0be9b36199a2411f78823b3)
+++ common/MessageProcessor.cpp	(revision 8554263f37bc4e15ded77204278d53ae15d0375a)
@@ -40,5 +40,8 @@
    int ret =  sendto(sock, (char*)msg, sizeof(NETWORK_MSG), 0, (struct sockaddr *)dest, sizeof(struct sockaddr_in));
 
-   return ret;
+   if (ret < 0)
+      error("sendMessage");
+   else
+      return ret;
 }
 
Index: server/server.cpp
===================================================================
--- server/server.cpp	(revision 68d94de7bbe815d1c0be9b36199a2411f78823b3)
+++ server/server.cpp	(revision 8554263f37bc4e15ded77204278d53ae15d0375a)
@@ -46,6 +46,7 @@
 // from used to be const. Removed that so I could take a reference
 // and use it to send messages
-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);
-
+void 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);
+
+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);
@@ -53,12 +54,5 @@
 void damagePlayer(Player *p, int damage);
 
-void addObjectToMap(WorldMap::ObjectType objectType, int x, int y, WorldMap* gameMap, map<unsigned int, Player*>& mapPlayers, MessageProcessor &msgProcessor, int sock, ofstream& outputLog);
-
-// this should probably go somewhere in the common folder
-void error(const char *msg)
-{
-    perror(msg);
-    exit(0);
-}
+void addObjectToMap(WorldMap::ObjectType objectType, int x, int y, WorldMap* gameMap, map<unsigned int, Player*>& mapPlayers, MessageProcessor &msgProcessor);
 
 void quit(int sig) {
@@ -68,5 +62,5 @@
 int main(int argc, char *argv[])
 {
-   int sock, length, n;
+   int sock, length;
    struct sockaddr_in server;
    struct sockaddr_in from; // info of client sending the message
@@ -133,5 +127,6 @@
    set_nonblock(sock);
 
-   bool broadcastResponse;
+   msgProcessor = MessageProcessor(sock, &outputLog);
+
    timespec ts;
    int timeLastUpdated = 0, curTime = 0, timeLastBroadcast = 0;
@@ -149,6 +144,6 @@
          timeLastUpdated = curTime;
 
-         msgProcessor.cleanAckedMessages(&outputLog);
-         msgProcessor.resendUnackedMessages(sock, &outputLog);
+         msgProcessor.cleanAckedMessages();
+         msgProcessor.resendUnackedMessages();
 
          map<unsigned int, Player*>::iterator it;
@@ -157,4 +152,5 @@
 
          // set targets for all chasing players (or make them attack if they're close enough)
+         // this should be moved into the games loop
          for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
          {
@@ -197,10 +193,5 @@
                   p->serialize(serverMsg.buffer);
 
-                  map<unsigned int, Player*>::iterator it2;
-                  for (it2 = p->currentGame->getPlayers().begin(); it2 != p->currentGame->getPlayers().end(); it2++)
-                  {
-                     if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
-                        error("sendMessage");
-                  }
+                  broadcastMessage(msgProcessor, serverMsg, p->currentGame->getPlayers());
                }
 
@@ -215,10 +206,5 @@
                   p->serialize(serverMsg.buffer);
 
-                  map<unsigned int, Player*>::iterator it2;
-                  for (it2 = playersInGame.begin(); it2 != playersInGame.end(); it2++)
-                  {
-                     if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
-                        error("sendMessage");
-                  }
+                  broadcastMessage(msgProcessor, serverMsg, playersInGame);
                }
             }
@@ -257,5 +243,4 @@
                       broadcastMove = true;
                   cout << "player move processed" << endl;
-
 
                   WorldMap::ObjectType flagType;
@@ -348,22 +333,10 @@
                      serverMsg.type = MSG_TYPE_OBJECT;
                      gameMap->getObjects()->back().serialize(serverMsg.buffer);
-
-                     map<unsigned int, Player*>::iterator it2;
-                  
-                     for (it2 = playersInGame.begin(); it2 != playersInGame.end(); it2++)
-                     {
-                        if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
-                           error("sendMessage");
-                     }
+                     broadcastMessage(msgProcessor, serverMsg, playersInGame);
 
                      serverMsg.type = MSG_TYPE_SCORE;
                      memcpy(serverMsg.buffer, &scoreBlue, 4);
                      memcpy(serverMsg.buffer+4, &scoreRed, 4);
-
-                     for (it2 = playersInGame.begin(); it2 != playersInGame.end(); it2++)
-                     {
-                        if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
-                           error("sendMessage");
-                     }
+                     broadcastMessage(msgProcessor, serverMsg, playersInGame);
 
                      // check to see if the game should end
@@ -385,10 +358,5 @@
                         memcpy(serverMsg.buffer+8, &scoreRed, 4);
                         strcpy(serverMsg.buffer+12, game->getName().c_str());
-
-                        for (it2 = playersInGame.begin(); it2 != playersInGame.end(); it2++)
-                        {
-                           if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
-                              error("sendMessage");
-                        }
+                        broadcastMessage(msgProcessor, serverMsg, playersInGame);
                      }
 
@@ -432,29 +400,12 @@
                      serverMsg.type = MSG_TYPE_OBJECT;
                      itObjects->serialize(serverMsg.buffer);
-
-                     map<unsigned int, Player*>::iterator it2;
-                     for (it2 = playersInGame.begin(); it2 != playersInGame.end(); it2++)
-                     {
-                        if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
-                           error("sendMessage");
-                     }
+                     broadcastMessage(msgProcessor, serverMsg, playersInGame);
                   }
 
                   if (broadcastMove)
                   {
-                     cout << "broadcasting player move" << endl;
                      serverMsg.type = MSG_TYPE_PLAYER;
                      p->serialize(serverMsg.buffer);
-
-                     // only broadcast message to other players in the same game
-                     cout << "about to broadcast move" << endl;
-
-                     map<unsigned int, Player*>::iterator it2;
-                     for (it2 = playersInGame.begin(); it2 != playersInGame.end(); it2++)
-                     {
-                        if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
-                           error("sendMessage");
-                     }
-                     cout << "done broadcasting player move" << endl;
+                     broadcastMessage(msgProcessor, serverMsg, playersInGame);
                   }
                }
@@ -474,11 +425,5 @@
                   memcpy(serverMsg.buffer, &p->id, 4);
                   memcpy(serverMsg.buffer+4, &p->targetPlayer, 4);
-
-                  map<unsigned int, Player*>::iterator it2;
-                  for (it2 = playersInGame.begin(); it2 != playersInGame.end(); it2++)
-                  {
-                     if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
-                        error("sendMessage");
-                  }
+                  broadcastMessage(msgProcessor, serverMsg, playersInGame);
 
                   if (p->attackType == Player::ATTACK_MELEE)
@@ -498,5 +443,5 @@
 
                         if (flagType != WorldMap::OBJECT_NONE) {
-                           addObjectToMap(flagType, target->pos.x, target->pos.y, gameMap, playersInGame, msgProcessor, sock, outputLog);
+                           addObjectToMap(flagType, target->pos.x, target->pos.y, gameMap, playersInGame, msgProcessor);
                         }
                      }
@@ -525,12 +470,5 @@
                      cout << "Invalid attack type: " << p->attackType << endl;
 
-                  // broadcast either a PLAYER or PROJECTILE message
-                  cout << "Broadcasting player or projectile message" << endl;
-                  for (it2 = playersInGame.begin(); it2 != playersInGame.end(); it2++)
-                  {
-                     if (msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
-                        error("sendMessage");
-                  }
-                  cout << "Done broadcasting" << endl;
+                  broadcastMessage(msgProcessor, serverMsg, playersInGame);
                }
             }
@@ -541,13 +479,5 @@
                serverMsg.type = MSG_TYPE_GAME_INFO;
                memcpy(serverMsg.buffer, &numPlayers, 4);
-
-               map<unsigned int, Player*>::iterator it2;
-               for (it2 = mapPlayers.begin(); it2 != mapPlayers.end(); it2++)
-               {
-                  if (it2->second->currentGame == game)
-                      it2->second->currentGame = NULL;
-                  if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
-                     error("sendMessage");
-               }
+               broadcastMessage(msgProcessor, serverMsg, mapPlayers);
 
                // erase game from server
@@ -576,17 +506,7 @@
                   memcpy(serverMsg.buffer, &itProj->second.id, 4);
                   game->removeProjectile(itProj->second.id);
-
-                  map<unsigned int, Player*>::iterator it2;
-                  cout << "Broadcasting REMOVE_PROJECTILE" << endl;
-                  for (it2 = game->getPlayers().begin(); it2 != game->getPlayers().end(); it2++)
-                  {
-                     if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
-                        error("sendMessage");
-                  }
-
-                  cout << "send a PLAYER message after dealing damage" << endl;
-                  // send a PLAYER message after dealing damage
+                  broadcastMessage(msgProcessor, serverMsg, game->getPlayers());
+
                   Player* target = game->getPlayers()[itProj->second.target];
-
                   damagePlayer(target, itProj->second.damage);
 
@@ -600,48 +520,19 @@
 
                      if (flagType != WorldMap::OBJECT_NONE)
-                        addObjectToMap(flagType, target->pos.x, target->pos.y, game->getMap(), game->getPlayers(), msgProcessor, sock, outputLog);
+                        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);
-
-                  cout << "Sending a PLAYER message" << endl;
-                  for (it2 = game->getPlayers().begin(); it2 != game->getPlayers().end(); it2++)
-                  {
-                     if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
-                        error("sendMessage");
-                  }
+                  broadcastMessage(msgProcessor, serverMsg, game->getPlayers());
                }
-               cout << "Projectile was not moved" << endl;
             }
          }
       }
 
-      n = msgProcessor.receiveMessage(&clientMsg, sock, &from, &outputLog);
-
-      if (n >= 0)
-      {
-         broadcastResponse = processMessage(clientMsg, from, msgProcessor, mapPlayers, mapGames, gameMap, unusedPlayerId, serverMsg, sock, scoreBlue, scoreRed, outputLog);
-
-         if (broadcastResponse)
-         {
-            cout << "Should be broadcasting the message" << endl;
-
-            // needs to be updated to use the players from the game
-            map<unsigned int, Player*>::iterator it;
-            for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
-            {
-               cout << "Sent message back to " << it->second->name << endl;
-               if ( msgProcessor.sendMessage(&serverMsg, sock, &(it->second->addr), &outputLog) < 0 )
-                  error("sendMessage");
-            }
-         }
-         else
-         {
-            cout << "Should be sending back the message" << endl;
-
-            if ( msgProcessor.sendMessage(&serverMsg, sock, &from, &outputLog) < 0 )
-               error("sendMessage");
-         }
+      if (msgProcessor.receiveMessage(&clientMsg, &from) >= 0)
+      {
+         processMessage(clientMsg, from, msgProcessor, mapPlayers, mapGames, gameMap, unusedPlayerId, serverMsg, scoreBlue, scoreRed);
 
          cout << "Finished processing the message" << endl;
@@ -668,5 +559,5 @@
 }
 
-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)
+void 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)
 {
    DataAccess da;
@@ -677,7 +568,4 @@
    cout << "MSG: type: " << clientMsg.type << endl;
    cout << "MSG contents: " << clientMsg.buffer << endl;
-
-   // maybe we should make a message class and have this be a member
-   bool broadcastResponse = false;
 
    // Check that if an invalid message is sent, the client will correctly
@@ -691,5 +579,4 @@
          Player::PlayerClass playerClass;
 
-         serverMsg.type = MSG_TYPE_REGISTER;
          memcpy(&playerClass, clientMsg.buffer+username.length()+password.length()+2, 4);
 
@@ -697,20 +584,29 @@
          cout << "password: " << password << endl;
 
-         if (playerClass == Player::CLASS_WARRIOR)
-            cout << "class: WARRIOR" << endl;
-         else if (playerClass == Player::CLASS_RANGER)
-            cout << "class: RANGER" << endl;
-         else {
-            cout << "Unknown player class detected" << endl;
+         bool validClass = false;
+
+         switch(playerClass) {
+            case Player::CLASS_WARRIOR:
+            case Player::CLASS_RANGER:
+               validClass = true;
+               break;
+            default:
+               validClass = false;
+               break;
+         }
+
+         serverMsg.type = MSG_TYPE_REGISTER;
+
+         if (validClass) {
+            int error = da.insertPlayer(username, password, playerClass);
+
+            if (error)
+               strcpy(serverMsg.buffer, "Registration failed. Please try again.");
+            else
+               strcpy(serverMsg.buffer, "Registration successful.");
+         }else
             strcpy(serverMsg.buffer, "You didn't select a class");
-            break;
-         }
-
-         int error = da.insertPlayer(username, password, playerClass);
-
-         if (error)
-            strcpy(serverMsg.buffer, "Registration failed. Please try again.");
-         else
-            strcpy(serverMsg.buffer, "Registration successful.");
+
+         msgProcessor.sendMessage(&serverMsg, &from);
 
          break;
@@ -748,5 +644,4 @@
 
             serverMsg.type = MSG_TYPE_PLAYER;
-
             // tell the new player about all the existing players
             cout << "Sending other players to new player" << endl;
@@ -759,6 +654,5 @@
                cout << "sending info about " << it->second->name  << endl;
                cout << "sending id " << it->second->id  << endl;
-               if ( msgProcessor.sendMessage(&serverMsg, sock, &from, &outputLog) < 0 )
-                  error("sendMessage");
+               msgProcessor.sendMessage(&serverMsg, &from);
             }
 
@@ -772,6 +666,5 @@
                itObjects->serialize(serverMsg.buffer);
                cout << "sending item id " << itObjects->id  << endl;
-               if ( msgProcessor.sendMessage(&serverMsg, sock, &from, &outputLog) < 0 )
-                  error("sendMessage");
+               msgProcessor.sendMessage(&serverMsg, &from);
             }
 
@@ -788,6 +681,5 @@
                memcpy(serverMsg.buffer, &numPlayers, 4);
                strcpy(serverMsg.buffer+4, g->getName().c_str());
-               if ( msgProcessor.sendMessage(&serverMsg, sock, &from, &outputLog) < 0 )
-                  error("sendMessage");
+               msgProcessor.sendMessage(&serverMsg, &from);
             }
 
@@ -796,17 +688,9 @@
             memcpy(serverMsg.buffer, &scoreBlue, 4);
             memcpy(serverMsg.buffer+4, &scoreRed, 4);
-            if ( msgProcessor.sendMessage(&serverMsg, sock, &from, &outputLog) < 0 )
-               error("sendMessage");
+            msgProcessor.sendMessage(&serverMsg, &from);
 
             serverMsg.type = MSG_TYPE_PLAYER;
             p->serialize(serverMsg.buffer);
-            cout << "Should be broadcasting the message" << endl;
-
-            for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
-            {
-               cout << "Sent message back to " << it->second->name << endl;
-               if ( msgProcessor.sendMessage(&serverMsg, sock, &(it->second->addr), &outputLog) < 0 )
-                  error("sendMessage");
-            }
+            broadcastMessage(msgProcessor, serverMsg, mapPlayers);
 
             mapPlayers[unusedPlayerId] = p;
@@ -814,4 +698,5 @@
 
          serverMsg.type = MSG_TYPE_LOGIN;
+         msgProcessor.sendMessage(&serverMsg, &from);
 
          break;
@@ -845,5 +730,5 @@
 
                if (flagType != WorldMap::OBJECT_NONE) {
-                  addObjectToMap(flagType, p->pos.x, p->pos.y, gameMap, mapPlayers, msgProcessor, sock, outputLog);
+                  addObjectToMap(flagType, p->pos.x, p->pos.y, gameMap, mapPlayers, msgProcessor);
                }
             }
@@ -853,20 +738,17 @@
             memcpy(serverMsg.buffer, &p->id, 4);
 
-            map<unsigned int, Player*>::iterator it;
-            for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
-            {
-               cout << "Sent message back to " << it->second->name << endl;
-               if ( msgProcessor.sendMessage(&serverMsg, sock, &(it->second->addr), &outputLog) < 0 )
-                  error("sendMessage");
-            }
+            broadcastMessage(msgProcessor, serverMsg, mapPlayers);
 
             if (p->id < unusedPlayerId)
                unusedPlayerId = p->id;
+
             mapPlayers.erase(p->id);
             delete p;
+
             strcpy(serverMsg.buffer+4, "You have successfully logged out.");
          }
 
          serverMsg.type = MSG_TYPE_LOGOUT;
+         msgProcessor.sendMessage(&serverMsg, &from);
 
          break;
@@ -875,4 +757,6 @@
       {
          cout << "Got a chat message" << endl;
+
+         serverMsg.type = MSG_TYPE_CHAT;
 
          Player *p = findPlayerByAddr(mapPlayers, from);
@@ -881,16 +765,14 @@
          {
             strcpy(serverMsg.buffer, "No player is logged in using this connection. This is either a bug, or you're trying to hack the server.");
+            msgProcessor.sendMessage(&serverMsg, &from);
          }
          else
          {
-            broadcastResponse = true;
-
             ostringstream oss;
             oss << p->name << ": " << clientMsg.buffer;
 
             strcpy(serverMsg.buffer, oss.str().c_str());
+            broadcastMessage(msgProcessor, serverMsg, mapPlayers);
          }	
-
-         serverMsg.type = MSG_TYPE_CHAT;
 
          break;
@@ -911,4 +793,5 @@
          
          Player* p = mapPlayers[id];
+         bool validMessage = false;
 
          if ( p->addr.sin_addr.s_addr == from.sin_addr.s_addr &&
@@ -922,11 +805,16 @@
                memcpy(serverMsg.buffer+8, &p->target.y, 4);
 
-               broadcastResponse = true;
+               broadcastMessage(msgProcessor, serverMsg, mapPlayers);
+
+               validMessage = true;
             }
             else
                cout << "Bad terrain detected" << endl;
          }
-         else  // nned to send back a message indicating failure
+         else
             cout << "Player id (" << id << ") doesn't match sender" << endl;
+
+         if (!validMessage)
+            msgProcessor.sendMessage(&serverMsg, &from);
 
          break;
@@ -946,22 +834,14 @@
 
          if (objectId >= 0) {
+            map<unsigned int, Player*> players = p->currentGame->getPlayers();
+
             serverMsg.type = MSG_TYPE_REMOVE_OBJECT;
             memcpy(serverMsg.buffer, &objectId, 4);
-
-            map<unsigned int, Player*> players = p->currentGame->getPlayers();
-            map<unsigned int, Player*>::iterator it;
-            for (it = players.begin(); it != players.end(); it++)
-            {
-               if ( msgProcessor.sendMessage(&serverMsg, sock, &(it->second->addr), &outputLog) < 0 )
-                  error("sendMessage");
-            }
-
-         }
-
-         // if there was no flag to pickup, we really don't need to send a message
-         serverMsg.type = MSG_TYPE_PLAYER;
-         p->serialize(serverMsg.buffer);
-
-         broadcastResponse = true;
+            broadcastMessage(msgProcessor, serverMsg, players);
+
+            serverMsg.type = MSG_TYPE_PLAYER;
+            p->serialize(serverMsg.buffer);
+            broadcastMessage(msgProcessor, serverMsg, players);
+         }
 
          break;
@@ -985,5 +865,7 @@
             flagType = WorldMap::OBJECT_RED_FLAG;
 
-         addObjectToMap(flagType, p->pos.x, p->pos.y, p->currentGame->getMap(), p->currentGame->getPlayers(), msgProcessor, sock, outputLog);
+         map<unsigned int, Player*> players = p->currentGame->getPlayers();
+
+         addObjectToMap(flagType, p->pos.x, p->pos.y, p->currentGame->getMap(), players, msgProcessor);
 
          p->hasBlueFlag = false;
@@ -992,6 +874,5 @@
          serverMsg.type = MSG_TYPE_PLAYER;
          p->serialize(serverMsg.buffer);
-
-         broadcastResponse = true;
+         broadcastMessage(msgProcessor, serverMsg, players);
 
          break;
@@ -1008,24 +889,14 @@
          // need to make sure the target is in the sender's game
 
-         Player* source = mapPlayers[id];
-         source->targetPlayer = targetId;
-         source->isChasing = true;
-
-         // this is irrelevant since the client doesn't even listen for START_ATTACK messages
-         // actually, the client should not ignore this and should instead perform the same movement
-         // algorithm on its end (following the target player until in range) that the server does.
-         // Once the attacker is in range, the client should stop movement and wait for messages
-         // from the server
+         Player* p = mapPlayers[id];
+         p->targetPlayer = targetId;
+         p->isChasing = true;
+
+         map<unsigned int, Player*> players = p->currentGame->getPlayers();
+
          serverMsg.type = MSG_TYPE_START_ATTACK;
          memcpy(serverMsg.buffer, &id, 4);
          memcpy(serverMsg.buffer+4, &targetId, 4);
-         broadcastResponse = true;
-
-         break;
-      }
-      case MSG_TYPE_ATTACK:
-      {
-         cout << "Received am ATTACK message" << endl;
-         cout << "ERROR: Clients should not send ATTACK messages" << endl;
+         broadcastMessage(msgProcessor, serverMsg, players);
 
          break;
@@ -1042,29 +913,28 @@
             cout << "Error: Game already exists" << endl;
             serverMsg.type = MSG_TYPE_JOIN_GAME_FAILURE;
-            broadcastResponse = false;
-            return broadcastResponse;
-         }
-
-         Game* g = new Game(gameName, "../data/map.txt");
-         mapGames[gameName] = g;
-
-         // add flag objects to the map
-         WorldMap* m = g->getMap();
-         for (int y=0; y<m->height; y++) {
-            for (int x=0; x<m->width; x++) {
-               switch (m->getStructure(x, y)) {
-                  case WorldMap::STRUCTURE_BLUE_FLAG:
-                     m->addObject(WorldMap::OBJECT_BLUE_FLAG, x*25+12, y*25+12);
-                     break;
-                  case WorldMap::STRUCTURE_RED_FLAG:
-                     m->addObject(WorldMap::OBJECT_RED_FLAG, x*25+12, y*25+12);
-                     break;
+         }else {
+            Game* g = new Game(gameName, "../data/map.txt");
+            mapGames[gameName] = g;
+
+            // add flag objects to the map
+            WorldMap* m = g->getMap();
+            for (int y=0; y<m->height; y++) {
+               for (int x=0; x<m->width; x++) {
+                  switch (m->getStructure(x, y)) {
+                     case WorldMap::STRUCTURE_BLUE_FLAG:
+                        m->addObject(WorldMap::OBJECT_BLUE_FLAG, x*25+12, y*25+12);
+                        break;
+                     case WorldMap::STRUCTURE_RED_FLAG:
+                        m->addObject(WorldMap::OBJECT_RED_FLAG, x*25+12, y*25+12);
+                        break;
+                  }
                }
             }
-         }
-
-         serverMsg.type = MSG_TYPE_JOIN_GAME_SUCCESS;
-         strcpy(serverMsg.buffer, gameName.c_str());
-         broadcastResponse = false;
+
+            serverMsg.type = MSG_TYPE_JOIN_GAME_SUCCESS;
+            strcpy(serverMsg.buffer, gameName.c_str());
+         }
+
+         msgProcessor.sendMessage(&serverMsg, &from);
 
          break;
@@ -1081,22 +951,19 @@
             cout << "Error: Game does not exist" << endl;
             serverMsg.type = MSG_TYPE_JOIN_GAME_FAILURE;
-            broadcastResponse = false;
-            return broadcastResponse;
-         }
-
-         Game* g = mapGames[gameName];
-         map<unsigned int, Player*>& players = g->getPlayers();
-         Player* p = findPlayerByAddr(mapPlayers, from);
-
-         if (players.find(p->id) != players.end()) {
-            cout << "Player " << p->name << " trying to join a game he's already in" << endl;
-            serverMsg.type = MSG_TYPE_JOIN_GAME_FAILURE;
-            broadcastResponse = false;
-            return broadcastResponse;
-         }
-
-         serverMsg.type = MSG_TYPE_JOIN_GAME_SUCCESS;
-         strcpy(serverMsg.buffer, gameName.c_str());
-         broadcastResponse = false;
+         }else {
+            Game* g = mapGames[gameName];
+            map<unsigned int, Player*>& players = g->getPlayers();
+            Player* p = findPlayerByAddr(mapPlayers, from);
+
+            if (players.find(p->id) != players.end()) {
+               cout << "Player " << p->name << " trying to join a game he's already in" << endl;
+               serverMsg.type = MSG_TYPE_JOIN_GAME_FAILURE;
+            }else {
+               serverMsg.type = MSG_TYPE_JOIN_GAME_SUCCESS;
+               strcpy(serverMsg.buffer, gameName.c_str());
+            }
+         }
+
+         msgProcessor.sendMessage(&serverMsg, &from);
 
          break;
@@ -1113,37 +980,28 @@
 
             /// should send a response back, maybe a new message type is needed
-
-            break;
-         }
-
-         cout << "Game name: " << g->getName() << endl;
-         p->currentGame = NULL;
-
-         serverMsg.type = MSG_TYPE_LEAVE_GAME;
-         memcpy(serverMsg.buffer, &p->id, 4);
-         strcpy(serverMsg.buffer+4, g->getName().c_str());
-
-         map<unsigned int, Player*>& players = g->getPlayers();
-
-         map<unsigned int, Player*>::iterator it;
-         for (it = players.begin(); it != players.end(); it++)
-         {
-            if ( msgProcessor.sendMessage(&serverMsg, sock, &(it->second->addr), &outputLog) < 0 )
-               error("sendMessage");
-         }
-
-         g->removePlayer(p->id);
-
-         int numPlayers = g->getNumPlayers();
-
-         serverMsg.type = MSG_TYPE_GAME_INFO;
-         memcpy(serverMsg.buffer, &numPlayers, 4);
-         strcpy(serverMsg.buffer+4, g->getName().c_str());
-         broadcastResponse = true;
-
-         // if there are no more players in the game, remove it
-         if (numPlayers == 0) {
-            mapGames.erase(g->getName());
-            delete g;
+            // not sure what to do here
+         }else {
+            cout << "Game name: " << g->getName() << endl;
+            p->currentGame = NULL;
+
+            serverMsg.type = MSG_TYPE_LEAVE_GAME;
+            memcpy(serverMsg.buffer, &p->id, 4);
+            strcpy(serverMsg.buffer+4, g->getName().c_str());
+            broadcastMessage(msgProcessor, serverMsg, g->getPlayers());
+
+            g->removePlayer(p->id);
+
+            int numPlayers = g->getNumPlayers();
+
+            serverMsg.type = MSG_TYPE_GAME_INFO;
+            memcpy(serverMsg.buffer, &numPlayers, 4);
+            strcpy(serverMsg.buffer+4, g->getName().c_str());
+            broadcastMessage(msgProcessor, serverMsg, mapPlayers);
+
+            // if there are no more players in the game, remove it
+            if (numPlayers == 0) {
+               mapGames.erase(g->getName());
+               delete g;
+            }
          }
 
@@ -1160,6 +1018,6 @@
          if (mapGames.find(gameName) == mapGames.end()) {
             serverMsg.type = MSG_TYPE_JOIN_GAME_FAILURE;
-            broadcastResponse = false;
-            return broadcastResponse;
+
+            msgProcessor.sendMessage(&serverMsg, &from);
          }
 
@@ -1180,6 +1038,5 @@
             itObjects->serialize(serverMsg.buffer);
             cout << "sending item id " << itObjects->id  << endl;
-            if ( msgProcessor.sendMessage(&serverMsg, sock, &from, &outputLog) < 0 )
-               error("sendMessage");
+            msgProcessor.sendMessage(&serverMsg, &from);
          }
 
@@ -1193,23 +1050,14 @@
          memcpy(serverMsg.buffer+4, &game_redScore, 4);
 
-         if ( msgProcessor.sendMessage(&serverMsg, sock, &from, &outputLog) < 0 )
-            error("sendMessage");
-
+         msgProcessor.sendMessage(&serverMsg, &from);
+
+         // send info to other players
          serverMsg.type = MSG_TYPE_PLAYER_JOIN_GAME;
          p->serialize(serverMsg.buffer);
          cout << "Should be broadcasting the message" << endl;
-
-         map<unsigned int, Player*>& otherPlayers = g->getPlayers();
-         map<unsigned int, Player*>::iterator it;
-         for (it = otherPlayers.begin(); it != otherPlayers.end(); it++)
-         {
-            cout << "Sent message back to " << it->second->name << endl;
-            if ( msgProcessor.sendMessage(&serverMsg, sock, &(it->second->addr), &outputLog) < 0 )
-               error("sendMessage");
-         }
+         broadcastMessage(msgProcessor, serverMsg, g->getPlayers());
 
          g->addPlayer(p);
 
-         map<unsigned int, Player*>& allPlayers = g->getPlayers();
 
          // tell the new player about all the players in the game (including himself)
@@ -1217,4 +1065,7 @@
          serverMsg.type = MSG_TYPE_PLAYER_JOIN_GAME;
 
+         
+         map<unsigned int, Player*>& allPlayers = g->getPlayers();
+         map<unsigned int, Player*>::iterator it;
          for (it = allPlayers.begin(); it != allPlayers.end(); it++)
          {
@@ -1223,6 +1074,5 @@
             cout << "sending info about " << it->second->name  << endl;
             cout << "sending id " << it->second->id  << endl;
-            if ( msgProcessor.sendMessage(&serverMsg, sock, &from, &outputLog) < 0 )
-               error("sendMessage");
+            msgProcessor.sendMessage(&serverMsg, &from);
          }
 
@@ -1232,5 +1082,5 @@
          memcpy(serverMsg.buffer, &numPlayers, 4);
          strcpy(serverMsg.buffer+4, gameName.c_str());
-         broadcastResponse = true;
+         broadcastMessage(msgProcessor, serverMsg, mapPlayers);
 
          break;
@@ -1238,4 +1088,7 @@
       default:
       {
+         // probably want to log the error rather than sending a chat message,
+         // especially since chat isn't currently visible on all screens
+
          serverMsg.type = MSG_TYPE_CHAT;
          strcpy(serverMsg.buffer, "Server error occured. Report this please.");
@@ -1244,6 +1097,11 @@
       }
    }
-
-   return broadcastResponse;
+}
+
+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));
+   }
 }
 
@@ -1292,18 +1150,12 @@
 }
 
-void addObjectToMap(WorldMap::ObjectType objectType, int x, int y, WorldMap* gameMap, map<unsigned int, Player*>& mapPlayers, MessageProcessor &msgProcessor, int sock, ofstream& outputLog) {
+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);
 
-   // need to send the OBJECT message too
    serverMsg.type = MSG_TYPE_OBJECT;
    gameMap->getObjects()->back().serialize(serverMsg.buffer);
 
-   map<unsigned int, Player*>::iterator it;
-   for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
-   {
-      if ( msgProcessor.sendMessage(&serverMsg, sock, &(it->second->addr), &outputLog) < 0 )
-         error("sendMessage");
-   }
+   broadcastMessage(msgProcessor, serverMsg, mapPlayers);
 }
