Changes in / [3a79253:ca44f82] in network-game


Ignore:
Files:
3 added
4 deleted
15 edited

Legend:

Unmodified
Added
Removed

  • client/Client/Client.vcxproj

    r3a79253 rca44f82  
    4747      <GenerateDebugInformation>true</GenerateDebugInformation>
    4848      <AdditionalLibraryDirectories>c:\allegro\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
    49       <AdditionalDependencies>allegro-5.0.7-monolith-md-debug.lib;%(AdditionalDependencies)</AdditionalDependencies>
     49      <AdditionalDependencies>allegro-5.0.8-monolith-md-debug.lib;%(AdditionalDependencies)</AdditionalDependencies>
    5050    </Link>
    5151  </ItemDefinitionGroup>
    … …  
    6565  <ItemGroup>
    6666    <ClCompile Include="..\..\common\Common.cpp" />
     67    <ClCompile Include="..\..\common\WorldMap.cpp" />
    6768    <ClCompile Include="..\..\common\Message.cpp" />
    6869    <ClCompile Include="..\..\common\Player.cpp" />
    … …  
    7778    <ClInclude Include="..\..\common\Common.h" />
    7879    <ClInclude Include="..\..\common\Compiler.h" />
     80    <ClInclude Include="..\..\common\WorldMap.h" />
    7981    <ClInclude Include="..\..\common\Message.h" />
    8082    <ClInclude Include="..\..\common\Player.h" />

  • client/Client/Client.vcxproj.filters

    r3a79253 rca44f82  
    5555      <Filter>Source Files\common</Filter>
    5656    </ClCompile>
     57    <ClCompile Include="..\..\common\WorldMap.cpp">
     58      <Filter>Source Files\common</Filter>
     59    </ClCompile>
    5760  </ItemGroup>
    5861  <ItemGroup>
    … …  
    8487      <Filter>Header Files\common</Filter>
    8588    </ClInclude>
     89    <ClInclude Include="..\..\common\WorldMap.h">
     90      <Filter>Header Files\common</Filter>
     91    </ClInclude>
    8692  </ItemGroup>
    8793  <ItemGroup>

  • client/Client/main.cpp

    r3a79253 rca44f82  
    1414
    1515#include <sys/types.h>
    16 #include <stdio.h>
    17 #include <stdlib.h>
     16#include <cstdio>
     17#include <cstdlib>
    1818#include <string>
    1919#include <iostream>
     20#include <sstream>
     21
     22#include <map>
    2023
    2124#include <map>
    … …  
    2427#include <allegro5/allegro_font.h>
    2528#include <allegro5/allegro_ttf.h>
     29#include <allegro5/allegro_primitives.h>
    2630
    2731#include "../../common/Message.h"
    2832#include "../../common/Common.h"
     33#include "../../common/WorldMap.h"
    2934#include "../../common/Player.h"
    3035
    … …  
    4247void initWinSock();
    4348void shutdownWinSock();
    44 void processMessage(NETWORK_MSG &msg, int &state, chat &chatConsole);
     49void processMessage(NETWORK_MSG &msg, int &state, chat &chatConsole, map<unsigned int, Player>& mapPlayers, unsigned int& curPlayerId);
     50void drawMap(WorldMap* gameMap);
     51void drawPlayers(map<unsigned int, Player>& mapPlayers, unsigned int curPlayerId);
     52POSITION screenToMap(POSITION pos);
     53POSITION mapToScreen(POSITION pos);
    4554
    4655// callbacks
    … …  
    99108   bool redraw = true;
    100109   doexit = false;
     110   map<unsigned int, Player> mapPlayers;
     111   unsigned int curPlayerId = -1;
    101112
    102113   float bouncer_x = SCREEN_W / 2.0 - BOUNCER_SIZE / 2.0;
    … …  
    110121   }
    111122
    112    al_init_primitives_addon();
     123   if (al_init_primitives_addon())
     124      cout << "Primitives initialized" << endl;
     125   else
     126      cout << "Primitives not initialized" << endl;
     127
    113128   al_init_font_addon();
    114129   al_init_ttf_addon();
    115130
    116    ALLEGRO_FONT *font = al_load_ttf_font("../pirulen.ttf", 12, 0);
    117  
     131   #if defined WINDOWS
     132      ALLEGRO_FONT *font = al_load_ttf_font("../pirulen.ttf", 12, 0);
     133   #elif defined LINUX
     134      ALLEGRO_FONT *font = al_load_ttf_font("pirulen.ttf", 12, 0);
     135   #endif
     136
    118137   if (!font) {
    119138      fprintf(stderr, "Could not load 'pirulen.ttf'.\n");
    … …  
    144163      return -1;
    145164   }
     165
     166   WorldMap* gameMap = WorldMap::loadMapFromFile("../../data/map.txt");
     167   //delete gameMap;
     168   //gameMap = WorldMap::createDefaultMap();
    146169
    147170   wndLogin = new Window(0, 0, SCREEN_W, SCREEN_H);
    … …  
    291314         }
    292315      }
     316      else if(ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_UP) {
     317         if(wndCurrent == wndMain) {
     318            msgTo.type = MSG_TYPE_PLAYER_MOVE;
     319
     320            POSITION pos;
     321            pos.x = ev.mouse.x;
     322            pos.y = ev.mouse.y;
     323            pos = screenToMap(pos);
     324
     325            if (pos.x != -1)
     326            {
     327               memcpy(msgTo.buffer, &curPlayerId, 4);
     328               memcpy(msgTo.buffer+4, &pos.x, 4);
     329               memcpy(msgTo.buffer+8, &pos.y, 4);
     330
     331               sendMessage(&msgTo, sock, &server);
     332            }
     333            else
     334               cout << "Invalid point: User did not click on the map" << endl;
     335         }
     336      }
    293337
    294338      if (receiveMessage(&msgFrom, sock, &from) >= 0)
    295339      {
    296          processMessage(msgFrom, state, chatConsole);
     340         processMessage(msgFrom, state, chatConsole, mapPlayers, curPlayerId);
    297341         cout << "state: " << state << endl;
    298342      }
    … …  
    301345      {
    302346         redraw = false;
    303  
     347
    304348         wndCurrent->draw(display);
    305  
    306          al_draw_bitmap(bouncer, bouncer_x, bouncer_y, 0);
    307349
    308350         chatConsole.draw(font, al_map_rgb(255,255,255));
    … …  
    314356         else if(wndCurrent == wndMain) {
    315357            al_draw_text(font, al_map_rgb(0, 255, 0), 4, 43, ALLEGRO_ALIGN_LEFT, "Message:");
     358
     359            drawMap(gameMap);
     360            drawPlayers(mapPlayers, curPlayerId);
    316361         }
    317362
    … …  
    330375   delete wndLogin;
    331376   delete wndMain;
     377
     378   delete gameMap;
    332379
    333380   al_destroy_event_queue(event_queue);
    … …  
    372419}
    373420
    374 void processMessage(NETWORK_MSG &msg, int &state, chat &chatConsole)
     421POSITION screenToMap(POSITION pos)
     422{
     423   pos.x = pos.x-300;
     424   pos.y = pos.y-100;
     425
     426   if (pos.x < 0 || pos.y < 0)
     427   {
     428      pos.x = -1;
     429      pos.y = -1;
     430   }
     431
     432   return pos;
     433}
     434
     435POSITION mapToScreen(POSITION pos)
     436{
     437   pos.x = pos.x+300;
     438   pos.y = pos.y+100;
     439
     440   return pos;
     441}
     442
     443POSITION mapToScreen(FLOAT_POSITION pos)
     444{
     445   POSITION p;
     446   p.x = pos.x+300;
     447   p.y = pos.y+100;
     448
     449   return p;
     450}
     451
     452void processMessage(NETWORK_MSG &msg, int &state, chat &chatConsole, map<unsigned int, Player>& mapPlayers, unsigned int& curPlayerId)
    375453{
    376454   string response = string(msg.buffer);
    … …  
    383461      {
    384462         cout << "In STATE_START" << endl;
    385 
    386          chatConsole.addLine(response);
    387463
    388464         switch(msg.type)
    … …  
    408484                  state = STATE_LOGIN;
    409485                  wndCurrent = wndMain;
    410                   cout << "User login successful" << endl;
     486                 
     487                  Player p("", "");
     488                  p.deserialize(msg.buffer);
     489                  mapPlayers[p.id] = p;
     490                  curPlayerId = p.id;
     491
     492                  cout << "Got a valid login response with the player" << endl;
     493                  cout << "Player id: " << curPlayerId << endl;
    411494               }
     495
    412496               break;
    413497            }
    … …  
    418502      case STATE_LOGIN:
    419503      {
    420          chatConsole.addLine(response);
    421 
    422           switch(msg.type)
     504         switch(msg.type)
    423505         {
    424506            case MSG_TYPE_REGISTER:
    … …  
    428510            case MSG_TYPE_LOGIN:
    429511            {
     512               chatConsole.addLine(response);
     513
    430514               if (response.compare("You have successfully logged out.") == 0)
    431515               {
    … …  
    448532
    449533               cout << "p.id: " << p.id << endl;
    450                cout << "p.name: " << p.name << endl;
    451                cout << "p.pos.x: " << p.pos.x << endl;
    452                cout << "p.pos.y: " << p.pos.y << endl;
    453534
    454535               break;
    455536            }
    456          }
    457                      
     537            case MSG_TYPE_CHAT:
     538            {
     539               chatConsole.addLine(response);
     540
     541               break;
     542            }
     543         }
     544
    458545         break;
    459546      }
    … …  
    467554}
    468555
     556void drawMap(WorldMap* gameMap)
     557{
     558   POSITION mapPos;
     559   mapPos.x = 0;
     560   mapPos.y = 0;
     561   mapPos = mapToScreen(mapPos);
     562   for (int x=0; x<12; x++)
     563   {
     564      for (int y=0; y<12; y++)
     565      {
     566         WorldMap::TerrainType el = gameMap->getElement(x, y);
     567
     568         if (el == WorldMap::TERRAIN_GRASS)
     569            al_draw_filled_rectangle(x*25+mapPos.x, y*25+mapPos.y, x*25+25+mapPos.x, y*25+25+mapPos.y, al_map_rgb(0, 255, 0));
     570         else if (el == WorldMap::TERRAIN_OCEAN)
     571            al_draw_filled_rectangle(x*25+mapPos.x, y*25+mapPos.y, x*25+25+mapPos.x, y*25+25+mapPos.y, al_map_rgb(0, 0, 255));
     572         else if (el == WorldMap::TERRAIN_ROCK)
     573            al_draw_filled_rectangle(x*25+mapPos.x, y*25+mapPos.y, x*25+25+mapPos.x, y*25+25+mapPos.y, al_map_rgb(100, 100, 0));
     574      }
     575   }
     576}
     577
     578void drawPlayers(map<unsigned int, Player>& mapPlayers, unsigned int curPlayerId)
     579{
     580   map<unsigned int, Player>::iterator it;
     581
     582   Player* p;
     583   POSITION pos;
     584
     585   for(it = mapPlayers.begin(); it != mapPlayers.end(); it++)
     586   {
     587      p = &it->second;
     588      pos = mapToScreen(p->pos);
     589
     590      if (p->id == curPlayerId)
     591         al_draw_filled_circle(pos.x, pos.y, 12, al_map_rgb(255, 0, 0));
     592      else
     593         al_draw_filled_circle(pos.x, pos.y, 12, al_map_rgb(191, 0, 0));
     594   }
     595}
     596
    469597void registerAccount()
    470598{

  • client/makefile

    r3a79253 rca44f82  
    33FLAGS = $(LIB_FLAGS)
    44COMMON_PATH = ../common
    5 DEPENDENCIES = Message.o Player.o chat.o GuiComponent.o Window.o Textbox.o Button.o
     5DEPENDENCIES = Common.o Message.o Player.o chat.o GuiComponent.o Window.o Textbox.o Button.o
    66
    77gameClient : Client/main.cpp $(DEPENDENCIES)
    88        $(CC) -o $@ $+ $(FLAGS)
     9
     10Common.o : $(COMMON_PATH)/Common.cpp
     11        $(CC) -c -o $@ $? $(FLAGS)
    912
    1013Message.o : $(COMMON_PATH)/Message.cpp

  • common/Common.cpp

    r3a79253 rca44f82  
    11#include "Common.h"
     2
     3#include <iostream>
     4using namespace std;
     5
     6#if defined WINDOWS
     7   #include <Windows.h>
     8#elif defined LINUX
     9   #include <time.h>
     10#endif
    211
    312void set_nonblock(int sock)
    … …  
    1322   #endif
    1423}
     24
     25unsigned long long getCurrentMillis()
     26{
     27   unsigned long long numMilliseconds;
     28
     29   #if defined WINDOWS
     30      numMilliseconds = GetTickCount();
     31   #elif defined LINUX
     32      timespec curTime;
     33      clock_gettime(CLOCK_REALTIME, &curTime);
     34
     35      numMilliseconds = curTime.tv_sec*(unsigned long long)1000+curTime.tv_nsec/(unsigned long long)1000000;
     36   #endif
     37
     38   return numMilliseconds;
     39}

  • common/Common.h

    r3a79253 rca44f82  
    1313
    1414void set_nonblock(int sock);
     15unsigned long long getCurrentMillis();
    1516
    1617typedef struct
    … …  
    1819   int x;
    1920   int y;
    20 } PLAYER_POS;
     21} POSITION;
     22
     23typedef struct
     24{
     25   float x;
     26   float y;
     27} FLOAT_POSITION;
    2128
    2229#endif

  • common/Message.cpp

    r3a79253 rca44f82  
    1111#endif
    1212
     13#include <iostream>
     14
     15using namespace std;
     16
    1317int sendMessage(NETWORK_MSG *msg, int sock, struct sockaddr_in *dest)
    1418{
    15    return sendto(sock, (char*)msg, sizeof(NETWORK_MSG), 0, (struct sockaddr *)dest, sizeof(struct sockaddr_in));
     19   int ret =  sendto(sock, (char*)msg, sizeof(NETWORK_MSG), 0, (struct sockaddr *)dest, sizeof(struct sockaddr_in));
     20
     21   cout << "Sent message of type " << msg->type << endl;
     22
     23   return ret;
    1624}
    1725
    … …  
    2129
    2230   // assume we don't care about the value of socklen
    23    return recvfrom(sock, (char*)msg, sizeof(NETWORK_MSG), 0, (struct sockaddr *)dest, &socklen);
     31   int ret =  recvfrom(sock, (char*)msg, sizeof(NETWORK_MSG), 0, (struct sockaddr *)dest, &socklen);
     32
     33   if (ret > -1)
     34      cout << "Received message of type " << msg->type << endl;
     35
     36   return ret;
    2437}

  • common/Message.h

    r3a79253 rca44f82  
    66#define MSG_TYPE_LOGOUT       3
    77#define MSG_TYPE_CHAT         4
    8 #define MSG_TYPE_PLAYER       5
     8#define MSG_TYPE_PLAYER       5  // server sends this to update player positions
     9#define MSG_TYPE_PLAYER_MOVE  6  // client sends this when a player wants to move
    910
    1011typedef struct

  • common/Player.cpp

    r3a79253 rca44f82  
    44#include <sstream>
    55#include <cstring>
     6#include <cmath>
    67
    78using namespace std;
    … …  
    1213   this->name = "";
    1314   this->password = "";
    14    this->pos.x = 0;
    15    this->pos.y = 0;
     15   this->pos.x = this->target.x = 0;
     16   this->pos.y = this->target.y = 0;
     17   this->timeLastUpdated = 0;
    1618}
    1719
    … …  
    2325   this->pos.x = p.pos.x;
    2426   this->pos.y = p.pos.y;
     27   this->target.x = p.target.x;
     28   this->target.y = p.target.y;
    2529   this->addr = p.addr;
    2630}
    … …  
    3135   this->name = name;
    3236   this->password = password;
    33    this->pos.x = 200;
    34    this->pos.y = 200;
     37   this->pos.x = this->target.x = 200;
     38   this->pos.y = this->target.y = 200;
    3539}
    3640
    … …  
    4044   this->name = name;
    4145   this->password = "";
    42    this->pos.x = 200;
    43    this->pos.y = 200;
     46   this->pos.x = this->target.x = 200;
     47   this->pos.y = this->target.y = 200;
    4448   this->addr = addr;
    4549}
    … …  
    5155void Player::serialize(char* buffer)
    5256{
    53    ostringstream oss;
    54 
    55    oss.write((char*)&(this->id), sizeof(int));
    56    oss << this->name;
    57    oss.write("\0", 1);
    58    oss.write((char*)&(this->pos.x), sizeof(int));
    59    oss.write((char*)&(this->pos.y), sizeof(int));
    60 
    61    memcpy(buffer, oss.str().c_str(), this->name.length()+1+2*sizeof(int));
     57   memcpy(buffer, &this->id, 4);
     58   memcpy(buffer+4, &this->pos.x, 4);
     59   memcpy(buffer+8, &this->pos.y, 4);
     60   memcpy(buffer+12, &this->target.x, 4);
     61   memcpy(buffer+16, &this->target.y, 4);
     62   strcpy(buffer+20, this->name.c_str());
    6263}
    6364
    6465void Player::deserialize(char* buffer)
    6566{
    66    istringstream iss;
    67    iss.str(buffer);
     67   memcpy(&this->id, buffer, 4);
     68   memcpy(&this->pos.x, buffer+4, 4);
     69   memcpy(&this->pos.y, buffer+8, 4);
     70   memcpy(&this->target.x, buffer+12, 4);
     71   memcpy(&this->target.y, buffer+16, 4);
     72   this->name.assign(buffer+20);
    6873
    69    iss.read((char*)&(this->id), sizeof(int));
    70    iss >> this->name;
    71    iss.read((char*)&(this->pos.x), sizeof(int));
    72    iss.read((char*)&(this->pos.y), sizeof(int));
     74   cout << "id: " << this->id << endl;
     75   cout << "pos x: " << this->pos.x << endl;
     76   cout << "pos y: " << this->pos.y << endl;
     77   cout << "target x: " << this->target.x << endl;
     78   cout << "target y: " << this->target.y << endl;
     79   cout << "name: " << this->name << endl;
    7380}
    7481
    … …  
    8289   this->addr = addr;
    8390}
     91
     92void Player::move(void) {
     93   int speed = 100; // pixels per second
     94   unsigned long long curTime = getCurrentMillis();
     95
     96   // if we're at our target, don't move
     97   if (pos.x == target.x && pos.y == target.y)
     98      cout << "We're already at our target" << endl;
     99   else {
     100      float pixels = speed * (curTime-timeLastUpdated) / 1000.0;
     101      cout << "We need to move " << pixels << " pixels" << endl;
     102
     103      double angle = atan2(target.y-pos.y, target.x-pos.x);
     104
     105      float dist = sqrt(pow(target.x-pos.x, 2) + pow(target.y-pos.y, 2));
     106      if (dist <= pixels) {
     107         pos.x = target.x;
     108         pos.y = target.y;
     109      }else {
     110         pos.x += cos(angle)*pixels;
     111         pos.y += sin(angle)*pixels;
     112      }
     113   }
     114
     115   timeLastUpdated = curTime;
     116}

  • common/Player.h

    r3a79253 rca44f82  
    3232   void setAddr(sockaddr_in addr);
    3333
     34   void move();
     35
    3436   int id;
    3537   string name;
    3638   string password;
    3739   sockaddr_in addr;
    38    PLAYER_POS pos;
     40   FLOAT_POSITION pos;
     41   POSITION target;
     42   unsigned long long timeLastUpdated;
    3943};
    4044

  • readme.txt

    r3a79253 rca44f82  
     1This info is outdated. The latest info is on the github wiki.
     2
    13BoostPro Installer options
    24

  • server/DataAccess.cpp

    r3a79253 rca44f82  
    33#include <iostream>
    44#include <sstream>
     5#include <cstdlib>
    56
    67using namespace std;
    … …  
    2728   ostringstream oss;
    2829
    29    oss << "'" << username << "', '" << password << "'";
     30   string salt = "$1$";
     31   int random;
     32   char chr;
     33   for(int i=0; i<8; i++)
     34   {
     35      random = rand() % 62;
     36      if (random < 26)
     37         chr = (char)('a'+random);
     38      else if (random < 52)
     39         chr = (char)('A'+random-26);
     40      else
     41         chr = (char)('0'+random-52);
     42      salt += chr;
     43   }
     44   salt += '$';
     45
     46   string encrypted(crypt(password.c_str(), salt.c_str()));
     47
     48   oss << "'" << username << "', '" << encrypted << "'";
    3049
    3150   return insert("users", "name, password", oss.str());
     51}
     52
     53int DataAccess::updatePlayer(string username, string password)
     54{
     55   ostringstream values, where;
     56
     57   values << "password='" << password << "'";
     58   
     59   where << "name='" << username << "'";
     60
     61   return update("users", values.str(), where.str());
    3262}
    3363
    … …  
    5181   }
    5282
    53    if ( ( row = mysql_fetch_row(result)) != NULL )
     83   if ( ( row = mysql_fetch_row(result)) != NULL ) {
     84      cout << "Creating a new player" << endl;
    5485      p = new Player(string(row[1]), string(row[2]));
    55    else {
     86   }else {
    5687      cout << "Returned no results for some reason" << endl;
    5788      p = NULL;
    … …  
    6394}
    6495
    65 int DataAccess::printPlayers()
     96// need to make sure this list is freed
     97// since we need to create a DataAccess class
     98// when calling these functions,
     99// we could free this list in the destructor
     100list<Player*>* DataAccess::getPlayers()
    66101{
    67102   MYSQL_RES *result;
    … …  
    73108   if (result == NULL) {
    74109      cout << mysql_error(connection) << endl;
    75       return 1;
     110      return NULL;
    76111   }
    77112
     113   list<Player*>* lstPlayers = new list<Player*>();
    78114   while ( ( row = mysql_fetch_row(result)) != NULL ) {
    79115      cout << row[0] << ", " << row[1] << ", " << row[2] << endl;
     116      lstPlayers->push_back(new Player(row[1], row[2]));
    80117   }
    81118
    82119   mysql_free_result(result);
    83120
    84    return 0;
     121   return lstPlayers;
    85122}
    86123
    87 int DataAccess::insert(string table, string rows, string values)
     124bool DataAccess::verifyPassword(string password, string encrypted)
     125{
     126   string test(crypt(password.c_str(), encrypted.c_str()));
     127
     128   return encrypted.compare(test) == 0;
     129}
     130
     131int DataAccess::insert(string table, string columns, string values)
    88132{
    89133   int query_state;
    90134   ostringstream oss;
    91135
    92    oss << "INSERT into " << table << " (" << rows << ") VALUES (" << values << ")";
     136   oss << "INSERT into " << table << " (" << columns << ") VALUES (" << values << ")";
     137   cout << "query: " << oss.str() << endl;
     138
     139   query_state = mysql_query(connection, oss.str().c_str());
     140
     141   if (query_state != 0) {
     142      cout << mysql_error(connection) << endl;
     143      return 1;
     144   }
     145
     146   return 0;
     147}
     148
     149int DataAccess::update(string table, string values, string where)
     150{
     151   int query_state;
     152   ostringstream oss;
     153
     154   oss << "UPDATE " << table << " SET " << values << " WHERE " << where;
    93155   cout << "query: " << oss.str() << endl;
    94156

  • server/DataAccess.h

    r3a79253 rca44f82  
    33
    44#include <string>
     5#include <list>
    56
    67#include <mysql/mysql.h>
    … …  
    1617
    1718   int insertPlayer(string username, string password);
     19   int updatePlayer(string username, string password);
    1820
    19    Player *getPlayer(string username);
    20    int printPlayers();
     21   Player* getPlayer(string username);
     22   list<Player*>* getPlayers();
     23   bool verifyPassword(string encrypted, string password);
    2124
    2225   int insert(string table, string rows, string values);
     26   int update(string table, string values, string where);
    2327   MYSQL_RES *select(string table, string filter);
    2428

  • server/makefile

    r3a79253 rca44f82  
    11CC = g++
    2 LIB_FLAGS = -lssl -lmysqlclient
     2LIB_FLAGS = -lssl -lmysqlclient -lcrypt -lrt
    33FLAGS = $(LIB_FLAGS)
    44COMMON_PATH = ../common
    5 DEPENDENCIES = Common.o Message.o Player.o DataAccess.o
     5DEPENDENCIES = Common.o Message.o Player.o WorldMap.o DataAccess.o
    66
    77server : server.cpp $(DEPENDENCIES)
    … …  
    1717        $(CC) -c -o $@ $?
    1818
     19WorldMap.o : $(COMMON_PATH)/WorldMap.cpp
     20        $(CC) -c -o $@ $?
     21
    1922%.o : %.cpp
    2023        $(CC) -c -o $@ $?

  • server/server.cpp

    r3a79253 rca44f82  
    66#include <sstream>
    77#include <cstring>
     8#include <cmath>
    89
    910#include <vector>
    … …  
    1415#include <netinet/in.h>
    1516#include <arpa/inet.h>
     17
     18#include <crypt.h>
    1619
    1720/*
    … …  
    2427#include "../common/Common.h"
    2528#include "../common/Message.h"
     29#include "../common/WorldMap.h"
    2630#include "../common/Player.h"
    2731
    … …  
    3034using namespace std;
    3135
    32 bool processMessage(const NETWORK_MSG &clientMsg, const struct sockaddr_in &from, map<unsigned int, Player>& mapPlayers, unsigned int& unusedId, NETWORK_MSG &serverMsg);
    33 
    34 void updateUnusedId(unsigned int& id);
     36bool processMessage(const NETWORK_MSG &clientMsg, const struct sockaddr_in &from, map<unsigned int, Player>& mapPlayers, WorldMap* gameMap, unsigned int& unusedId, NETWORK_MSG &serverMsg);
     37
     38void updateUnusedId(unsigned int& id, map<unsigned int, Player>& mapPlayers);
    3539
    3640// this should probably go somewhere in the common folder
    … …  
    9498   NETWORK_MSG clientMsg, serverMsg;
    9599   map<unsigned int, Player> mapPlayers;
    96    unsigned int unusedId = 0;
     100   unsigned int unusedId = 1;
    97101
    98102   //SSL_load_error_strings();
    … …  
    104108      exit(1);
    105109   }
     110
     111   WorldMap* gameMap = NULL; //WorldMap::createDefaultMap();
    106112 
    107113   sock = socket(AF_INET, SOCK_DGRAM, 0);
    … …  
    127133         cout << "Got a message" << endl;
    128134
    129          broadcastResponse = processMessage(clientMsg, from, mapPlayers, unusedId, serverMsg);
    130 
     135         broadcastResponse = processMessage(clientMsg, from, mapPlayers, gameMap, unusedId, serverMsg);
     136
     137         // probably replace this with a function that prints based on the
     138         // message type
    131139         cout << "msg: " << serverMsg.buffer << endl;
    132 
     140         cout << "broadcastResponse: " << broadcastResponse << endl;
    133141         if (broadcastResponse)
    134142         {
    … …  
    136144
    137145            map<unsigned int, Player>::iterator it;
    138 
    139146            for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
    140147            {
    … …  
    151158         }
    152159
     160         // update player positions
     161         map<unsigned int, Player>::iterator it;
     162         for (it = mapPlayers.begin(); it != mapPlayers.end(); it++)
     163         {
     164            it->second.move();
     165         }
     166
    153167         broadcastPlayerPositions(mapPlayers, sock);
    154168      }
    … …  
    158172}
    159173
    160 bool processMessage(const NETWORK_MSG& clientMsg, const struct sockaddr_in& from, map<unsigned int, Player>& mapPlayers, unsigned int& unusedId, NETWORK_MSG& serverMsg)
     174bool processMessage(const NETWORK_MSG& clientMsg, const struct sockaddr_in& from, map<unsigned int, Player>& mapPlayers, WorldMap* gameMap, unsigned int& unusedId, NETWORK_MSG& serverMsg)
    161175{
    162176   DataAccess da;
    … …  
    195209      case MSG_TYPE_LOGIN:
    196210      {
     211         cout << "Got login message" << endl;
     212
    197213         string username(clientMsg.buffer);
    198214         string password(strchr(clientMsg.buffer, '\0')+1);
    199          cout << "Player logging in: " << username << endl;
    200215
    201216         Player* p = da.getPlayer(username);
    202217
    203          if (p == NULL || p->password != password)
     218         if (p == NULL || !da.verifyPassword(password, p->password))
    204219         {
    205220            strcpy(serverMsg.buffer, "Incorrect username or password");
    … …  
    212227         {
    213228            p->setAddr(from);
     229            updateUnusedId(unusedId, mapPlayers);
    214230            p->id = unusedId;
    215231            mapPlayers[unusedId] = *p;
    216             updateUnusedId(unusedId);
    217 
    218             strcpy(serverMsg.buffer, "Login successful. Enjoy chatting with other players.");
     232
     233            // sendd back the new player info to the user
     234            p->serialize(serverMsg.buffer);
    219235         }
    220236
    … …  
    235251         {
    236252            strcpy(serverMsg.buffer, "That player is not logged in. This is either a bug, or you're trying to hack the server.");
     253            cout << "Player not logged in" << endl;
    237254         }
    238255         else if ( p->addr.sin_addr.s_addr != from.sin_addr.s_addr ||
    … …  
    240257         {
    241258            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.");
     259            cout << "Player logged in using a different connection" << endl;
    242260         }
    243261         else
    … …  
    247265            mapPlayers.erase(p->id);
    248266            strcpy(serverMsg.buffer, "You have successfully logged out.");
    249          }
     267            cout << "Player logged out successfuly" << endl;
     268         }
     269
     270         // should really be serverMsg.type = MSG_TYPE_LOGOUT;
     271         serverMsg.type = MSG_TYPE_LOGIN;
    250272
    251273         break;
    … …  
    265287            broadcastResponse = true;
    266288
    267             stringstream ss;
    268             ss << p->name << ": " << clientMsg.buffer;
    269 
    270             strcpy(serverMsg.buffer, ss.str().c_str());
     289            ostringstream oss;
     290            oss << p->name << ": " << clientMsg.buffer;
     291
     292            strcpy(serverMsg.buffer, oss.str().c_str());
    271293         }     
    272294
    … …  
    275297         break;
    276298      }
     299      case MSG_TYPE_PLAYER_MOVE:
     300      {
     301         cout << "Got a move message" << endl;
     302
     303         istringstream iss;
     304         iss.str(clientMsg.buffer);
     305
     306         cout << "PLAYER_MOVE" << endl;
     307
     308         int id, x, y;
     309
     310         memcpy(&id, clientMsg.buffer, 4);
     311         memcpy(&x, clientMsg.buffer+4, 4);
     312         memcpy(&y, clientMsg.buffer+8, 4);
     313         
     314         cout << "x: " << x << endl;
     315         cout << "y: " << y << endl;
     316         cout << "id: " << id << endl;
     317
     318         if ( mapPlayers[id].addr.sin_addr.s_addr == from.sin_addr.s_addr &&
     319              mapPlayers[id].addr.sin_port == from.sin_port )
     320         {
     321            // we need to make sure the player can move here
     322            if (0 <= x && x < 300 && 0 <= y && y < 300 &&
     323               gameMap->getElement(x/25, y/25) == WorldMap::TERRAIN_GRASS)
     324            {
     325               // first we get the correct vector
     326               mapPlayers[id].target.x = x;
     327               mapPlayers[id].target.y = y;
     328               int xDiff = mapPlayers[id].target.x - mapPlayers[id].pos.x;
     329               int yDiff = mapPlayers[id].target.y - mapPlayers[id].pos.y;
     330               cout << "xDiff: " << xDiff << endl;               
     331               cout << "yDiff: " << yDiff << endl;               
     332
     333               // then we get the correct angle
     334               double angle = atan2(yDiff, xDiff);
     335               cout << "angle: " << angle << endl;               
     336
     337               // finally we use the angle to determine
     338               // how much the player moves
     339               // the player will move 50 pixels in the correct direction
     340               mapPlayers[id].pos.x += cos(angle)*50;
     341               mapPlayers[id].pos.y += sin(angle)*50;
     342               cout << "new x: " << mapPlayers[id].pos.x << endl;               
     343               cout << "new y: " << mapPlayers[id].pos.y << endl;               
     344
     345               serverMsg.type = MSG_TYPE_PLAYER_MOVE;
     346               
     347               memcpy(serverMsg.buffer, &id, 4);
     348               memcpy(serverMsg.buffer+4, &mapPlayers[id].pos.x, 4);
     349               memcpy(serverMsg.buffer+8, &mapPlayers[id].pos.y, 4);
     350               //memcpy(serverMsg.buffer, clientMsg.buffer, 12);
     351
     352               broadcastResponse = true;
     353            }
     354            else
     355               cout << "Bad terrain detected" << endl;
     356         }
     357         else  // nned to send back a message indicating failure
     358            cout << "Player id (" << id << ") doesn't match sender" << endl;
     359
     360         break;
     361      }
    277362      default:
    278363      {
    … …  
    285370   }
    286371
     372   cout << "Got to the end of the switch" << endl;
     373
    287374   return broadcastResponse;
    288375}
    289376
    290 void updateUnusedId(unsigned int& id)
    291 {
    292    id = 5;
    293 }
     377void updateUnusedId(unsigned int& id, map<unsigned int, Player>& mapPlayers)
     378{
     379   while (mapPlayers.find(id) != mapPlayers.end())
     380      id++;
     381}
Note: See TracChangeset for help on using the changeset viewer.