Changes in / [384b7e0:093c141] in network-game


Ignore:
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • common/Common.h

    r384b7e0 r093c141  
    2020} POSITION;
    2121
     22typedef struct
     23{
     24   float x;
     25   float y;
     26} FLOAT_POSITION;
     27
    2228#endif

  • common/Player.cpp

    r384b7e0 r093c141  
    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;
    1617}
    1718
    … …  
    2324   this->pos.x = p.pos.x;
    2425   this->pos.y = p.pos.y;
     26   this->target.x = p.target.x;
     27   this->target.y = p.target.y;
    2528   this->addr = p.addr;
    2629}
    … …  
    3134   this->name = name;
    3235   this->password = password;
    33    this->pos.x = 200;
    34    this->pos.y = 200;
     36   this->pos.x = this->target.x = 200;
     37   this->pos.y = this->target.y = 200;
    3538}
    3639
    … …  
    4043   this->name = name;
    4144   this->password = "";
    42    this->pos.x = 200;
    43    this->pos.y = 200;
     45   this->pos.x = this->target.x = 200;
     46   this->pos.y = this->target.y = 200;
    4447   this->addr = addr;
    4548}
    … …  
    7982   this->addr = addr;
    8083}
     84
     85void Player::move(void) {
     86   // timeLastMoved
     87   // pos
     88   // target
     89   int speed = 100; // pixels per second
     90
     91   timespec curTS, diffTS;
     92   clock_gettime(CLOCK_REALTIME, &curTS);
     93
     94   // get time elapsed
     95   diffTS.tv_sec = curTS.tv_sec - timeLastUpdated.tv_sec;
     96   diffTS.tv_nsec = curTS.tv_nsec - timeLastUpdated.tv_nsec;
     97   if (diffTS.tv_nsec < 0) {
     98      diffTS.tv_sec -= 1;
     99      diffTS.tv_nsec += 1000000000;
     100   }
     101
     102   cout << "elapsed secs: " << diffTS.tv_sec << endl;
     103   cout << "elapsed nsecs: " << diffTS.tv_nsec << endl;
     104
     105   // here we move 100 pixels per second
     106   float pixels = 100 * (diffTS.tv_sec+diffTS.tv_nsec/1000000000.0);
     107   cout << "We need to move " << pixels << "pixels" << endl;
     108
     109   double angle = atan2(target.y-pos.y, target.x-pos.x);
     110
     111   // we just need to check that we don't overjump the target
     112   pos.x += cos(angle)*pixels;
     113   pos.y += sin(angle)*pixels;
     114
     115   timeLastUpdated.tv_sec = curTS.tv_sec;
     116   timeLastUpdated.tv_nsec = curTS.tv_nsec;
     117}

  • common/Player.h

    r384b7e0 r093c141  
    1212
    1313#include <string>
     14#include <sys/time.h>
    1415
    1516#include "Common.h"
    … …  
    3233   void setAddr(sockaddr_in addr);
    3334
     35   void move();
     36
    3437   int id;
    3538   string name;
    3639   string password;
    3740   sockaddr_in addr;
    38    POSITION pos;
     41   FLOAT_POSITION pos;
     42   POSITION target;
     43   timespec timeLastUpdated;
    3944};
    4045

  • server/DataAccess.cpp

    r384b7e0 r093c141  
    8181   }
    8282
    83    if ( ( row = mysql_fetch_row(result)) != NULL )
     83   if ( ( row = mysql_fetch_row(result)) != NULL ) {
     84      cout << "Creating a new player" << endl;
    8485      p = new Player(string(row[1]), string(row[2]));
    85    else {
     86   }else {
    8687      cout << "Returned no results for some reason" << endl;
    8788      p = NULL;

  • server/makefile

    r384b7e0 r093c141  
    11CC = g++
    2 LIB_FLAGS = -lssl -lmysqlclient -lcrypt
     2LIB_FLAGS = -lssl -lmysqlclient -lcrypt -lrt
    33FLAGS = $(LIB_FLAGS)
    44COMMON_PATH = ../common
    5 DEPENDENCIES = Common.o Message.o Player.o Map.o DataAccess.o
     5DEPENDENCIES = Common.o Message.o Player.o WorldMap.o DataAccess.o
    66
    77server : server.cpp $(DEPENDENCIES)
    … …  
    1717        $(CC) -c -o $@ $?
    1818
    19 Map.o : $(COMMON_PATH)/Map.cpp
     19WorldMap.o : $(COMMON_PATH)/WorldMap.cpp
    2020        $(CC) -c -o $@ $?
    2121

  • server/server.cpp

    r384b7e0 r093c141  
    66#include <sstream>
    77#include <cstring>
     8#include <cmath>
     9#include <sys/time.h>
    810
    911#include <vector>
    … …  
    2628#include "../common/Common.h"
    2729#include "../common/Message.h"
     30#include "../common/WorldMap.h"
    2831#include "../common/Player.h"
    2932
    … …  
    3235using namespace std;
    3336
    34 bool processMessage(const NETWORK_MSG &clientMsg, const struct sockaddr_in &from, map<unsigned int, Player>& mapPlayers, unsigned int& unusedId, NETWORK_MSG &serverMsg);
     37bool processMessage(const NETWORK_MSG &clientMsg, const struct sockaddr_in &from, map<unsigned int, Player>& mapPlayers, WorldMap* gameMap, unsigned int& unusedId, NETWORK_MSG &serverMsg);
    3538
    3639void updateUnusedId(unsigned int& id, map<unsigned int, Player>& mapPlayers);
    … …  
    106109      exit(1);
    107110   }
     111
     112   WorldMap* gameMap = WorldMap::createDefaultMap();
    108113 
    109114   sock = socket(AF_INET, SOCK_DGRAM, 0);
    … …  
    119124   set_nonblock(sock);
    120125
     126   Player testP;
     127   clock_gettime(CLOCK_REALTIME, &testP.timeLastUpdated);
     128
     129   cout << "Before sleep" << endl;
     130   // wait some time
     131   sleep(3);
     132   cout << "After sleep" << endl;
     133
     134   testP.move();
     135
     136/*
    121137   bool broadcastResponse;
    122138   while (true) {
    … …  
    129145         cout << "Got a message" << endl;
    130146
    131          broadcastResponse = processMessage(clientMsg, from, mapPlayers, unusedId, serverMsg);
     147         broadcastResponse = processMessage(clientMsg, from, mapPlayers, gameMap, unusedId, serverMsg);
    132148
    133149         // probably replace this with a function that prints based on the
    … …  
    158174      }
    159175   }
     176*/
    160177
    161178   return 0;
    162179}
    163180
    164 bool processMessage(const NETWORK_MSG& clientMsg, const struct sockaddr_in& from, map<unsigned int, Player>& mapPlayers, unsigned int& unusedId, NETWORK_MSG& serverMsg)
     181bool processMessage(const NETWORK_MSG& clientMsg, const struct sockaddr_in& from, map<unsigned int, Player>& mapPlayers, WorldMap* gameMap, unsigned int& unusedId, NETWORK_MSG& serverMsg)
    165182{
    166183   DataAccess da;
    … …  
    199216      case MSG_TYPE_LOGIN:
    200217      {
     218         cout << "Got login message" << endl;
     219
    201220         string username(clientMsg.buffer);
    202221         string password(strchr(clientMsg.buffer, '\0')+1);
    … …  
    287306      case MSG_TYPE_PLAYER_MOVE:
    288307      {
     308         cout << "Got a move message" << endl;
     309
    289310         istringstream iss;
    290311         iss.str(clientMsg.buffer);
    … …  
    305326              mapPlayers[id].addr.sin_port == from.sin_port )
    306327         {
    307             memcpy(&mapPlayers[id].pos.x, clientMsg.buffer+4, 4);
    308             memcpy(&mapPlayers[id].pos.y, clientMsg.buffer+8, 4);
    309 
    310             serverMsg.type = MSG_TYPE_PLAYER_MOVE;
    311             memcpy(serverMsg.buffer, clientMsg.buffer, 12);
    312 
    313             broadcastResponse = true;
     328            // we need to make sure the player can move here
     329            if (0 <= x && x < 300 && 0 <= y && y < 300 &&
     330               gameMap->getElement(x/25, y/25) == WorldMap::TERRAIN_GRASS)
     331            {
     332               // first we get the correct vector
     333               mapPlayers[id].target.x = x;
     334               mapPlayers[id].target.y = y;
     335               int xDiff = mapPlayers[id].target.x - mapPlayers[id].pos.x;
     336               int yDiff = mapPlayers[id].target.y - mapPlayers[id].pos.y;
     337               cout << "xDiff: " << xDiff << endl;               
     338               cout << "yDiff: " << yDiff << endl;               
     339
     340               // then we get the correct angle
     341               double angle = atan2(yDiff, xDiff);
     342               cout << "angle: " << angle << endl;               
     343
     344               // finally we use the angle to determine
     345               // how much the player moves
     346               // the player will move 50 pixels in the correct direction
     347               mapPlayers[id].pos.x += cos(angle)*50;
     348               mapPlayers[id].pos.y += sin(angle)*50;
     349               cout << "new x: " << mapPlayers[id].pos.x << endl;               
     350               cout << "new y: " << mapPlayers[id].pos.y << endl;               
     351
     352               serverMsg.type = MSG_TYPE_PLAYER_MOVE;
     353               
     354               memcpy(serverMsg.buffer, &id, 4);
     355               memcpy(serverMsg.buffer+4, &mapPlayers[id].pos.x, 4);
     356               memcpy(serverMsg.buffer+8, &mapPlayers[id].pos.y, 4);
     357               //memcpy(serverMsg.buffer, clientMsg.buffer, 12);
     358
     359               broadcastResponse = true;
     360            }
     361            else
     362               cout << "Bad terrain detected" << endl;
    314363         }
    315364         else  // nned to send back a message indicating failure
    … …  
    328377   }
    329378
     379   cout << "Got to the end of the switch" << endl;
     380
    330381   return broadcastResponse;
    331382}
Note: See TracChangeset for help on using the changeset viewer.