source: network-game/server/server.cpp@ 5ae8dca

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

Server moves projectiles in all individual games and damages players and sends correct messages when a projectile hits in individual games

  • Property mode set to 100644
File size: 44.2 KB
Line 
1#include <cstdlib>
2#include <cstdio>
3#include <unistd.h>
4#include <string>
5#include <iostream>
6#include <sstream>
7#include <fstream>
8#include <cstring>
9#include <cmath>
10
11#include <vector>
12#include <map>
13
14#include <csignal>
15
16#include <sys/time.h>
17
18#include <sys/socket.h>
19#include <netdb.h>
20#include <netinet/in.h>
21#include <arpa/inet.h>
22
23#include <crypt.h>
24
25/*
26#include <openssl/bio.h>
27#include <openssl/ssl.h>
28#include <openssl/err.h>
29*/
30
31#include "../common/Compiler.h"
32#include "../common/Common.h"
33#include "../common/MessageProcessor.h"
34#include "../common/WorldMap.h"
35#include "../common/Player.h"
36#include "../common/Projectile.h"
37#include "../common/Game.h"
38
39#include "DataAccess.h"
40
41using namespace std;
42
43bool done;
44
45// from used to be const. Removed that so I could take a reference
46// and use it to send messages
47bool processMessage(const NETWORK_MSG &clientMsg, struct sockaddr_in &from, MessageProcessor &msgProcessor, map<unsigned int, Player*>& mapPlayers, map<string, Game*>& mapGames, WorldMap* gameMap, unsigned int& unusedPlayerId, NETWORK_MSG &serverMsg, int sock, int &scoreBlue, int &scoreRed, ofstream& outputLog);
48
49void updateUnusedPlayerId(unsigned int& id, map<unsigned int, Player*>& mapPlayers);
50Player *findPlayerByName(map<unsigned int, Player*> &m, string name);
51Player *findPlayerByAddr(map<unsigned int, Player*> &m, const sockaddr_in &addr);
52void damagePlayer(Player *p, int damage);
53
54void addObjectToMap(WorldMap::ObjectType objectType, int x, int y, WorldMap* gameMap, map<unsigned int, Player*>& mapPlayers, MessageProcessor &msgProcessor, int sock, ofstream& outputLog);
55
56// this should probably go somewhere in the common folder
57void error(const char *msg)
58{
59 perror(msg);
60 exit(0);
61}
62
63void quit(int sig) {
64 done = true;
65}
66
67int main(int argc, char *argv[])
68{
69 int sock, length, n;
70 struct sockaddr_in server;
71 struct sockaddr_in from; // info of client sending the message
72 NETWORK_MSG clientMsg, serverMsg;
73 MessageProcessor msgProcessor;
74 map<unsigned int, Player*> mapPlayers;
75 map<unsigned int, Projectile> mapProjectiles;
76 map<string, Game*> mapGames;
77 unsigned int unusedPlayerId = 1, unusedProjectileId = 1;
78 int scoreBlue, scoreRed;
79 ofstream outputLog;
80
81 done = false;
82
83 scoreBlue = 0;
84 scoreRed = 0;
85
86 signal(SIGINT, quit);
87
88 //SSL_load_error_strings();
89 //ERR_load_BIO_strings();
90 //OpenSSL_add_all_algorithms();
91
92 if (argc != 2)
93 {
94 cerr << "ERROR, expected server [domain] [port]" << endl;
95 exit(1);
96 }
97
98 outputLog.open("server.log", ios::app);
99 outputLog << "Started server on " << getCurrentDateTimeString() << endl;
100
101 WorldMap* gameMap = WorldMap::loadMapFromFile("../data/map.txt");
102
103 // add some items to the map. They will be sent out
104 // to players when they login
105 for (int y=0; y<gameMap->height; y++)
106 {
107 for (int x=0; x<gameMap->width; x++)
108 {
109 switch (gameMap->getStructure(x, y))
110 {
111 case WorldMap::STRUCTURE_BLUE_FLAG:
112 gameMap->addObject(WorldMap::OBJECT_BLUE_FLAG, x*25+12, y*25+12);
113 break;
114 case WorldMap::STRUCTURE_RED_FLAG:
115 gameMap->addObject(WorldMap::OBJECT_RED_FLAG, x*25+12, y*25+12);
116 break;
117 }
118 }
119 }
120
121 sock = socket(AF_INET, SOCK_DGRAM, 0);
122 if (sock < 0)
123 error("Opening socket");
124 length = sizeof(server);
125 bzero(&server,length);
126 server.sin_family=AF_INET;
127 server.sin_port=htons(atoi(argv[1]));
128 server.sin_addr.s_addr=INADDR_ANY;
129 if ( bind(sock, (struct sockaddr *)&server, length) < 0 )
130 error("binding");
131
132 set_nonblock(sock);
133
134 bool broadcastResponse;
135 timespec ts;
136 int timeLastUpdated = 0, curTime = 0, timeLastBroadcast = 0;
137 while (!done)
138 {
139 usleep(5000);
140
141 clock_gettime(CLOCK_REALTIME, &ts);
142 // make the number smaller so millis can fit in an int
143 ts.tv_sec -= 1368000000;
144 curTime = ts.tv_sec*1000 + ts.tv_nsec/1000000;
145
146 if (timeLastUpdated == 0 || (curTime-timeLastUpdated) >= 50)
147 {
148 timeLastUpdated = curTime;
149
150 msgProcessor.cleanAckedMessages(&outputLog);
151 msgProcessor.resendUnackedMessages(sock, &outputLog);
152
153 map<unsigned int, Player*>::iterator it;
154
155 cout << "Updating player targets and respawning dead players" << endl;
156
157 // set targets for all chasing players (or make them attack if they're close enough)
158 for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
159 {
160 Player* p = it->second;
161
162 // check if it's time to revive dead players
163 if (p->isDead)
164 {
165 if (getCurrentMillis() - p->timeDied >= 10000)
166 {
167 p->isDead = false;
168
169 POSITION spawnPos;
170
171 switch (p->team)
172 {
173 case 0:// blue team
174 spawnPos = gameMap->getStructureLocation(WorldMap::STRUCTURE_BLUE_FLAG);
175 break;
176 case 1:// red team
177 spawnPos = gameMap->getStructureLocation(WorldMap::STRUCTURE_RED_FLAG);
178 break;
179 default:
180 // should never go here
181 cout << "Error: Invalid team" << endl;
182 break;
183 }
184
185 // spawn the player to the right of their flag location
186 spawnPos.x = (spawnPos.x+1) * 25 + 12;
187 spawnPos.y = spawnPos.y * 25 + 12;
188
189 p->pos = spawnPos.toFloat();
190 p->target = spawnPos;
191 p->health = p->maxHealth;
192
193 serverMsg.type = MSG_TYPE_PLAYER;
194 p->serialize(serverMsg.buffer);
195
196 map<unsigned int, Player*>::iterator it2;
197 for (it2 = mapPlayers.begin(); it2 != mapPlayers.end(); it2++)
198 {
199 if ( msgProcessor.sendMessage(&serverMsg, sock, &(p->addr), &outputLog) < 0 )
200 error("sendMessage");
201 }
202 }
203
204 continue;
205 }
206
207 if (p->currentGame != NULL) {
208 map<unsigned int, Player*> playersInGame = p->currentGame->getPlayers();
209 if (p->updateTarget(playersInGame))
210 {
211 serverMsg.type = MSG_TYPE_PLAYER;
212 p->serialize(serverMsg.buffer);
213
214 map<unsigned int, Player*>::iterator it2;
215 for (it2 = playersInGame.begin(); it2 != playersInGame.end(); it2++)
216 {
217 if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
218 error("sendMessage");
219 }
220 }
221 }
222 }
223
224 cout << "Processing players in a game" << endl;
225
226 // process players currently in a game
227 FLOAT_POSITION oldPos;
228 for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
229 {
230 Player* p = it->second;
231 if (p->currentGame == NULL)
232 continue;
233
234 cout << "moving player" << endl;
235 bool broadcastMove = false;
236
237 // xompute playersInGame here
238
239 // move player and perform associated tasks
240 oldPos = p->pos;
241 if (p->move(p->currentGame->getMap())) {
242
243 cout << "player moved" << endl;
244 if (p->currentGame->processPlayerMovement(p, oldPos))
245 broadcastMove = true;
246 cout << "player move processed" << endl;
247
248 map<unsigned int, Player*>& playersInGame = p->currentGame->getPlayers();
249
250 WorldMap::ObjectType flagType;
251 POSITION pos;
252 bool flagTurnedIn = false;
253 bool flagReturned = false;
254 bool ownFlagAtBase = false;
255
256 // need to figure out how to move this to a different file
257 // while still sending back flag type and position
258 WorldMap* playerMap = p->currentGame->getMap();
259 switch(playerMap->getStructure(p->pos.x/25, p->pos.y/25))
260 {
261 case WorldMap::STRUCTURE_BLUE_FLAG:
262 {
263 if (p->team == 0 && p->hasRedFlag)
264 {
265 // check that your flag is at your base
266 pos = playerMap->getStructureLocation(WorldMap::STRUCTURE_BLUE_FLAG);
267
268 vector<WorldMap::Object>* vctObjects = playerMap->getObjects();
269 vector<WorldMap::Object>::iterator itObjects;
270
271 for (itObjects = vctObjects->begin(); itObjects != vctObjects->end(); itObjects++)
272 {
273 if (itObjects->type == WorldMap::OBJECT_BLUE_FLAG)
274 {
275 if (itObjects->pos.x == pos.x*25+12 && itObjects->pos.y == pos.y*25+12)
276 {
277 ownFlagAtBase = true;
278 break;
279 }
280 }
281 }
282
283 if (ownFlagAtBase)
284 {
285 p->hasRedFlag = false;
286 flagType = WorldMap::OBJECT_RED_FLAG;
287 pos = playerMap->getStructureLocation(WorldMap::STRUCTURE_RED_FLAG);
288 flagTurnedIn = true;
289 scoreBlue++;
290 }
291 }
292
293 break;
294 }
295 case WorldMap::STRUCTURE_RED_FLAG:
296 {
297 if (p->team == 1 && p->hasBlueFlag)
298 {
299 // check that your flag is at your base
300 pos = playerMap->getStructureLocation(WorldMap::STRUCTURE_RED_FLAG);
301
302 vector<WorldMap::Object>* vctObjects = playerMap->getObjects();
303 vector<WorldMap::Object>::iterator itObjects;
304
305 for (itObjects = vctObjects->begin(); itObjects != vctObjects->end(); itObjects++)
306 {
307 if (itObjects->type == WorldMap::OBJECT_RED_FLAG)
308 {
309 if (itObjects->pos.x == pos.x*25+12 && itObjects->pos.y == pos.y*25+12)
310 {
311 ownFlagAtBase = true;
312 break;
313 }
314 }
315 }
316
317 if (ownFlagAtBase)
318 {
319 p->hasBlueFlag = false;
320 flagType = WorldMap::OBJECT_BLUE_FLAG;
321 pos = playerMap->getStructureLocation(WorldMap::STRUCTURE_BLUE_FLAG);
322 flagTurnedIn = true;
323 scoreRed++;
324 }
325 }
326
327 break;
328 }
329 }
330
331 if (flagTurnedIn)
332 {
333 // send an OBJECT message to add the flag back to its spawn point
334 pos.x = pos.x*25+12;
335 pos.y = pos.y*25+12;
336 playerMap->addObject(flagType, pos.x, pos.y);
337
338 serverMsg.type = MSG_TYPE_OBJECT;
339 playerMap->getObjects()->back().serialize(serverMsg.buffer);
340
341 map<unsigned int, Player*>::iterator it2;
342
343 for (it2 = playersInGame.begin(); it2 != playersInGame.end(); it2++)
344 {
345 if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
346 error("sendMessage");
347 }
348
349 serverMsg.type = MSG_TYPE_SCORE;
350 memcpy(serverMsg.buffer, &scoreBlue, 4);
351 memcpy(serverMsg.buffer+4, &scoreRed, 4);
352
353 for (it2 = playersInGame.begin(); it2 != playersInGame.end(); it2++)
354 {
355 if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
356 error("sendMessage");
357 }
358
359 // this means a PLAYER message will be sent
360 broadcastMove = true;
361 }
362
363 // go through all objects and check if the player is close to one and if its their flag
364 vector<WorldMap::Object>* vctObjects = playerMap->getObjects();
365 vector<WorldMap::Object>::iterator itObjects;
366 POSITION structPos;
367
368 for (itObjects = vctObjects->begin(); itObjects != vctObjects->end(); itObjects++)
369 {
370 POSITION pos = itObjects->pos;
371
372 if (posDistance(p->pos, pos.toFloat()) < 10)
373 {
374 if (p->team == 0 &&
375 itObjects->type == WorldMap::OBJECT_BLUE_FLAG)
376 {
377 structPos = playerMap->getStructureLocation(WorldMap::STRUCTURE_BLUE_FLAG);
378 flagReturned = true;
379 break;
380 }
381 else if (p->team == 1 &&
382 itObjects->type == WorldMap::OBJECT_RED_FLAG)
383 {
384 structPos = playerMap->getStructureLocation(WorldMap::STRUCTURE_RED_FLAG);
385 flagReturned = true;
386 break;
387 }
388 }
389 }
390
391 if (flagReturned)
392 {
393 itObjects->pos.x = structPos.x*25+12;
394 itObjects->pos.y = structPos.y*25+12;
395
396 serverMsg.type = MSG_TYPE_OBJECT;
397 itObjects->serialize(serverMsg.buffer);
398
399 map<unsigned int, Player*>::iterator it2;
400 for (it2 = playersInGame.begin(); it2 != playersInGame.end(); it2++)
401 {
402 if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
403 error("sendMessage");
404 }
405 }
406
407 if (broadcastMove)
408 {
409 cout << "broadcasting player move" << endl;
410 serverMsg.type = MSG_TYPE_PLAYER;
411 p->serialize(serverMsg.buffer);
412
413 // only broadcast message to other players in the same game
414 cout << "about to broadcast move" << endl;
415
416 map<unsigned int, Player*>::iterator it2;
417 for (it2 = playersInGame.begin(); it2 != playersInGame.end(); it2++)
418 {
419 if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
420 error("sendMessage");
421 }
422 cout << "done broadcasting player move" << endl;
423 }
424 }
425
426 cout << "processing player attack" << endl;
427
428 // check if the player's attack animation is complete
429 if (p->isAttacking && p->timeAttackStarted+p->attackCooldown <= getCurrentMillis())
430 {
431 p->isAttacking = false;
432 cout << "Attack animation is complete" << endl;
433
434 //send everyone an ATTACK message
435 cout << "about to broadcast attack" << endl;
436
437 serverMsg.type = MSG_TYPE_ATTACK;
438 memcpy(serverMsg.buffer, &p->id, 4);
439 memcpy(serverMsg.buffer+4, &p->targetPlayer, 4);
440
441 map<unsigned int, Player*>& playersInGame = p->currentGame->getPlayers();
442 map<unsigned int, Player*>::iterator it2;
443 for (it2 = playersInGame.begin(); it2 != playersInGame.end(); it2++)
444 {
445 if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
446 error("sendMessage");
447 }
448
449 if (p->attackType == Player::ATTACK_MELEE)
450 {
451 cout << "Melee attack" << endl;
452
453 Player* target = playersInGame[p->targetPlayer];
454 damagePlayer(target, p->damage);
455
456 if (target->isDead)
457 {
458 WorldMap::ObjectType flagType = WorldMap::OBJECT_NONE;
459 if (target->hasBlueFlag)
460 flagType = WorldMap::OBJECT_BLUE_FLAG;
461 else if (target->hasRedFlag)
462 flagType = WorldMap::OBJECT_RED_FLAG;
463
464 if (flagType != WorldMap::OBJECT_NONE) {
465 addObjectToMap(flagType, target->pos.x, target->pos.y, p->currentGame->getMap(), playersInGame, msgProcessor, sock, outputLog);
466 }
467 }
468
469 serverMsg.type = MSG_TYPE_PLAYER;
470 target->serialize(serverMsg.buffer);
471 }
472 else if (p->attackType == Player::ATTACK_RANGED)
473 {
474 cout << "Ranged attack" << endl;
475
476 Projectile proj(p->pos.x, p->pos.y, p->targetPlayer, p->damage);
477 p->currentGame->assignProjectileId(&proj);
478
479 p->currentGame->addProjectile(proj);
480
481 int x = p->pos.x;
482 int y = p->pos.y;
483
484 serverMsg.type = MSG_TYPE_PROJECTILE;
485 memcpy(serverMsg.buffer, &proj.id, 4);
486 memcpy(serverMsg.buffer+4, &x, 4);
487 memcpy(serverMsg.buffer+8, &y, 4);
488 memcpy(serverMsg.buffer+12, &p->targetPlayer, 4);
489 }
490 else
491 cout << "Invalid attack type: " << it->second->attackType << endl;
492
493 // broadcast either a PLAYER or PROJECTILE message
494 cout << "Broadcasting player or projectile message" << endl;
495 for (it2 = playersInGame.begin(); it2 != playersInGame.end(); it2++)
496 {
497 if (msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
498 error("sendMessage");
499 }
500 cout << "Done broadcasting" << endl;
501 }
502 }
503
504 cout << "Processing projectiles" << endl;
505
506 // move all projectiles
507 // see if this can be moved inside the game class
508 // this method can be moved when I add a MessageProcessor to the Game class
509 map<string, Game*>::iterator itGames;
510 Game* game;
511 map<unsigned int, Projectile>::iterator itProj;
512 for (itGames = mapGames.begin(); itGames != mapGames.end(); itGames++) {
513 game = itGames->second;
514 for (itProj = game->getProjectiles().begin(); itProj != game->getProjectiles().end(); itProj++)
515 {
516 cout << "About to call projectile move" << endl;
517 if (itProj->second.move(game->getPlayers()))
518 {
519 // send a REMOVE_PROJECTILE message
520 cout << "send a REMOVE_PROJECTILE message" << endl;
521 serverMsg.type = MSG_TYPE_REMOVE_PROJECTILE;
522 memcpy(serverMsg.buffer, &itProj->second.id, 4);
523 game->removeProjectile(itProj->second.id);
524
525 map<unsigned int, Player*>::iterator it2;
526 cout << "Broadcasting REMOVE_PROJECTILE" << endl;
527 for (it2 = game->getPlayers().begin(); it2 != game->getPlayers().end(); it2++)
528 {
529 if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
530 error("sendMessage");
531 }
532
533 cout << "send a PLAYER message after dealing damage" << endl;
534 // send a PLAYER message after dealing damage
535 Player* target = game->getPlayers()[itProj->second.target];
536
537 damagePlayer(target, itProj->second.damage);
538
539 if (target->isDead)
540 {
541 WorldMap::ObjectType flagType = WorldMap::OBJECT_NONE;
542 if (target->hasBlueFlag)
543 flagType = WorldMap::OBJECT_BLUE_FLAG;
544 else if (target->hasRedFlag)
545 flagType = WorldMap::OBJECT_RED_FLAG;
546
547 if (flagType != WorldMap::OBJECT_NONE)
548 addObjectToMap(flagType, target->pos.x, target->pos.y, game->getMap(), game->getPlayers(), msgProcessor, sock, outputLog);
549 }
550
551 serverMsg.type = MSG_TYPE_PLAYER;
552 target->serialize(serverMsg.buffer);
553
554 cout << "Sending a PLAYER message" << endl;
555 for (it2 = game->getPlayers().begin(); it2 != game->getPlayers().end(); it2++)
556 {
557 if ( msgProcessor.sendMessage(&serverMsg, sock, &(it2->second->addr), &outputLog) < 0 )
558 error("sendMessage");
559 }
560 }
561 cout << "Projectile was not moved" << endl;
562 }
563 }
564 }
565
566 n = msgProcessor.receiveMessage(&clientMsg, sock, &from, &outputLog);
567
568 if (n >= 0)
569 {
570 broadcastResponse = processMessage(clientMsg, from, msgProcessor, mapPlayers, mapGames, gameMap, unusedPlayerId, serverMsg, sock, scoreBlue, scoreRed, outputLog);
571
572 if (broadcastResponse)
573 {
574 cout << "Should be broadcasting the message" << endl;
575
576 // needs to be updated to use the players from the game
577 map<unsigned int, Player*>::iterator it;
578 for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
579 {
580 cout << "Sent message back to " << it->second->name << endl;
581 if ( msgProcessor.sendMessage(&serverMsg, sock, &(it->second->addr), &outputLog) < 0 )
582 error("sendMessage");
583 }
584 }
585 else
586 {
587 cout << "Should be sending back the message" << endl;
588
589 if ( msgProcessor.sendMessage(&serverMsg, sock, &from, &outputLog) < 0 )
590 error("sendMessage");
591 }
592
593 cout << "Finished processing the message" << endl;
594 }
595 }
596
597 outputLog << "Stopped server on " << getCurrentDateTimeString() << endl;
598 outputLog.close();
599
600 // delete all games
601 map<string, Game*>::iterator itGames;
602 for (itGames = mapGames.begin(); itGames != mapGames.end(); itGames++)
603 {
604 delete itGames->second;
605 }
606
607 map<unsigned int, Player*>::iterator itPlayers;
608 for (itPlayers = mapPlayers.begin(); itPlayers != mapPlayers.end(); itPlayers++)
609 {
610 delete itPlayers->second;
611 }
612
613 return 0;
614}
615
616bool 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)
617{
618 DataAccess da;
619
620 cout << "Inside processMessage" << endl;
621
622 cout << "Received message" << endl;
623 cout << "MSG: type: " << clientMsg.type << endl;
624 cout << "MSG contents: " << clientMsg.buffer << endl;
625
626 // maybe we should make a message class and have this be a member
627 bool broadcastResponse = false;
628
629 // Check that if an invalid message is sent, the client will correctly
630 // receive and display the response. Maybe make a special error msg type
631 switch(clientMsg.type)
632 {
633 case MSG_TYPE_REGISTER:
634 {
635 string username(clientMsg.buffer);
636 string password(strchr(clientMsg.buffer, '\0')+1);
637 Player::PlayerClass playerClass;
638
639 serverMsg.type = MSG_TYPE_REGISTER;
640 memcpy(&playerClass, clientMsg.buffer+username.length()+password.length()+2, 4);
641
642 cout << "username: " << username << endl;
643 cout << "password: " << password << endl;
644
645 if (playerClass == Player::CLASS_WARRIOR)
646 cout << "class: WARRIOR" << endl;
647 else if (playerClass == Player::CLASS_RANGER)
648 cout << "class: RANGER" << endl;
649 else {
650 cout << "Unknown player class detected" << endl;
651 strcpy(serverMsg.buffer, "You didn't select a class");
652 break;
653 }
654
655 int error = da.insertPlayer(username, password, playerClass);
656
657 if (error)
658 strcpy(serverMsg.buffer, "Registration failed. Please try again.");
659 else
660 strcpy(serverMsg.buffer, "Registration successful.");
661
662 break;
663 }
664 case MSG_TYPE_LOGIN:
665 {
666 cout << "Got login message" << endl;
667
668 string username(clientMsg.buffer);
669 string password(strchr(clientMsg.buffer, '\0')+1);
670
671 Player* p = da.getPlayer(username);
672
673 if (p == NULL || !da.verifyPassword(password, p->password))
674 {
675 strcpy(serverMsg.buffer, "Incorrect username or password");
676 if (p != NULL)
677 delete(p);
678 }
679 else if(findPlayerByName(mapPlayers, username) != NULL)
680 {
681 strcpy(serverMsg.buffer, "Player has already logged in.");
682 delete(p);
683 }
684 else
685 {
686 updateUnusedPlayerId(unusedPlayerId, mapPlayers);
687 p->id = unusedPlayerId;
688 cout << "new player id: " << p->id << endl;
689 p->setAddr(from);
690 p->currentGame = NULL;
691
692 // choose a random team (either 0 or 1)
693 p->team = rand() % 2;
694
695 serverMsg.type = MSG_TYPE_PLAYER;
696
697 // tell the new player about all the existing players
698 cout << "Sending other players to new player" << endl;
699
700 map<unsigned int, Player*>::iterator it;
701 for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
702 {
703 it->second->serialize(serverMsg.buffer);
704
705 cout << "sending info about " << it->second->name << endl;
706 cout << "sending id " << it->second->id << endl;
707 if ( msgProcessor.sendMessage(&serverMsg, sock, &from, &outputLog) < 0 )
708 error("sendMessage");
709 }
710
711 // tell the new player about all map objects
712 // (currently just the flags)
713 serverMsg.type = MSG_TYPE_OBJECT;
714 vector<WorldMap::Object>* vctObjects = gameMap->getObjects();
715 vector<WorldMap::Object>::iterator itObjects;
716 cout << "sending items" << endl;
717 for (itObjects = vctObjects->begin(); itObjects != vctObjects->end(); itObjects++) {
718 itObjects->serialize(serverMsg.buffer);
719 cout << "sending item id " << itObjects->id << endl;
720 if ( msgProcessor.sendMessage(&serverMsg, sock, &from, &outputLog) < 0 )
721 error("sendMessage");
722 }
723
724 // send info about existing games to new player
725 map<string, Game*>::iterator itGames;
726 Game* g;
727 int numPlayers;
728 serverMsg.type = MSG_TYPE_GAME_INFO;
729
730 for (itGames = mapGames.begin(); itGames != mapGames.end(); itGames++)
731 {
732 g = itGames->second;
733 numPlayers = g->getNumPlayers();
734 memcpy(serverMsg.buffer, &numPlayers, 4);
735 strcpy(serverMsg.buffer+4, g->getName().c_str());
736 if ( msgProcessor.sendMessage(&serverMsg, sock, &from, &outputLog) < 0 )
737 error("sendMessage");
738 }
739
740 // send the current score
741 serverMsg.type = MSG_TYPE_SCORE;
742 memcpy(serverMsg.buffer, &scoreBlue, 4);
743 memcpy(serverMsg.buffer+4, &scoreRed, 4);
744 if ( msgProcessor.sendMessage(&serverMsg, sock, &from, &outputLog) < 0 )
745 error("sendMessage");
746
747 serverMsg.type = MSG_TYPE_PLAYER;
748 p->serialize(serverMsg.buffer);
749 cout << "Should be broadcasting the message" << endl;
750
751 for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
752 {
753 cout << "Sent message back to " << it->second->name << endl;
754 if ( msgProcessor.sendMessage(&serverMsg, sock, &(it->second->addr), &outputLog) < 0 )
755 error("sendMessage");
756 }
757
758 mapPlayers[unusedPlayerId] = p;
759 }
760
761 serverMsg.type = MSG_TYPE_LOGIN;
762
763 break;
764 }
765 case MSG_TYPE_LOGOUT:
766 {
767 string name(clientMsg.buffer);
768 cout << "Player logging out: " << name << endl;
769
770 Player *p = findPlayerByName(mapPlayers, name);
771
772 if (p == NULL)
773 {
774 strcpy(serverMsg.buffer+4, "That player is not logged in. This is either a bug, or you're trying to hack the server.");
775 cout << "Player not logged in" << endl;
776 }
777 else if ( p->addr.sin_addr.s_addr != from.sin_addr.s_addr ||
778 p->addr.sin_port != from.sin_port )
779 {
780 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.");
781 cout << "Player logged in using a different connection" << endl;
782 }
783 else
784 {
785 if (!p->isDead) {
786 WorldMap::ObjectType flagType = WorldMap::OBJECT_NONE;
787 if (p->hasBlueFlag)
788 flagType = WorldMap::OBJECT_BLUE_FLAG;
789 else if (p->hasRedFlag)
790 flagType = WorldMap::OBJECT_RED_FLAG;
791
792 if (flagType != WorldMap::OBJECT_NONE) {
793 addObjectToMap(flagType, p->pos.x, p->pos.y, gameMap, mapPlayers, msgProcessor, sock, outputLog);
794 }
795 }
796
797 // broadcast to all players before deleting p from the map
798 serverMsg.type = MSG_TYPE_LOGOUT;
799 memcpy(serverMsg.buffer, &p->id, 4);
800
801 map<unsigned int, Player*>::iterator it;
802 for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
803 {
804 cout << "Sent message back to " << it->second->name << endl;
805 if ( msgProcessor.sendMessage(&serverMsg, sock, &(it->second->addr), &outputLog) < 0 )
806 error("sendMessage");
807 }
808
809 if (p->id < unusedPlayerId)
810 unusedPlayerId = p->id;
811 mapPlayers.erase(p->id);
812 delete p;
813 strcpy(serverMsg.buffer+4, "You have successfully logged out.");
814 }
815
816 serverMsg.type = MSG_TYPE_LOGOUT;
817
818 break;
819 }
820 case MSG_TYPE_CHAT:
821 {
822 cout << "Got a chat message" << endl;
823
824 Player *p = findPlayerByAddr(mapPlayers, from);
825
826 if (p == NULL)
827 {
828 strcpy(serverMsg.buffer, "No player is logged in using this connection. This is either a bug, or you're trying to hack the server.");
829 }
830 else
831 {
832 broadcastResponse = true;
833
834 ostringstream oss;
835 oss << p->name << ": " << clientMsg.buffer;
836
837 strcpy(serverMsg.buffer, oss.str().c_str());
838 }
839
840 serverMsg.type = MSG_TYPE_CHAT;
841
842 break;
843 }
844 case MSG_TYPE_PLAYER_MOVE:
845 {
846 cout << "PLAYER_MOVE" << endl;
847
848 int id, x, y;
849
850 memcpy(&id, clientMsg.buffer, 4);
851 memcpy(&x, clientMsg.buffer+4, 4);
852 memcpy(&y, clientMsg.buffer+8, 4);
853
854 cout << "x: " << x << endl;
855 cout << "y: " << y << endl;
856 cout << "id: " << id << endl;
857
858 Player* p = mapPlayers[id];
859
860 if ( p->addr.sin_addr.s_addr == from.sin_addr.s_addr &&
861 p->addr.sin_port == from.sin_port )
862 {
863 if (p->currentGame->startPlayerMovement(id, x, y)) {
864 serverMsg.type = MSG_TYPE_PLAYER_MOVE;
865
866 memcpy(serverMsg.buffer, &id, 4);
867 memcpy(serverMsg.buffer+4, &p->target.x, 4);
868 memcpy(serverMsg.buffer+8, &p->target.y, 4);
869
870 broadcastResponse = true;
871 }
872 else
873 cout << "Bad terrain detected" << endl;
874 }
875 else // nned to send back a message indicating failure
876 cout << "Player id (" << id << ") doesn't match sender" << endl;
877
878 break;
879 }
880 case MSG_TYPE_PICKUP_FLAG:
881 {
882 // may want to check the id matches the sender, just like for PLAYER_NOVE
883 cout << "PICKUP_FLAG" << endl;
884
885 int id;
886
887 memcpy(&id, clientMsg.buffer, 4);
888 cout << "id: " << id << endl;
889
890 Player* p = mapPlayers[id];
891 int objectId = p->currentGame->processFlagPickupRequest(p);
892
893 if (objectId >= 0) {
894 serverMsg.type = MSG_TYPE_REMOVE_OBJECT;
895 memcpy(serverMsg.buffer, &objectId, 4);
896
897 map<unsigned int, Player*> players = p->currentGame->getPlayers();
898 map<unsigned int, Player*>::iterator it;
899 for (it = players.begin(); it != players.end(); it++)
900 {
901 if ( msgProcessor.sendMessage(&serverMsg, sock, &(it->second->addr), &outputLog) < 0 )
902 error("sendMessage");
903 }
904
905 }
906
907 // if there was no flag to pickup, we really don't need to send a message
908 serverMsg.type = MSG_TYPE_PLAYER;
909 p->serialize(serverMsg.buffer);
910
911 break;
912 }
913 case MSG_TYPE_DROP_FLAG:
914 {
915 // may want to check the id matches the sender, just like for PLAYER_NOVE
916 cout << "DROP_FLAG" << endl;
917
918 int id;
919
920 memcpy(&id, clientMsg.buffer, 4);
921 cout << "id: " << id << endl;
922
923 Player* p = mapPlayers[id];
924
925 WorldMap::ObjectType flagType = WorldMap::OBJECT_NONE;
926 if (p->hasBlueFlag)
927 flagType = WorldMap::OBJECT_BLUE_FLAG;
928 else if (p->hasRedFlag)
929 flagType = WorldMap::OBJECT_RED_FLAG;
930
931 addObjectToMap(flagType, p->pos.x, p->pos.y, p->currentGame->getMap(), p->currentGame->getPlayers(), msgProcessor, sock, outputLog);
932
933 p->hasBlueFlag = false;
934 p->hasRedFlag = false;
935
936 serverMsg.type = MSG_TYPE_PLAYER;
937 p->serialize(serverMsg.buffer);
938
939 broadcastResponse = true;
940
941 break;
942 }
943 case MSG_TYPE_START_ATTACK:
944 {
945 cout << "Received a START_ATTACK message" << endl;
946
947 int id, targetId;
948
949 memcpy(&id, clientMsg.buffer, 4);
950 memcpy(&targetId, clientMsg.buffer+4, 4);
951
952 // need to make sure the target is in the sender's game
953
954 Player* source = mapPlayers[id];
955 source->targetPlayer = targetId;
956 source->isChasing = true;
957
958 // this is irrelevant since the client doesn't even listen for START_ATTACK messages
959 // actually, the client should not ignore this and should instead perform the same movement
960 // algorithm on its end (following the target player until in range) that the server does.
961 // Once the attacker is in range, the client should stop movement and wait for messages
962 // from the server
963 serverMsg.type = MSG_TYPE_START_ATTACK;
964 memcpy(serverMsg.buffer, &id, 4);
965 memcpy(serverMsg.buffer+4, &targetId, 4);
966 broadcastResponse = true;
967
968 break;
969 }
970 case MSG_TYPE_ATTACK:
971 {
972 cout << "Received am ATTACK message" << endl;
973 cout << "ERROR: Clients should not send ATTACK messages" << endl;
974
975 break;
976 }
977 case MSG_TYPE_CREATE_GAME:
978 {
979 cout << "Received a CREATE_GAME message" << endl;
980
981 string gameName(clientMsg.buffer);
982 cout << "Game name: " << gameName << endl;
983
984 // check if this game already exists
985 if (mapGames.find(gameName) != mapGames.end()) {
986 cout << "Error: Game already exists" << endl;
987 serverMsg.type = MSG_TYPE_JOIN_GAME_FAILURE;
988 broadcastResponse = false;
989 return broadcastResponse;
990 }
991
992 Game* g = new Game(gameName, "../data/map.txt");
993 mapGames[gameName] = g;
994
995 // add flag objects to the map
996 WorldMap* m = g->getMap();
997 for (int y=0; y<m->height; y++) {
998 for (int x=0; x<m->width; x++) {
999 switch (m->getStructure(x, y)) {
1000 case WorldMap::STRUCTURE_BLUE_FLAG:
1001 m->addObject(WorldMap::OBJECT_BLUE_FLAG, x*25+12, y*25+12);
1002 break;
1003 case WorldMap::STRUCTURE_RED_FLAG:
1004 m->addObject(WorldMap::OBJECT_RED_FLAG, x*25+12, y*25+12);
1005 break;
1006 }
1007 }
1008 }
1009
1010 Player* p = findPlayerByAddr(mapPlayers, from);
1011 p->currentGame = g;
1012
1013 serverMsg.type = MSG_TYPE_JOIN_GAME_SUCCESS;
1014 strcpy(serverMsg.buffer, gameName.c_str());
1015 broadcastResponse = false;
1016
1017 break;
1018 }
1019 case MSG_TYPE_JOIN_GAME:
1020 {
1021 cout << "Received a JOIN_GAME message" << endl;
1022
1023 string gameName(clientMsg.buffer);
1024 cout << "Game name: " << gameName << endl;
1025
1026 // check if this game already exists
1027 if (mapGames.find(gameName) == mapGames.end()) {
1028 cout << "Error: Game does not exist" << endl;
1029 serverMsg.type = MSG_TYPE_JOIN_GAME_FAILURE;
1030 broadcastResponse = false;
1031 return broadcastResponse;
1032 }
1033
1034 Game* g = mapGames[gameName];
1035 map<unsigned int, Player*>& players = g->getPlayers();
1036 Player* p = findPlayerByAddr(mapPlayers, from);
1037
1038 if (players.find(p->id) != players.end()) {
1039 cout << "Player " << p->name << " trying to join a game he's already in" << endl;
1040 serverMsg.type = MSG_TYPE_JOIN_GAME_FAILURE;
1041 broadcastResponse = false;
1042 return broadcastResponse;
1043 }
1044
1045 p->currentGame = g;
1046
1047 serverMsg.type = MSG_TYPE_JOIN_GAME_SUCCESS;
1048 strcpy(serverMsg.buffer, gameName.c_str());
1049 broadcastResponse = false;
1050
1051 break;
1052 }
1053 case MSG_TYPE_LEAVE_GAME:
1054 {
1055 cout << "Received a LEAVE_GAME message" << endl;
1056
1057 Player* p = findPlayerByAddr(mapPlayers, from);
1058 Game* g = p->currentGame;
1059
1060 if (g == NULL) {
1061 cout << "Player " << p->name << " is trying to leave a game, but is not currently in a game." << endl;
1062
1063 /// should send a response back, maybe a new message type is needed
1064
1065 break;
1066 }
1067
1068 cout << "Game name: " << g->getName() << endl;
1069 p->currentGame = NULL;
1070
1071 serverMsg.type = MSG_TYPE_LEAVE_GAME;
1072 memcpy(serverMsg.buffer, &p->id, 4);
1073 strcpy(serverMsg.buffer+4, g->getName().c_str());
1074
1075 map<unsigned int, Player*>& players = g->getPlayers();
1076
1077 map<unsigned int, Player*>::iterator it;
1078 for (it = players.begin(); it != players.end(); it++)
1079 {
1080 if ( msgProcessor.sendMessage(&serverMsg, sock, &(it->second->addr), &outputLog) < 0 )
1081 error("sendMessage");
1082 }
1083
1084 g->removePlayer(p->id);
1085
1086 int numPlayers = g->getNumPlayers();
1087
1088 serverMsg.type = MSG_TYPE_GAME_INFO;
1089 memcpy(serverMsg.buffer, &numPlayers, 4);
1090 strcpy(serverMsg.buffer+4, g->getName().c_str());
1091 broadcastResponse = true;
1092
1093 // if there are no more players in the game, remove it
1094 if (numPlayers == 0) {
1095 mapGames.erase(g->getName());
1096 delete g;
1097 }
1098
1099 break;
1100 }
1101 case MSG_TYPE_JOIN_GAME_ACK:
1102 {
1103 cout << "Received a JOIN_GAME_ACK message" << endl;
1104
1105 string gameName(clientMsg.buffer);
1106 cout << "Game name: " << gameName << endl;
1107
1108 // check if this game already exists
1109 if (mapGames.find(gameName) == mapGames.end()) {
1110 serverMsg.type = MSG_TYPE_JOIN_GAME_FAILURE;
1111 broadcastResponse = false;
1112 return broadcastResponse;
1113 }
1114
1115 Game* g = mapGames[gameName];
1116
1117 Player* p = findPlayerByAddr(mapPlayers, from);
1118 p->team = rand() % 2; // choose a random team (either 0 or 1)
1119 p->currentGame = g; // should have been done in JOIN_GAME, so not necessary
1120
1121 // tell the new player about all map objects
1122 // (currently just the flags)
1123
1124 serverMsg.type = MSG_TYPE_OBJECT;
1125 vector<WorldMap::Object>* vctObjects = g->getMap()->getObjects();
1126 vector<WorldMap::Object>::iterator itObjects;
1127 cout << "sending items" << endl;
1128 for (itObjects = vctObjects->begin(); itObjects != vctObjects->end(); itObjects++) {
1129 itObjects->serialize(serverMsg.buffer);
1130 cout << "sending item id " << itObjects->id << endl;
1131 if ( msgProcessor.sendMessage(&serverMsg, sock, &from, &outputLog) < 0 )
1132 error("sendMessage");
1133 }
1134
1135
1136 // send the current score
1137 serverMsg.type = MSG_TYPE_SCORE;
1138
1139 int game_blueScore = g->getBlueScore();
1140 int game_redScore = g->getRedScore();
1141 memcpy(serverMsg.buffer, &game_blueScore, 4);
1142 memcpy(serverMsg.buffer+4, &game_redScore, 4);
1143
1144 if ( msgProcessor.sendMessage(&serverMsg, sock, &from, &outputLog) < 0 )
1145 error("sendMessage");
1146
1147 serverMsg.type = MSG_TYPE_PLAYER_JOIN_GAME;
1148 p->serialize(serverMsg.buffer);
1149 cout << "Should be broadcasting the message" << endl;
1150
1151 map<unsigned int, Player*>& otherPlayers = g->getPlayers();
1152 map<unsigned int, Player*>::iterator it;
1153 for (it = otherPlayers.begin(); it != otherPlayers.end(); it++)
1154 {
1155 cout << "Sent message back to " << it->second->name << endl;
1156 if ( msgProcessor.sendMessage(&serverMsg, sock, &(it->second->addr), &outputLog) < 0 )
1157 error("sendMessage");
1158 }
1159
1160 g->addPlayer(p);
1161
1162 map<unsigned int, Player*>& allPlayers = g->getPlayers();
1163
1164 // tell the new player about all the players in the game (including himself)
1165 cout << "Sending other players to new player" << endl;
1166 serverMsg.type = MSG_TYPE_PLAYER_JOIN_GAME;
1167
1168 for (it = allPlayers.begin(); it != allPlayers.end(); it++)
1169 {
1170 it->second->serialize(serverMsg.buffer);
1171
1172 cout << "sending info about " << it->second->name << endl;
1173 cout << "sending id " << it->second->id << endl;
1174 if ( msgProcessor.sendMessage(&serverMsg, sock, &from, &outputLog) < 0 )
1175 error("sendMessage");
1176 }
1177
1178 int numPlayers = g->getNumPlayers();
1179
1180 serverMsg.type = MSG_TYPE_GAME_INFO;
1181 memcpy(serverMsg.buffer, &numPlayers, 4);
1182 strcpy(serverMsg.buffer+4, gameName.c_str());
1183 broadcastResponse = true;
1184
1185 break;
1186 }
1187 default:
1188 {
1189 serverMsg.type = MSG_TYPE_CHAT;
1190 strcpy(serverMsg.buffer, "Server error occured. Report this please.");
1191
1192 break;
1193 }
1194 }
1195
1196 return broadcastResponse;
1197}
1198
1199void updateUnusedPlayerId(unsigned int& id, map<unsigned int, Player*>& mapPlayers)
1200{
1201 while (mapPlayers.find(id) != mapPlayers.end())
1202 id++;
1203}
1204
1205Player *findPlayerByName(map<unsigned int, Player*> &m, string name)
1206{
1207 map<unsigned int, Player*>::iterator it;
1208
1209 for (it = m.begin(); it != m.end(); it++)
1210 {
1211 if ( it->second->name.compare(name) == 0 )
1212 return it->second;
1213 }
1214
1215 return NULL;
1216}
1217
1218Player *findPlayerByAddr(map<unsigned int, Player*> &m, const sockaddr_in &addr)
1219{
1220 map<unsigned int, Player*>::iterator it;
1221
1222 for (it = m.begin(); it != m.end(); it++)
1223 {
1224 if ( it->second->addr.sin_addr.s_addr == addr.sin_addr.s_addr &&
1225 it->second->addr.sin_port == addr.sin_port )
1226 return it->second;
1227 }
1228
1229 return NULL;
1230}
1231
1232void damagePlayer(Player *p, int damage) {
1233 p->health -= damage;
1234 if (p->health < 0)
1235 p->health = 0;
1236 if (p->health == 0) {
1237 cout << "Player died" << endl;
1238 p->isDead = true;
1239 p->timeDied = getCurrentMillis();
1240 }
1241}
1242
1243void addObjectToMap(WorldMap::ObjectType objectType, int x, int y, WorldMap* gameMap, map<unsigned int, Player*>& mapPlayers, MessageProcessor &msgProcessor, int sock, ofstream& outputLog) {
1244 NETWORK_MSG serverMsg;
1245
1246 gameMap->addObject(objectType, x, y);
1247
1248 // need to send the OBJECT message too
1249 serverMsg.type = MSG_TYPE_OBJECT;
1250 gameMap->getObjects()->back().serialize(serverMsg.buffer);
1251
1252 map<unsigned int, Player*>::iterator it;
1253 for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
1254 {
1255 if ( msgProcessor.sendMessage(&serverMsg, sock, &(it->second->addr), &outputLog) < 0 )
1256 error("sendMessage");
1257 }
1258}
Note: See TracBrowser for help on using the repository browser.