source: network-game/server/server.cpp@ 0678d60

Last change on this file since 0678d60 was 0678d60, checked in by dportnoy <dmp1488@…>, 11 years ago

All server warnings have been fixed and the WorldMap class has a new method to create flags (and, in the future, other objects) based on structures present on the map

  • Property mode set to 100644
File size: 25.5 KB
RevLine 
[2488852]1#include <cstdlib>
[371ce29]2#include <cstdio>
[e3535b3]3#include <unistd.h>
[2488852]4#include <string>
[e3535b3]5#include <iostream>
[3b1efcc]6#include <sstream>
[d05086b]7#include <fstream>
[edfd1d0]8#include <cstring>
[60017fc]9#include <cmath>
[371ce29]10
[01d0d00]11#include <vector>
12#include <map>
13
[d05086b]14#include <csignal>
15
[d211210]16#include <sys/time.h>
17
[73f75c1]18#include <sys/socket.h>
[371ce29]19#include <netdb.h>
[73f75c1]20#include <netinet/in.h>
21#include <arpa/inet.h>
22
[b128109]23#include <crypt.h>
24
[edfd1d0]25/*
[e3535b3]26#include <openssl/bio.h>
27#include <openssl/ssl.h>
28#include <openssl/err.h>
[edfd1d0]29*/
[e3535b3]30
[b53c6b3]31#include "../common/Compiler.h"
[3b1efcc]32#include "../common/Common.h"
[9b5d30b]33#include "../common/MessageProcessor.h"
[60017fc]34#include "../common/WorldMap.h"
[edfd1d0]35#include "../common/Player.h"
[8dad966]36#include "../common/Projectile.h"
[99afbb8]37#include "../common/Game.h"
[c9f6a1c]38#include "../common/GameSummary.h"
[b53c6b3]39
[36082e8]40#include "DataAccess.h"
[d2b411a]41
[e3535b3]42using namespace std;
43
[d211210]44// from used to be const. Removed that so I could take a reference
45// and use it to send messages
[2e63b64]46void processMessage(const NETWORK_MSG& clientMsg, struct sockaddr_in& from, MessageProcessor& msgProcessor, map<unsigned int, Player*>& mapPlayers, map<string, Game*>& mapGames, unsigned int& unusedPlayerId);
[f3fb980]47
[95ffe57]48void updateUnusedPlayerId(unsigned int& id, map<unsigned int, Player*>& mapPlayers);
49Player *findPlayerByName(map<unsigned int, Player*> &m, string name);
50Player *findPlayerByAddr(map<unsigned int, Player*> &m, const sockaddr_in &addr);
[8e540f4]51
[f3fb980]52void quit(int sig);
53
54bool done;
[d05086b]55
[e3535b3]56int main(int argc, char *argv[])
57{
[8554263]58 int sock, length;
[e3535b3]59 struct sockaddr_in server;
[3b1efcc]60 struct sockaddr_in from; // info of client sending the message
[e084950]61 NETWORK_MSG clientMsg, serverMsg;
[9b5d30b]62 MessageProcessor msgProcessor;
[95ffe57]63 map<unsigned int, Player*> mapPlayers;
[8dad966]64 map<unsigned int, Projectile> mapProjectiles;
[f41a7f9]65 map<string, Game*> mapGames;
[d05c484]66 unsigned int unusedPlayerId = 1;
[d05086b]67 ofstream outputLog;
68
69 done = false;
[b8601ee]70
[d05086b]71 signal(SIGINT, quit);
72
[edfd1d0]73 //SSL_load_error_strings();
74 //ERR_load_BIO_strings();
75 //OpenSSL_add_all_algorithms();
[e3535b3]76
[95ffe57]77 if (argc != 2)
78 {
79 cerr << "ERROR, expected server [domain] [port]" << endl;
[73f75c1]80 exit(1);
[e3535b3]81 }
[60017fc]82
[d05086b]83 outputLog.open("server.log", ios::app);
84 outputLog << "Started server on " << getCurrentDateTimeString() << endl;
85
[371ce29]86 sock = socket(AF_INET, SOCK_DGRAM, 0);
[5b1e31e]87 if (sock < 0)
88 error("Opening socket");
[e3535b3]89 length = sizeof(server);
90 bzero(&server,length);
91 server.sin_family=AF_INET;
92 server.sin_port=htons(atoi(argv[1]));
[2488852]93 server.sin_addr.s_addr=INADDR_ANY;
94 if ( bind(sock, (struct sockaddr *)&server, length) < 0 )
[e084950]95 error("binding");
[73f75c1]96
[371ce29]97 set_nonblock(sock);
98
[8554263]99 msgProcessor = MessageProcessor(sock, &outputLog);
100
[d211210]101 timespec ts;
[d05c484]102 int timeLastUpdated = 0, curTime = 0;
[95ffe57]103 while (!done)
104 {
[371ce29]105 usleep(5000);
106
[d211210]107 clock_gettime(CLOCK_REALTIME, &ts);
[430c80e]108 // make the number smaller so millis can fit in an int
[d69eb32]109 ts.tv_sec -= 1368000000;
[430c80e]110 curTime = ts.tv_sec*1000 + ts.tv_nsec/1000000;
[d211210]111
[95ffe57]112 if (timeLastUpdated == 0 || (curTime-timeLastUpdated) >= 50)
113 {
[d211210]114 timeLastUpdated = curTime;
115
[8554263]116 msgProcessor.cleanAckedMessages();
117 msgProcessor.resendUnackedMessages();
[9b5d30b]118
[95ffe57]119 map<unsigned int, Player*>::iterator it;
[11d21ee]120
[ce2bb87]121 cout << "Updating player targets and respawning dead players" << endl;
122
[11d21ee]123 // set targets for all chasing players (or make them attack if they're close enough)
[8554263]124 // this should be moved into the games loop
[95ffe57]125 for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
126 {
[ffadc8e]127 Player* p = it->second;
128
[c76134b]129 // check if it's time to revive dead players
[ffadc8e]130 if (p->isDead)
[95ffe57]131 {
[e1af80c]132 cout << "Player is dead" << endl;
[35f6097]133
[ffadc8e]134 if (getCurrentMillis() - p->timeDied >= 10000)
[95ffe57]135 {
[ffadc8e]136 p->isDead = false;
[c76134b]137
138 POSITION spawnPos;
139
[ffadc8e]140 switch (p->team)
[95ffe57]141 {
[c76134b]142 case 0:// blue team
[35f6097]143 spawnPos = p->currentGame->getMap()->getStructureLocation(WorldMap::STRUCTURE_BLUE_FLAG);
[c76134b]144 break;
145 case 1:// red team
[35f6097]146 spawnPos = p->currentGame->getMap()->getStructureLocation(WorldMap::STRUCTURE_RED_FLAG);
[c76134b]147 break;
148 default:
149 // should never go here
150 cout << "Error: Invalid team" << endl;
151 break;
152 }
153
154 // spawn the player to the right of their flag location
155 spawnPos.x = (spawnPos.x+1) * 25 + 12;
156 spawnPos.y = spawnPos.y * 25 + 12;
157
[ffadc8e]158 p->pos = spawnPos.toFloat();
159 p->target = spawnPos;
160 p->health = p->maxHealth;
[c76134b]161
162 serverMsg.type = MSG_TYPE_PLAYER;
[ffadc8e]163 p->serialize(serverMsg.buffer);
[c76134b]164
[d05c484]165 msgProcessor.broadcastMessage(serverMsg, p->currentGame->getPlayers());
[c76134b]166 }
167
168 continue;
169 }
170
[ffadc8e]171 if (p->currentGame != NULL) {
172 map<unsigned int, Player*> playersInGame = p->currentGame->getPlayers();
[204edcf]173 if (p->updateTarget(playersInGame))
[5b1e31e]174 {
[ffadc8e]175 serverMsg.type = MSG_TYPE_PLAYER;
176 p->serialize(serverMsg.buffer);
[d05c484]177 msgProcessor.broadcastMessage(serverMsg, playersInGame);
[11d21ee]178 }
179 }
180 }
181
[ce2bb87]182 cout << "Processing players in a game" << endl;
183
[402cf86]184 // process players currently in a game
[e62b56c]185 map<string, Game*>::iterator itGames;
186 Game* game = NULL;
[ce2bb87]187
[e5b96e2]188 for (itGames = mapGames.begin(); itGames != mapGames.end();) {
[d05c484]189 game = itGames->second;
190 if (game->handleGameEvents()) {
191 // send a GAME_INFO message with 0 players to force clients to delete the game
192 int numPlayers = 0;
193 serverMsg.type = MSG_TYPE_GAME_INFO;
194 memcpy(serverMsg.buffer, &numPlayers, 4);
195 strcpy(serverMsg.buffer+4, game->getName().c_str());
196 msgProcessor.broadcastMessage(serverMsg, mapPlayers);
197
[f3fb980]198 delete itGames->second;
[df74597]199 mapGames.erase(itGames++);
[e5b96e2]200 }else
201 itGames++;
[8dad966]202 }
203
[ce2bb87]204 cout << "Processing projectiles" << endl;
205
[8dad966]206 // move all projectiles
[483a2cb]207 // see if this can be moved inside the game class
[45734ff]208 // this method can be moved when I add a MessageProcessor to the Game class
[8dad966]209 map<unsigned int, Projectile>::iterator itProj;
[5ae8dca]210 for (itGames = mapGames.begin(); itGames != mapGames.end(); itGames++) {
211 game = itGames->second;
212 for (itProj = game->getProjectiles().begin(); itProj != game->getProjectiles().end(); itProj++)
[95ffe57]213 {
[5ae8dca]214 cout << "About to call projectile move" << endl;
215 if (itProj->second.move(game->getPlayers()))
[8dad966]216 {
[5ae8dca]217 // send a REMOVE_PROJECTILE message
218 cout << "send a REMOVE_PROJECTILE message" << endl;
219 serverMsg.type = MSG_TYPE_REMOVE_PROJECTILE;
220 memcpy(serverMsg.buffer, &itProj->second.id, 4);
221 game->removeProjectile(itProj->second.id);
[d05c484]222 msgProcessor.broadcastMessage(serverMsg, game->getPlayers());
[5ae8dca]223
224 Player* target = game->getPlayers()[itProj->second.target];
[d05c484]225 game->dealDamageToPlayer(target, itProj->second.damage);
[8dad966]226 }
227 }
[d211210]228 }
229 }
230
[8554263]231 if (msgProcessor.receiveMessage(&clientMsg, &from) >= 0)
[95ffe57]232 {
[2e63b64]233 processMessage(clientMsg, from, msgProcessor, mapPlayers, mapGames, unusedPlayerId);
[ce2bb87]234
235 cout << "Finished processing the message" << endl;
[7b43385]236 }
[8e540f4]237 }
[371ce29]238
[d05086b]239 outputLog << "Stopped server on " << getCurrentDateTimeString() << endl;
240 outputLog.close();
241
[f41a7f9]242 // delete all games
243 map<string, Game*>::iterator itGames;
[95ffe57]244 for (itGames = mapGames.begin(); itGames != mapGames.end(); itGames++)
245 {
[f41a7f9]246 delete itGames->second;
247 }
248
[95ffe57]249 map<unsigned int, Player*>::iterator itPlayers;
250 for (itPlayers = mapPlayers.begin(); itPlayers != mapPlayers.end(); itPlayers++)
251 {
252 delete itPlayers->second;
253 }
254
[8e540f4]255 return 0;
256}
257
[2e63b64]258void processMessage(const NETWORK_MSG &clientMsg, struct sockaddr_in &from, MessageProcessor &msgProcessor, map<unsigned int, Player*>& mapPlayers, map<string, Game*>& mapGames, unsigned int& unusedPlayerId)
[8e540f4]259{
[f3fb980]260 NETWORK_MSG serverMsg;
[41ad8ed]261 DataAccess da;
262
[9a4fa04]263 cout << "Inside processMessage" << endl;
264
[b8cb03f]265 cout << "Received message" << endl;
[8e540f4]266 cout << "MSG: type: " << clientMsg.type << endl;
267 cout << "MSG contents: " << clientMsg.buffer << endl;
268
269 // Check that if an invalid message is sent, the client will correctly
270 // receive and display the response. Maybe make a special error msg type
271 switch(clientMsg.type)
272 {
273 case MSG_TYPE_REGISTER:
[d2b411a]274 {
[8e540f4]275 string username(clientMsg.buffer);
276 string password(strchr(clientMsg.buffer, '\0')+1);
[521c88b]277 Player::PlayerClass playerClass;
278
[4509648]279 memcpy(&playerClass, clientMsg.buffer+username.length()+password.length()+2, 4);
[c4c2a3c]280
[8e540f4]281 cout << "username: " << username << endl;
282 cout << "password: " << password << endl;
[d2b411a]283
[8554263]284 bool validClass = false;
285
286 switch(playerClass) {
287 case Player::CLASS_WARRIOR:
288 case Player::CLASS_RANGER:
289 validClass = true;
290 break;
291 default:
292 validClass = false;
293 break;
[c4c2a3c]294 }
[521c88b]295
[8554263]296 serverMsg.type = MSG_TYPE_REGISTER;
[41ad8ed]297
[8554263]298 if (validClass) {
299 int error = da.insertPlayer(username, password, playerClass);
300
301 if (error)
302 strcpy(serverMsg.buffer, "Registration failed. Please try again.");
303 else
304 strcpy(serverMsg.buffer, "Registration successful.");
305 }else
306 strcpy(serverMsg.buffer, "You didn't select a class");
307
308 msgProcessor.sendMessage(&serverMsg, &from);
[d2b411a]309
[8e540f4]310 break;
311 }
312 case MSG_TYPE_LOGIN:
313 {
[60017fc]314 cout << "Got login message" << endl;
315
[8e540f4]316 string username(clientMsg.buffer);
[41ad8ed]317 string password(strchr(clientMsg.buffer, '\0')+1);
[8e540f4]318
[41ad8ed]319 Player* p = da.getPlayer(username);
[d2b411a]320
[b128109]321 if (p == NULL || !da.verifyPassword(password, p->password))
[41ad8ed]322 {
323 strcpy(serverMsg.buffer, "Incorrect username or password");
[95ffe57]324 if (p != NULL)
325 delete(p);
[41ad8ed]326 }
[01d0d00]327 else if(findPlayerByName(mapPlayers, username) != NULL)
[41ad8ed]328 {
329 strcpy(serverMsg.buffer, "Player has already logged in.");
[95ffe57]330 delete(p);
[41ad8ed]331 }
332 else
[8e540f4]333 {
[8dad966]334 updateUnusedPlayerId(unusedPlayerId, mapPlayers);
[204edcf]335 p->setId(unusedPlayerId);
336 cout << "new player id: " << p->getId() << endl;
[df79cfd]337 p->setAddr(from);
[ce2bb87]338 p->currentGame = NULL;
[df79cfd]339
340 // choose a random team (either 0 or 1)
341 p->team = rand() % 2;
[d211210]342
[f203c5c]343 serverMsg.type = MSG_TYPE_PLAYER;
[d211210]344 // tell the new player about all the existing players
345 cout << "Sending other players to new player" << endl;
346
[95ffe57]347 map<unsigned int, Player*>::iterator it;
[d211210]348 for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
349 {
[95ffe57]350 it->second->serialize(serverMsg.buffer);
[d211210]351
[95ffe57]352 cout << "sending info about " << it->second->name << endl;
[204edcf]353 cout << "sending id " << it->second->getId() << endl;
[8554263]354 msgProcessor.sendMessage(&serverMsg, &from);
[5f868c0]355 }
356
[d3efa1a]357 // send info about existing games to new player
358 map<string, Game*>::iterator itGames;
359 Game* g;
360 int numPlayers;
361 serverMsg.type = MSG_TYPE_GAME_INFO;
362
363 for (itGames = mapGames.begin(); itGames != mapGames.end(); itGames++)
364 {
365 g = itGames->second;
366 numPlayers = g->getNumPlayers();
367 memcpy(serverMsg.buffer, &numPlayers, 4);
368 strcpy(serverMsg.buffer+4, g->getName().c_str());
[8554263]369 msgProcessor.sendMessage(&serverMsg, &from);
[d211210]370 }
[59061f6]371
[b8601ee]372 serverMsg.type = MSG_TYPE_PLAYER;
[594d2e9]373 p->serialize(serverMsg.buffer);
[d05c484]374 msgProcessor.broadcastMessage(serverMsg, mapPlayers);
[d211210]375
[95ffe57]376 mapPlayers[unusedPlayerId] = p;
[07028b9]377 }
378
[f203c5c]379 serverMsg.type = MSG_TYPE_LOGIN;
[8554263]380 msgProcessor.sendMessage(&serverMsg, &from);
[07028b9]381
[8e540f4]382 break;
383 }
384 case MSG_TYPE_LOGOUT:
385 {
386 string name(clientMsg.buffer);
387 cout << "Player logging out: " << name << endl;
388
[01d0d00]389 Player *p = findPlayerByName(mapPlayers, name);
[633f42a]390
[8e540f4]391 if (p == NULL)
392 {
[90eaad2]393 strcpy(serverMsg.buffer+4, "That player is not logged in. This is either a bug, or you're trying to hack the server.");
[8a3ef42]394 cout << "Player not logged in" << endl;
[07028b9]395 }
[01d0d00]396 else if ( p->addr.sin_addr.s_addr != from.sin_addr.s_addr ||
397 p->addr.sin_port != from.sin_port )
[07028b9]398 {
[90eaad2]399 strcpy(serverMsg.buffer+4, "That player is logged in using a differemt connection. This is either a bug, or you're trying to hack the server.");
[8a3ef42]400 cout << "Player logged in using a different connection" << endl;
[2488852]401 }
[8e540f4]402 else
[2488852]403 {
[1a47469]404 // broadcast to all players before deleting p from the map
[204edcf]405 unsigned int playerId = p->getId();
[4509648]406 serverMsg.type = MSG_TYPE_LOGOUT;
[204edcf]407 memcpy(serverMsg.buffer, &playerId, 4);
[4509648]408
[d05c484]409 msgProcessor.broadcastMessage(serverMsg, mapPlayers);
[1a47469]410
[204edcf]411 if (p->getId() < unusedPlayerId)
412 unusedPlayerId = p->getId();
[8554263]413
[204edcf]414 mapPlayers.erase(p->getId());
[95ffe57]415 delete p;
[8554263]416
[90eaad2]417 strcpy(serverMsg.buffer+4, "You have successfully logged out.");
[8e540f4]418 }
[07028b9]419
[d211210]420 serverMsg.type = MSG_TYPE_LOGOUT;
[8554263]421 msgProcessor.sendMessage(&serverMsg, &from);
[8a3ef42]422
[8e540f4]423 break;
424 }
425 case MSG_TYPE_CHAT:
426 {
[da692b9]427 cout << "Got a chat message" << endl;
428
[8554263]429 serverMsg.type = MSG_TYPE_CHAT;
430
[01d0d00]431 Player *p = findPlayerByAddr(mapPlayers, from);
[07028b9]432
[8e540f4]433 if (p == NULL)
434 {
435 strcpy(serverMsg.buffer, "No player is logged in using this connection. This is either a bug, or you're trying to hack the server.");
[8554263]436 msgProcessor.sendMessage(&serverMsg, &from);
[2488852]437 }
[8e540f4]438 else
439 {
[b128109]440 ostringstream oss;
441 oss << p->name << ": " << clientMsg.buffer;
[3b1efcc]442
[b128109]443 strcpy(serverMsg.buffer, oss.str().c_str());
[d05c484]444 msgProcessor.broadcastMessage(serverMsg, mapPlayers);
[8e540f4]445 }
446
447 break;
[e084950]448 }
[b128109]449 case MSG_TYPE_PLAYER_MOVE:
450 {
451 cout << "PLAYER_MOVE" << endl;
452
[9ba9b96]453 unsigned int id;
454 int x, y;
[b128109]455
456 memcpy(&id, clientMsg.buffer, 4);
457 memcpy(&x, clientMsg.buffer+4, 4);
458 memcpy(&y, clientMsg.buffer+8, 4);
[7b43385]459
[b128109]460 cout << "x: " << x << endl;
461 cout << "y: " << y << endl;
462 cout << "id: " << id << endl;
[7b43385]463
[95ffe57]464 Player* p = mapPlayers[id];
[8554263]465 bool validMessage = false;
[95ffe57]466
467 if ( p->addr.sin_addr.s_addr == from.sin_addr.s_addr &&
468 p->addr.sin_port == from.sin_port )
[b128109]469 {
[0129700]470 if (p->currentGame->startPlayerMovement(id, x, y)) {
[60017fc]471 serverMsg.type = MSG_TYPE_PLAYER_MOVE;
472
473 memcpy(serverMsg.buffer, &id, 4);
[95ffe57]474 memcpy(serverMsg.buffer+4, &p->target.x, 4);
475 memcpy(serverMsg.buffer+8, &p->target.y, 4);
[60017fc]476
[d05c484]477 msgProcessor.broadcastMessage(serverMsg, mapPlayers);
[8554263]478
479 validMessage = true;
[60017fc]480 }
481 else
482 cout << "Bad terrain detected" << endl;
[b128109]483 }
[8554263]484 else
[b128109]485 cout << "Player id (" << id << ") doesn't match sender" << endl;
486
[8554263]487 if (!validMessage)
488 msgProcessor.sendMessage(&serverMsg, &from);
489
[b128109]490 break;
491 }
[5299436]492 case MSG_TYPE_PICKUP_FLAG:
493 {
494 // may want to check the id matches the sender, just like for PLAYER_NOVE
495 cout << "PICKUP_FLAG" << endl;
496
[9ba9b96]497 unsigned int id;
[5299436]498
499 memcpy(&id, clientMsg.buffer, 4);
500 cout << "id: " << id << endl;
501
[95ffe57]502 Player* p = mapPlayers[id];
[9ba9b96]503 unsigned int objectId = p->currentGame->processFlagPickupRequest(p);
[95ffe57]504
[ce2bb87]505 if (objectId >= 0) {
[8554263]506 map<unsigned int, Player*> players = p->currentGame->getPlayers();
507
[ce2bb87]508 serverMsg.type = MSG_TYPE_REMOVE_OBJECT;
509 memcpy(serverMsg.buffer, &objectId, 4);
[d05c484]510 msgProcessor.broadcastMessage(serverMsg, players);
[5c84d54]511
[8554263]512 serverMsg.type = MSG_TYPE_PLAYER;
513 p->serialize(serverMsg.buffer);
[d05c484]514 msgProcessor.broadcastMessage(serverMsg, players);
[5c84d54]515 }
516
[5299436]517 break;
518 }
[e487381]519 case MSG_TYPE_DROP_FLAG:
520 {
521 // may want to check the id matches the sender, just like for PLAYER_NOVE
522 cout << "DROP_FLAG" << endl;
523
[9ba9b96]524 unsigned int id;
[e487381]525
526 memcpy(&id, clientMsg.buffer, 4);
527 cout << "id: " << id << endl;
528
[95ffe57]529 Player* p = mapPlayers[id];
530
[e487381]531 WorldMap::ObjectType flagType = WorldMap::OBJECT_NONE;
[95ffe57]532 if (p->hasBlueFlag)
[e487381]533 flagType = WorldMap::OBJECT_BLUE_FLAG;
[95ffe57]534 else if (p->hasRedFlag)
[e487381]535 flagType = WorldMap::OBJECT_RED_FLAG;
536
[8554263]537 map<unsigned int, Player*> players = p->currentGame->getPlayers();
538
[d05c484]539 p->currentGame->addObjectToMap(flagType, p->pos.x, p->pos.y);
[e487381]540
[95ffe57]541 p->hasBlueFlag = false;
542 p->hasRedFlag = false;
[e487381]543
544 serverMsg.type = MSG_TYPE_PLAYER;
[95ffe57]545 p->serialize(serverMsg.buffer);
[d05c484]546 msgProcessor.broadcastMessage(serverMsg, players);
[e487381]547
548 break;
549 }
[9bfc1cb]550 case MSG_TYPE_ATTACK:
[4b4b153]551 {
552 cout << "Received a START_ATTACK message" << endl;
553
[9ba9b96]554 unsigned int id, targetId;
[8a4ed74]555
556 memcpy(&id, clientMsg.buffer, 4);
557 memcpy(&targetId, clientMsg.buffer+4, 4);
558
[ffadc8e]559 // need to make sure the target is in the sender's game
560
[8554263]561 Player* p = mapPlayers[id];
[204edcf]562 p->setTargetPlayer(targetId);
[8554263]563 p->isChasing = true;
564
565 map<unsigned int, Player*> players = p->currentGame->getPlayers();
[8dad966]566
[9bfc1cb]567 serverMsg.type = MSG_TYPE_ATTACK;
[8dad966]568 memcpy(serverMsg.buffer, &id, 4);
569 memcpy(serverMsg.buffer+4, &targetId, 4);
[d05c484]570 msgProcessor.broadcastMessage(serverMsg, players);
[8a4ed74]571
572 break;
[4b4b153]573 }
[b8f789d]574 case MSG_TYPE_CREATE_GAME:
[8e540f4]575 {
[b8f789d]576 cout << "Received a CREATE_GAME message" << endl;
577
578 string gameName(clientMsg.buffer);
579 cout << "Game name: " << gameName << endl;
580
[b48ef09]581 // check if this game already exists
582 if (mapGames.find(gameName) != mapGames.end()) {
[3ef8cf4]583 cout << "Error: Game already exists" << endl;
[b48ef09]584 serverMsg.type = MSG_TYPE_JOIN_GAME_FAILURE;
[8554263]585 }else {
[d05c484]586 Game* g = new Game(gameName, "../data/map.txt", &msgProcessor);
[8554263]587 mapGames[gameName] = g;
588
589 // add flag objects to the map
590 WorldMap* m = g->getMap();
[0678d60]591 m->createObjectsFromStructures();
[8554263]592
593 serverMsg.type = MSG_TYPE_JOIN_GAME_SUCCESS;
594 strcpy(serverMsg.buffer, gameName.c_str());
[70fc3e8]595 }
596
[8554263]597 msgProcessor.sendMessage(&serverMsg, &from);
[b92e6a7]598
[b48ef09]599 break;
600 }
601 case MSG_TYPE_JOIN_GAME:
602 {
603 cout << "Received a JOIN_GAME message" << endl;
[b92e6a7]604
[b48ef09]605 string gameName(clientMsg.buffer);
606 cout << "Game name: " << gameName << endl;
[b92e6a7]607
[b48ef09]608 // check if this game already exists
609 if (mapGames.find(gameName) == mapGames.end()) {
[3ef8cf4]610 cout << "Error: Game does not exist" << endl;
[b48ef09]611 serverMsg.type = MSG_TYPE_JOIN_GAME_FAILURE;
[8554263]612 }else {
613 Game* g = mapGames[gameName];
614 map<unsigned int, Player*>& players = g->getPlayers();
615 Player* p = findPlayerByAddr(mapPlayers, from);
616
[204edcf]617 if (players.find(p->getId()) != players.end()) {
[8554263]618 cout << "Player " << p->name << " trying to join a game he's already in" << endl;
619 serverMsg.type = MSG_TYPE_JOIN_GAME_FAILURE;
620 }else {
621 serverMsg.type = MSG_TYPE_JOIN_GAME_SUCCESS;
622 strcpy(serverMsg.buffer, gameName.c_str());
623 }
[b92e6a7]624 }
625
[8554263]626 msgProcessor.sendMessage(&serverMsg, &from);
[b8f789d]627
628 break;
629 }
[ab8fd40]630 case MSG_TYPE_LEAVE_GAME:
631 {
632 cout << "Received a LEAVE_GAME message" << endl;
633
634 Player* p = findPlayerByAddr(mapPlayers, from);
635 Game* g = p->currentGame;
636
637 if (g == NULL) {
638 cout << "Player " << p->name << " is trying to leave a game, but is not currently in a game." << endl;
639
640 /// should send a response back, maybe a new message type is needed
[8554263]641 // not sure what to do here
642 }else {
643 cout << "Game name: " << g->getName() << endl;
[360c0f1]644
645 if (!p->isDead) {
646 WorldMap::ObjectType flagType = WorldMap::OBJECT_NONE;
647 if (p->hasBlueFlag)
648 flagType = WorldMap::OBJECT_BLUE_FLAG;
649 else if (p->hasRedFlag)
650 flagType = WorldMap::OBJECT_RED_FLAG;
651
[d05c484]652 if (flagType != WorldMap::OBJECT_NONE)
653 g->addObjectToMap(flagType, p->pos.x, p->pos.y);
[360c0f1]654 }
[bcfd99a]655
656 p->currentGame = NULL;
[204edcf]657 g->removePlayer(p->getId());
[360c0f1]658
[204edcf]659 unsigned int playerId = p->getId();
[8554263]660 serverMsg.type = MSG_TYPE_LEAVE_GAME;
[204edcf]661 memcpy(serverMsg.buffer, &playerId, 4);
[8554263]662 strcpy(serverMsg.buffer+4, g->getName().c_str());
[d05c484]663 msgProcessor.broadcastMessage(serverMsg, g->getPlayers());
[95ffe57]664
[8554263]665 int numPlayers = g->getNumPlayers();
[ab8fd40]666
[8554263]667 serverMsg.type = MSG_TYPE_GAME_INFO;
668 memcpy(serverMsg.buffer, &numPlayers, 4);
669 strcpy(serverMsg.buffer+4, g->getName().c_str());
[d05c484]670 msgProcessor.broadcastMessage(serverMsg, mapPlayers);
[8554263]671
672 // if there are no more players in the game, remove it
673 if (numPlayers == 0) {
674 mapGames.erase(g->getName());
675 delete g;
676 }
[1248984]677 }
678
[ab8fd40]679 break;
680 }
[b48ef09]681 case MSG_TYPE_JOIN_GAME_ACK:
[b8f789d]682 {
[b48ef09]683 cout << "Received a JOIN_GAME_ACK message" << endl;
[e084950]684
[b8f789d]685 string gameName(clientMsg.buffer);
686 cout << "Game name: " << gameName << endl;
687
[b48ef09]688 // check if this game already exists
689 if (mapGames.find(gameName) == mapGames.end()) {
690 serverMsg.type = MSG_TYPE_JOIN_GAME_FAILURE;
[8554263]691
692 msgProcessor.sendMessage(&serverMsg, &from);
[b48ef09]693 }
[b92e6a7]694
[f41a7f9]695 Game* g = mapGames[gameName];
[b92e6a7]696
[b48ef09]697 Player* p = findPlayerByAddr(mapPlayers, from);
[f41a7f9]698 p->team = rand() % 2; // choose a random team (either 0 or 1)
[e62b56c]699 p->currentGame = g;
[b92e6a7]700
701 // tell the new player about all map objects
702 // (currently just the flags)
703
704 serverMsg.type = MSG_TYPE_OBJECT;
[f41a7f9]705 vector<WorldMap::Object>* vctObjects = g->getMap()->getObjects();
[b92e6a7]706 vector<WorldMap::Object>::iterator itObjects;
707 cout << "sending items" << endl;
708 for (itObjects = vctObjects->begin(); itObjects != vctObjects->end(); itObjects++) {
709 itObjects->serialize(serverMsg.buffer);
710 cout << "sending item id " << itObjects->id << endl;
[8554263]711 msgProcessor.sendMessage(&serverMsg, &from);
[b92e6a7]712 }
713
714
715 // send the current score
716 serverMsg.type = MSG_TYPE_SCORE;
717
[9ba9b96]718 unsigned int blueScore = g->getBlueScore();
719 unsigned int redScore = g->getRedScore();
[f3fb980]720 memcpy(serverMsg.buffer, &blueScore, 4);
721 memcpy(serverMsg.buffer+4, &redScore, 4);
[b92e6a7]722
[8554263]723 msgProcessor.sendMessage(&serverMsg, &from);
[b92e6a7]724
[8554263]725 // send info to other players
[453087e]726 serverMsg.type = MSG_TYPE_PLAYER_JOIN_GAME;
[b92e6a7]727 p->serialize(serverMsg.buffer);
728 cout << "Should be broadcasting the message" << endl;
[d05c484]729 msgProcessor.broadcastMessage(serverMsg, g->getPlayers());
[b8f789d]730
[b48ef09]731 g->addPlayer(p);
[453087e]732
733
734 // tell the new player about all the players in the game (including himself)
735 cout << "Sending other players to new player" << endl;
736 serverMsg.type = MSG_TYPE_PLAYER_JOIN_GAME;
737
[8554263]738
739 map<unsigned int, Player*>& allPlayers = g->getPlayers();
740 map<unsigned int, Player*>::iterator it;
[453087e]741 for (it = allPlayers.begin(); it != allPlayers.end(); it++)
742 {
743 it->second->serialize(serverMsg.buffer);
744
745 cout << "sending info about " << it->second->name << endl;
[204edcf]746 cout << "sending id " << it->second->getId() << endl;
[8554263]747 msgProcessor.sendMessage(&serverMsg, &from);
[453087e]748 }
749
[b48ef09]750 int numPlayers = g->getNumPlayers();
751
[b8f789d]752 serverMsg.type = MSG_TYPE_GAME_INFO;
753 memcpy(serverMsg.buffer, &numPlayers, 4);
754 strcpy(serverMsg.buffer+4, gameName.c_str());
[d05c484]755 msgProcessor.broadcastMessage(serverMsg, mapPlayers);
[ab8fd40]756
[b8f789d]757 break;
758 }
759 default:
760 {
[8554263]761 // probably want to log the error rather than sending a chat message,
762 // especially since chat isn't currently visible on all screens
763
[8e540f4]764 serverMsg.type = MSG_TYPE_CHAT;
[b8f789d]765 strcpy(serverMsg.buffer, "Server error occured. Report this please.");
[e084950]766
[8e540f4]767 break;
768 }
[e3535b3]769 }
[8554263]770}
[da692b9]771
[95ffe57]772void updateUnusedPlayerId(unsigned int& id, map<unsigned int, Player*>& mapPlayers)
[01d0d00]773{
[1106210]774 while (mapPlayers.find(id) != mapPlayers.end())
775 id++;
[01d0d00]776}
[8dad966]777
[95ffe57]778Player *findPlayerByName(map<unsigned int, Player*> &m, string name)
779{
780 map<unsigned int, Player*>::iterator it;
781
782 for (it = m.begin(); it != m.end(); it++)
783 {
784 if ( it->second->name.compare(name) == 0 )
785 return it->second;
786 }
787
788 return NULL;
789}
790
791Player *findPlayerByAddr(map<unsigned int, Player*> &m, const sockaddr_in &addr)
792{
793 map<unsigned int, Player*>::iterator it;
794
795 for (it = m.begin(); it != m.end(); it++)
796 {
797 if ( it->second->addr.sin_addr.s_addr == addr.sin_addr.s_addr &&
798 it->second->addr.sin_port == addr.sin_port )
799 return it->second;
800 }
801
802 return NULL;
803}
804
[f3fb980]805void quit(int sig) {
806 done = true;
807}
Note: See TracBrowser for help on using the repository browser.