source: network-game/server/server.cpp@ 8a4ed74

Last change on this file since 8a4ed74 was 8a4ed74, checked in by dportnoy <dmp1488@…>, 12 years ago

Made some minor server changes to help handle player attacks
  • Property mode set to 100644
File size: 24.1 KB
Line 
1#include <cstdlib>
2#include <cstdio>
3#include <unistd.h>
4#include <string>
5#include <iostream>
6#include <sstream>
7#include <cstring>
8#include <cmath>
9
10#include <vector>
11#include <map>
12
13#include <sys/time.h>
14
15#include <sys/socket.h>
16#include <netdb.h>
17#include <netinet/in.h>
18#include <arpa/inet.h>
19
20#include <crypt.h>
21
22/*
23#include <openssl/bio.h>
24#include <openssl/ssl.h>
25#include <openssl/err.h>
26*/
27
28#include "../common/Compiler.h"
29#include "../common/Common.h"
30#include "../common/Message.h"
31#include "../common/WorldMap.h"
32#include "../common/Player.h"
33
34#include "DataAccess.h"
35
36using namespace std;
37
38// from used to be const. Removed that so I could take a reference
39// and use it to send messages
40bool processMessage(const NETWORK_MSG &clientMsg, struct sockaddr_in &from, map<unsigned int, Player>& mapPlayers, WorldMap* gameMap, unsigned int& unusedId, NETWORK_MSG &serverMsg, int sock, int &scoreBlue, int &scoreRed);
41
42void updateUnusedId(unsigned int& id, map<unsigned int, Player>& mapPlayers);
43
44// this should probably go somewhere in the common folder
45void error(const char *msg)
46{
47 perror(msg);
48 exit(0);
49}
50
51Player *findPlayerByName(map<unsigned int, Player> &m, string name)
52{
53 map<unsigned int, Player>::iterator it;
54
55 for (it = m.begin(); it != m.end(); it++)
56 {
57 if ( it->second.name.compare(name) == 0 )
58 return &(it->second);
59 }
60
61 return NULL;
62}
63
64Player *findPlayerByAddr(map<unsigned int, Player> &m, const sockaddr_in &addr)
65{
66 map<unsigned int, Player>::iterator it;
67
68 for (it = m.begin(); it != m.end(); it++)
69 {
70 if ( it->second.addr.sin_addr.s_addr == addr.sin_addr.s_addr &&
71 it->second.addr.sin_port == addr.sin_port )
72 return &(it->second);
73 }
74
75 return NULL;
76}
77
78int main(int argc, char *argv[])
79{
80 int sock, length, n;
81 struct sockaddr_in server;
82 struct sockaddr_in from; // info of client sending the message
83 NETWORK_MSG clientMsg, serverMsg;
84 map<unsigned int, Player> mapPlayers;
85 unsigned int unusedId = 1;
86 int scoreBlue, scoreRed;
87
88 scoreBlue = 0;
89 scoreRed = 0;
90
91 //SSL_load_error_strings();
92 //ERR_load_BIO_strings();
93 //OpenSSL_add_all_algorithms();
94
95 if (argc < 2) {
96 cerr << "ERROR, no port provided" << endl;
97 exit(1);
98 }
99
100 WorldMap* gameMap = WorldMap::loadMapFromFile("../data/map.txt");
101
102 // add some items to the map. They will be sent out
103 // to players when they login
104 for (int y=0; y<gameMap->height; y++) {
105 for (int x=0; x<gameMap->width; x++) {
106 switch (gameMap->getStructure(x, y)) {
107 case WorldMap::STRUCTURE_BLUE_FLAG:
108 gameMap->addObject(WorldMap::OBJECT_BLUE_FLAG, x*25+12, y*25+12);
109 break;
110 case WorldMap::STRUCTURE_RED_FLAG:
111 gameMap->addObject(WorldMap::OBJECT_RED_FLAG, x*25+12, y*25+12);
112 break;
113 }
114 }
115 }
116
117 sock = socket(AF_INET, SOCK_DGRAM, 0);
118 if (sock < 0) error("Opening socket");
119 length = sizeof(server);
120 bzero(&server,length);
121 server.sin_family=AF_INET;
122 server.sin_port=htons(atoi(argv[1]));
123 server.sin_addr.s_addr=INADDR_ANY;
124 if ( bind(sock, (struct sockaddr *)&server, length) < 0 )
125 error("binding");
126
127 set_nonblock(sock);
128
129 bool broadcastResponse;
130 timespec ts;
131 int timeLastUpdated = 0, curTime = 0, timeLastBroadcast = 0;
132 while (true) {
133
134 usleep(5000);
135
136 clock_gettime(CLOCK_REALTIME, &ts);
137 // make the number smaller so millis can fit in an int
138 ts.tv_sec -= 1368000000;
139 curTime = ts.tv_sec*1000 + ts.tv_nsec/1000000;
140
141 if (timeLastUpdated == 0 || (curTime-timeLastUpdated) >= 50) {
142 timeLastUpdated = curTime;
143
144 // maybe put this in a separate method
145 map<unsigned int, Player>::iterator it;
146 FLOAT_POSITION oldPos;
147 bool broadcastMove = false;
148 for (it = mapPlayers.begin(); it != mapPlayers.end(); it++) {
149 oldPos = it->second.pos;
150 if (it->second.move(gameMap)) {
151
152 // check if the move needs to be canceled
153 switch(gameMap->getElement(it->second.pos.x/25, it->second.pos.y/25)) {
154 case WorldMap::TERRAIN_NONE:
155 case WorldMap::TERRAIN_OCEAN:
156 case WorldMap::TERRAIN_ROCK:
157 {
158 it->second.pos = oldPos;
159 it->second.target.x = it->second.pos.x;
160 it->second.target.y = it->second.pos.y;
161 broadcastMove = true;
162 break;
163 }
164 default:
165 // if there are no obstacles, do nothing
166 break;
167 }
168
169 WorldMap::ObjectType flagType;
170 POSITION pos;
171 bool flagTurnedIn = false;
172 bool flagReturned = false;
173 bool ownFlagAtBase = false;
174
175 switch(gameMap->getStructure(it->second.pos.x/25, it->second.pos.y/25)) {
176 case WorldMap::STRUCTURE_BLUE_FLAG:
177 {
178 if (it->second.team == 0 && it->second.hasRedFlag)
179 {
180 // check that your flag is at your base
181 pos = gameMap->getStructureLocation(WorldMap::STRUCTURE_BLUE_FLAG);
182
183 vector<WorldMap::Object>* vctObjects = gameMap->getObjects();
184 vector<WorldMap::Object>::iterator itObjects;
185
186 for (itObjects = vctObjects->begin(); itObjects != vctObjects->end(); itObjects++) {
187 if (itObjects->type == WorldMap::OBJECT_BLUE_FLAG) {
188 if (itObjects->pos.x == pos.x*25+12 && itObjects->pos.y == pos.y*25+12) {
189 ownFlagAtBase = true;
190 break;
191 }
192 }
193 }
194
195 if (ownFlagAtBase) {
196 it->second.hasRedFlag = false;
197 flagType = WorldMap::OBJECT_RED_FLAG;
198 pos = gameMap->getStructureLocation(WorldMap::STRUCTURE_RED_FLAG);
199 flagTurnedIn = true;
200 scoreBlue++;
201 }
202 }
203
204 break;
205 }
206 case WorldMap::STRUCTURE_RED_FLAG:
207 {
208 if (it->second.team == 1 && it->second.hasBlueFlag)
209 {
210 // check that your flag is at your base
211 pos = gameMap->getStructureLocation(WorldMap::STRUCTURE_RED_FLAG);
212
213 vector<WorldMap::Object>* vctObjects = gameMap->getObjects();
214 vector<WorldMap::Object>::iterator itObjects;
215
216 for (itObjects = vctObjects->begin(); itObjects != vctObjects->end(); itObjects++) {
217 if (itObjects->type == WorldMap::OBJECT_RED_FLAG) {
218 if (itObjects->pos.x == pos.x*25+12 && itObjects->pos.y == pos.y*25+12) {
219 ownFlagAtBase = true;
220 break;
221 }
222 }
223 }
224
225 if (ownFlagAtBase) {
226 it->second.hasBlueFlag = false;
227 flagType = WorldMap::OBJECT_BLUE_FLAG;
228 pos = gameMap->getStructureLocation(WorldMap::STRUCTURE_BLUE_FLAG);
229 flagTurnedIn = true;
230 scoreRed++;
231 }
232 }
233
234 break;
235 }
236 }
237
238 if (flagTurnedIn) {
239 // send an OBJECT message to add the flag back to its spawn point
240 pos.x = pos.x*25+12;
241 pos.y = pos.y*25+12;
242 gameMap->addObject(flagType, pos.x, pos.y);
243
244 serverMsg.type = MSG_TYPE_OBJECT;
245 gameMap->getObjects()->back().serialize(serverMsg.buffer);
246
247 map<unsigned int, Player>::iterator it2;
248 for (it2 = mapPlayers.begin(); it2 != mapPlayers.end(); it2++)
249 {
250 if ( sendMessage(&serverMsg, sock, &(it2->second.addr)) < 0 )
251 error("sendMessage");
252 }
253
254 serverMsg.type = MSG_TYPE_SCORE;
255 memcpy(serverMsg.buffer, &scoreBlue, 4);
256 memcpy(serverMsg.buffer+4, &scoreRed, 4);
257
258 for (it2 = mapPlayers.begin(); it2 != mapPlayers.end(); it2++)
259 {
260 if ( sendMessage(&serverMsg, sock, &(it2->second.addr)) < 0 )
261 error("sendMessage");
262 }
263
264 // this means a PLAYER message will be sent
265 broadcastMove = true;
266 }
267
268 // go through all objects and check if the player is close to one and if its their flag
269 vector<WorldMap::Object>* vctObjects = gameMap->getObjects();
270 vector<WorldMap::Object>::iterator itObjects;
271 POSITION structPos;
272
273 for (itObjects = vctObjects->begin(); itObjects != vctObjects->end(); itObjects++) {
274 POSITION pos = itObjects->pos;
275
276 if (posDistance(it->second.pos, pos.toFloat()) < 10) {
277 if (it->second.team == 0 &&
278 itObjects->type == WorldMap::OBJECT_BLUE_FLAG) {
279 structPos = gameMap->getStructureLocation(WorldMap::STRUCTURE_BLUE_FLAG);
280 flagReturned = true;
281 break;
282 } else if (it->second.team == 1 &&
283 itObjects->type == WorldMap::OBJECT_RED_FLAG) {
284 structPos = gameMap->getStructureLocation(WorldMap::STRUCTURE_RED_FLAG);
285 flagReturned = true;
286 break;
287 }
288 }
289 }
290
291 if (flagReturned) {
292 itObjects->pos.x = structPos.x*25+12;
293 itObjects->pos.y = structPos.y*25+12;
294
295 serverMsg.type = MSG_TYPE_OBJECT;
296 itObjects->serialize(serverMsg.buffer);
297
298 map<unsigned int, Player>::iterator it2;
299 for (it2 = mapPlayers.begin(); it2 != mapPlayers.end(); it2++)
300 {
301 if ( sendMessage(&serverMsg, sock, &(it2->second.addr)) < 0 )
302 error("sendMessage");
303 }
304 }
305
306 if (broadcastMove) {
307 serverMsg.type = MSG_TYPE_PLAYER;
308 it->second.serialize(serverMsg.buffer);
309
310 cout << "about to broadcast move" << endl;
311 map<unsigned int, Player>::iterator it2;
312 for (it2 = mapPlayers.begin(); it2 != mapPlayers.end(); it2++)
313 {
314 if ( sendMessage(&serverMsg, sock, &(it2->second.addr)) < 0 )
315 error("sendMessage");
316 }
317 }
318 }
319 }
320 }
321
322 n = receiveMessage(&clientMsg, sock, &from);
323
324 if (n >= 0) {
325 broadcastResponse = processMessage(clientMsg, from, mapPlayers, gameMap, unusedId, serverMsg, sock, scoreBlue, scoreRed);
326
327 if (broadcastResponse)
328 {
329 cout << "Should be broadcasting the message" << endl;
330
331 map<unsigned int, Player>::iterator it;
332 for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
333 {
334 cout << "Sent message back to " << it->second.name << endl;
335 if ( sendMessage(&serverMsg, sock, &(it->second.addr)) < 0 )
336 error("sendMessage");
337 }
338 }
339 else
340 {
341 cout << "Should be sending back the message" << endl;
342
343 if ( sendMessage(&serverMsg, sock, &from) < 0 )
344 error("sendMessage");
345 }
346 }
347 }
348
349 return 0;
350}
351
352bool processMessage(const NETWORK_MSG& clientMsg, struct sockaddr_in& from, map<unsigned int, Player>& mapPlayers, WorldMap* gameMap, unsigned int& unusedId, NETWORK_MSG& serverMsg, int sock, int &scoreBlue, int &scoreRed)
353{
354 DataAccess da;
355
356 cout << "Received message" << endl;
357 cout << "MSG: type: " << clientMsg.type << endl;
358 cout << "MSG contents: " << clientMsg.buffer << endl;
359
360 // maybe we should make a message class and have this be a member
361 bool broadcastResponse = false;
362
363 // Check that if an invalid message is sent, the client will correctly
364 // receive and display the response. Maybe make a special error msg type
365 switch(clientMsg.type)
366 {
367 case MSG_TYPE_REGISTER:
368 {
369 string username(clientMsg.buffer);
370 string password(strchr(clientMsg.buffer, '\0')+1);
371
372 cout << "username: " << username << endl;
373 cout << "password: " << password << endl;
374
375 int error = da.insertPlayer(username, password);
376
377 if (!error)
378 strcpy(serverMsg.buffer, "Registration successful.");
379 else
380 strcpy(serverMsg.buffer, "Registration failed. Please try again.");
381
382 serverMsg.type = MSG_TYPE_REGISTER;
383
384 break;
385 }
386 case MSG_TYPE_LOGIN:
387 {
388 cout << "Got login message" << endl;
389
390 serverMsg.type = MSG_TYPE_LOGIN;
391
392 string username(clientMsg.buffer);
393 string password(strchr(clientMsg.buffer, '\0')+1);
394
395 Player* p = da.getPlayer(username);
396
397 if (p == NULL || !da.verifyPassword(password, p->password))
398 {
399 strcpy(serverMsg.buffer, "Incorrect username or password");
400 }
401 else if(findPlayerByName(mapPlayers, username) != NULL)
402 {
403 strcpy(serverMsg.buffer, "Player has already logged in.");
404 }
405 else
406 {
407 serverMsg.type = MSG_TYPE_PLAYER;
408
409 updateUnusedId(unusedId, mapPlayers);
410 p->id = unusedId;
411 cout << "new player id: " << p->id << endl;
412 p->setAddr(from);
413
414 // choose a random team (either 0 or 1)
415 p->team = rand() % 2;
416
417 // choose a random class
418 int intClass = rand() % 2;
419 switch (intClass) {
420 case 0:
421 p->setClass(Player::CLASS_WARRIOR);
422 break;
423 case 1:
424 p->setClass(Player::CLASS_RANGER);
425 break;
426 }
427
428 // tell the new player about all the existing players
429 cout << "Sending other players to new player" << endl;
430
431 map<unsigned int, Player>::iterator it;
432 for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
433 {
434 it->second.serialize(serverMsg.buffer);
435
436 cout << "sending info about " << it->second.name << endl;
437 cout << "sending id " << it->second.id << endl;
438 if ( sendMessage(&serverMsg, sock, &from) < 0 )
439 error("sendMessage");
440 }
441
442 // tell the new player about all map objects
443 // (currently just the flags)
444 serverMsg.type = MSG_TYPE_OBJECT;
445 vector<WorldMap::Object>* vctObjects = gameMap->getObjects();
446 vector<WorldMap::Object>::iterator itObjects;
447 cout << "sending items" << endl;
448 for (itObjects = vctObjects->begin(); itObjects != vctObjects->end(); itObjects++) {
449 itObjects->serialize(serverMsg.buffer);
450 cout << "sending item id " << itObjects->id << endl;
451 if ( sendMessage(&serverMsg, sock, &from) < 0 )
452 error("sendMessage");
453 }
454
455 // send the current score
456 serverMsg.type = MSG_TYPE_SCORE;
457 memcpy(serverMsg.buffer, &scoreBlue, 4);
458 memcpy(serverMsg.buffer+4, &scoreRed, 4);
459 if ( sendMessage(&serverMsg, sock, &from) < 0 )
460 error("sendMessage");
461
462 serverMsg.type = MSG_TYPE_PLAYER;
463 p->serialize(serverMsg.buffer);
464 cout << "Should be broadcasting the message" << endl;
465
466 for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
467 {
468 cout << "Sent message back to " << it->second.name << endl;
469 if ( sendMessage(&serverMsg, sock, &(it->second.addr)) < 0 )
470 error("sendMessage");
471 }
472
473 serverMsg.type = MSG_TYPE_LOGIN;
474 mapPlayers[unusedId] = *p;
475 }
476
477 delete(p);
478
479 break;
480 }
481 case MSG_TYPE_LOGOUT:
482 {
483 string name(clientMsg.buffer);
484 cout << "Player logging out: " << name << endl;
485
486 Player *p = findPlayerByName(mapPlayers, name);
487
488 if (p == NULL)
489 {
490 strcpy(serverMsg.buffer, "That player is not logged in. This is either a bug, or you're trying to hack the server.");
491 cout << "Player not logged in" << endl;
492 }
493 else if ( p->addr.sin_addr.s_addr != from.sin_addr.s_addr ||
494 p->addr.sin_port != from.sin_port )
495 {
496 strcpy(serverMsg.buffer, "That player is logged in using a differemt connection. This is either a bug, or you're trying to hack the server.");
497 cout << "Player logged in using a different connection" << endl;
498 }
499 else
500 {
501 if (p->id < unusedId)
502 unusedId = p->id;
503 mapPlayers.erase(p->id);
504 strcpy(serverMsg.buffer, "You have successfully logged out.");
505 }
506
507 serverMsg.type = MSG_TYPE_LOGOUT;
508
509 break;
510 }
511 case MSG_TYPE_CHAT:
512 {
513 cout << "Got a chat message" << endl;
514
515 Player *p = findPlayerByAddr(mapPlayers, from);
516
517 if (p == NULL)
518 {
519 strcpy(serverMsg.buffer, "No player is logged in using this connection. This is either a bug, or you're trying to hack the server.");
520 }
521 else
522 {
523 broadcastResponse = true;
524
525 ostringstream oss;
526 oss << p->name << ": " << clientMsg.buffer;
527
528 strcpy(serverMsg.buffer, oss.str().c_str());
529 }
530
531 serverMsg.type = MSG_TYPE_CHAT;
532
533 break;
534 }
535 case MSG_TYPE_PLAYER_MOVE:
536 {
537 cout << "PLAYER_MOVE" << endl;
538
539 int id, x, y;
540
541 memcpy(&id, clientMsg.buffer, 4);
542 memcpy(&x, clientMsg.buffer+4, 4);
543 memcpy(&y, clientMsg.buffer+8, 4);
544
545 cout << "x: " << x << endl;
546 cout << "y: " << y << endl;
547 cout << "id: " << id << endl;
548
549 if ( mapPlayers[id].addr.sin_addr.s_addr == from.sin_addr.s_addr &&
550 mapPlayers[id].addr.sin_port == from.sin_port )
551 {
552 // we need to make sure the player can move here
553 if (0 <= x && x < 300 && 0 <= y && y < 300 &&
554 gameMap->getElement(x/25, y/25) == WorldMap::TERRAIN_GRASS)
555 {
556 cout << "valid terrain" << endl;
557
558 mapPlayers[id].target.x = x;
559 mapPlayers[id].target.y = y;
560
561 serverMsg.type = MSG_TYPE_PLAYER_MOVE;
562
563 memcpy(serverMsg.buffer, &id, 4);
564 memcpy(serverMsg.buffer+4, &mapPlayers[id].target.x, 4);
565 memcpy(serverMsg.buffer+8, &mapPlayers[id].target.y, 4);
566
567 broadcastResponse = true;
568 }
569 else
570 cout << "Bad terrain detected" << endl;
571 }
572 else // nned to send back a message indicating failure
573 cout << "Player id (" << id << ") doesn't match sender" << endl;
574
575 break;
576 }
577 case MSG_TYPE_PICKUP_FLAG:
578 {
579 // may want to check the id matches the sender, just like for PLAYER_NOVE
580 cout << "PICKUP_FLAG" << endl;
581
582 int id;
583
584 memcpy(&id, clientMsg.buffer, 4);
585 cout << "id: " << id << endl;
586
587 vector<WorldMap::Object>* vctObjects = gameMap->getObjects();
588 vector<WorldMap::Object>::iterator itObjects;
589
590 for (itObjects = vctObjects->begin(); itObjects != vctObjects->end();) {
591 POSITION pos = itObjects->pos;
592 bool gotFlag = false;
593
594 if (posDistance(mapPlayers[id].pos, pos.toFloat()) < 10) {
595 switch (itObjects->type) {
596 case WorldMap::OBJECT_BLUE_FLAG:
597 if (mapPlayers[id].team == 1) {
598 gotFlag = true;
599 mapPlayers[id].hasBlueFlag = true;
600 broadcastResponse = true;
601 }
602 break;
603 case WorldMap::OBJECT_RED_FLAG:
604 if (mapPlayers[id].team == 0) {
605 gotFlag = true;
606 mapPlayers[id].hasRedFlag = true;
607 broadcastResponse = true;
608 }
609 break;
610 }
611
612 if (gotFlag) {
613 serverMsg.type = MSG_TYPE_REMOVE_OBJECT;
614 memcpy(serverMsg.buffer, &itObjects->id, 4);
615
616 map<unsigned int, Player>::iterator it;
617 for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
618 {
619 if ( sendMessage(&serverMsg, sock, &(it->second.addr)) < 0 )
620 error("sendMessage");
621 }
622
623 // remove the object from the server-side map
624 cout << "size before: " << gameMap->getObjects()->size() << endl;
625 itObjects = vctObjects->erase(itObjects);
626 cout << "size after: " << gameMap->getObjects()->size() << endl;
627 }
628 }
629
630 if (!gotFlag)
631 itObjects++;
632 }
633
634 serverMsg.type = MSG_TYPE_PLAYER;
635 mapPlayers[id].serialize(serverMsg.buffer);
636
637 break;
638 }
639 case MSG_TYPE_DROP_FLAG:
640 {
641 // may want to check the id matches the sender, just like for PLAYER_NOVE
642 cout << "DROP_FLAG" << endl;
643
644 int id;
645
646 memcpy(&id, clientMsg.buffer, 4);
647 cout << "id: " << id << endl;
648
649 WorldMap::ObjectType flagType = WorldMap::OBJECT_NONE;
650 if (mapPlayers[id].hasBlueFlag)
651 flagType = WorldMap::OBJECT_BLUE_FLAG;
652 else if (mapPlayers[id].hasRedFlag)
653 flagType = WorldMap::OBJECT_RED_FLAG;
654
655 gameMap->addObject(flagType, mapPlayers[id].pos.x, mapPlayers[id].pos.y);
656
657 // need to send the OBJECT message too
658 serverMsg.type = MSG_TYPE_OBJECT;
659 gameMap->getObjects()->back().serialize(serverMsg.buffer);
660
661 map<unsigned int, Player>::iterator it;
662 for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
663 {
664 if ( sendMessage(&serverMsg, sock, &(it->second.addr)) < 0 )
665 error("sendMessage");
666 }
667
668 mapPlayers[id].hasBlueFlag = false;
669 mapPlayers[id].hasRedFlag = false;
670
671 serverMsg.type = MSG_TYPE_PLAYER;
672 mapPlayers[id].serialize(serverMsg.buffer);
673
674 map<unsigned int, Player>::iterator it2;
675 broadcastResponse = true;
676
677 break;
678 }
679 case MSG_TYPE_START_ATTACK:
680 {
681 cout << "Received a START_ATTACK message" << endl;
682
683 int id, targetId;
684
685 memcpy(&id, clientMsg.buffer, 4);
686 memcpy(&targetId, clientMsg.buffer+4, 4);
687
688 serverMsg.type = MSG_TYPE_START_ATTACK;
689 broadcastResponse = true;
690
691 break;
692 }
693 case MSG_TYPE_ATTACK:
694 {
695 cout << "Received am ATTACK message" << endl;
696
697 int id, targetId;
698
699 memcpy(&id, clientMsg.buffer, 4);
700 memcpy(&targetId, clientMsg.buffer+4, 4);
701
702 serverMsg.type = MSG_TYPE_ATTACK;
703 broadcastResponse = true;
704
705 break;
706 }
707 default:
708 {
709 strcpy(serverMsg.buffer, "Server error occured. Report this please.");
710
711 serverMsg.type = MSG_TYPE_CHAT;
712
713 break;
714 }
715 }
716
717 return broadcastResponse;
718}
719
720void updateUnusedId(unsigned int& id, map<unsigned int, Player>& mapPlayers)
721{
722 while (mapPlayers.find(id) != mapPlayers.end())
723 id++;
724}
Note: See TracBrowser for help on using the repository browser.