josh/treacherous-terrain
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Multiplayer framework in place (can now connect multiple clients and view them in game)

Browse Source
This commit is contained in:
xethm55 2012-09-24 20:31:51 -04:00
parent 3e178b4d97
commit abd731f3ca
9 changed files with 308 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
src/client/Client-gl.cc
View File

@ -258,17 +258,22 @@ void Client::redraw()
{ {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
double dir_x = cos(m_player->direction); double dir_x = cos((*m_players)[current_player].direction);
double dir_y = sin(m_player->direction); double dir_y = sin((*m_players)[current_player].direction);
m_modelview.load_identity(); m_modelview.load_identity();
m_modelview.look_at( m_modelview.look_at(
m_player->x - dir_x * 25, m_player->y - dir_y * 25, 30, (*m_players)[current_player].x - dir_x * 25, (*m_players)[current_player].y - dir_y * 25, 30,
m_player->x, m_player->y, 20, (*m_players)[current_player].x, (*m_players)[current_player].y, 20,
0, 0, 1); 0, 0, 1);
// TODO: call draw_player() for each networked player // TODO: call draw_player() for each networked player
draw_player(m_player); for(std::map<sf::Uint8, Player>::iterator piter = m_players->begin(); piter != m_players->end(); piter++)
draw_map(); {
draw_player(piter->second);
}
draw_map();
draw_sky(); draw_sky();
draw_lava(); draw_lava();
@ -277,12 +282,12 @@ void Client::redraw()
m_window->display(); m_window->display();
} }
void Client::draw_player(refptr<Player> player) void Client::draw_player(Player player)
{ {
m_obj_program.use(); m_obj_program.use();
m_modelview.push(); m_modelview.push();
m_modelview.translate(player->x, player->y, 4); m_modelview.translate(player.x, player.y, 4);
m_modelview.rotate(player->direction * 180.0 / M_PI, 0, 0, 1); m_modelview.rotate(player.direction * 180.0 / M_PI, 0, 0, 1);
m_modelview.scale(2, 2, 2); m_modelview.scale(2, 2, 2);
m_tank_obj.bindBuffers(); m_tank_obj.bindBuffers();
glEnableVertexAttribArray(0); glEnableVertexAttribArray(0);
@ -398,8 +403,8 @@ void Client::draw_overlay()
proj.ortho(-span, span, -span, span, -1, 1); proj.ortho(-span, span, -span, span, -1, 1);
proj.to_uniform(m_overlay_program.uniform("projection")); proj.to_uniform(m_overlay_program.uniform("projection"));
GLMatrix modelview; GLMatrix modelview;
modelview.rotate(90 - m_player->direction * 180 / M_PI, 0, 0, 1); modelview.rotate(90 - (*m_players)[current_player].direction * 180 / M_PI, 0, 0, 1);
modelview.translate(-m_player->x, -m_player->y, 0); modelview.translate(-(*m_players)[current_player].x, -(*m_players)[current_player].y, 0);
m_overlay_hex_attributes.bind(); m_overlay_hex_attributes.bind();
m_overlay_hex_indices.bind(); m_overlay_hex_indices.bind();
glEnableVertexAttribArray(0); glEnableVertexAttribArray(0);
@ -452,8 +457,8 @@ void Client::draw_sky()
m_sky_attributes.bind(); m_sky_attributes.bind();
m_projection.to_uniform(m_sky_program.uniform("projection")); m_projection.to_uniform(m_sky_program.uniform("projection"));
m_modelview.push(); m_modelview.push();
m_modelview.translate(m_player->x, m_player->y, 0); m_modelview.translate((*m_players)[current_player].x, (*m_players)[current_player].y, 0);
m_modelview.rotate(m_player->direction * 180.0 / M_PI, 0, 0, 1); m_modelview.rotate((*m_players)[current_player].direction * 180.0 / M_PI, 0, 0, 1);
m_modelview.to_uniform(m_sky_program.uniform("modelview")); m_modelview.to_uniform(m_sky_program.uniform("modelview"));
m_modelview.pop(); m_modelview.pop();
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE,

196
src/client/Client.cc
View File

@ -6,7 +6,10 @@ Client::Client()
{ {
m_net_client = new Network(); m_net_client = new Network();
m_net_client->Create(59243, "127.0.0.1"); // Just connect to local host for now - testing m_net_client->Create(59243, "127.0.0.1"); // Just connect to local host for now - testing
client_has_focus = true; client_has_focus = true;
m_players = new std::map<sf::Uint8, Player>;
m_players->clear();
current_player = 0;
} }
Client::~Client() Client::~Client()
@ -15,16 +18,15 @@ Client::~Client()
} }
void Client::run(bool fullscreen, int width, int height) void Client::run(bool fullscreen, int width, int height, std::string pname)
{ {
current_player_name = pname;
if (!create_window(fullscreen, width, height)) if (!create_window(fullscreen, width, height))
return; return;
m_player = new Player();
m_player->x = 0;
m_player->y = 0;
m_player->direction = M_PI_2;
m_clock.restart(); m_clock.restart();
sf::Mouse::setPosition(sf::Vector2i(m_width / 2, m_height / 2), *m_window); sf::Mouse::setPosition(sf::Vector2i(m_width / 2, m_height / 2), *m_window);
double last_time = 0.0; double last_time = 0.0;
while (m_window->isOpen()) while (m_window->isOpen())
{ {
@ -64,8 +66,11 @@ void Client::run(bool fullscreen, int width, int height)
} }
update(elapsed_time); update(elapsed_time);
redraw(); if(m_players->size() > 0)
last_time = current_time; {
redraw();
}
last_time = current_time;
// temporary for now. otherwise this thread consumed way too processing // temporary for now. otherwise this thread consumed way too processing
sf::sleep(sf::seconds(0.005)); // 5 milli-seconds sf::sleep(sf::seconds(0.005)); // 5 milli-seconds
@ -74,81 +79,136 @@ void Client::run(bool fullscreen, int width, int height)
void Client::update(double elapsed_time) void Client::update(double elapsed_time)
{ {
static sf::Uint8 w_pressed_prev = KEY_NOT_PRESSED; static bool registered_player = false;
static sf::Uint8 a_pressed_prev = KEY_NOT_PRESSED;
static sf::Uint8 s_pressed_prev = KEY_NOT_PRESSED;
static sf::Uint8 d_pressed_prev = KEY_NOT_PRESSED;
static sf::Int32 rel_mouse_movement_prev = 0;
sf::Packet client_packet; sf::Packet client_packet;
m_net_client->Receive(); m_net_client->Receive();
client_packet.clear(); client_packet.clear();
// Handle all received data (only really want the latest) // Handle all received data (only really want the latest)
while(m_net_client->getData(client_packet)) while(m_net_client->getData(client_packet))
{ {
// Update player position as calculated from the server. sf::Uint8 packet_type;
client_packet >> m_player->direction; client_packet >> packet_type;
client_packet >> m_player->x; switch(packet_type)
client_packet >> m_player->y; {
case PLAYER_CONNECT:
{
Player p;
sf::Uint8 pindex;
std::string name = "";
client_packet >> pindex;
client_packet >> name;
if(name == current_player_name)
{
current_player = pindex;
}
p.name = name;
(*m_players)[pindex] = p;
break;
}
case PLAYER_UPDATE:
{
sf::Uint8 player_index;
// Update player position as calculated from the server.
client_packet >> player_index;
if(m_players->end() != m_players->find(player_index))
{
client_packet >> (*m_players)[player_index].direction;
client_packet >> (*m_players)[player_index].x;
client_packet >> (*m_players)[player_index].y;
}
break;
}
case PLAYER_DISCONNECT:
{
// This will remove the player once the disconnect algorithm is implemented
break;
}
case PLAYER_DEATH:
{
// This will set a death flag in the player struct.
break;
}
default :
{
// Eat the packet
break;
}
}
} }
// For now, we are going to do a very crude shove data into // For now, we are going to do a very crude shove data into
// packet from keyboard and mouse events. // packet from keyboard and mouse events.
// TODO: Clean this up and make it more robust // TODO: Clean this up and make it more robust
client_packet.clear(); if(m_players->size() > 0)
{
sf::Uint8 w_pressed = KEY_NOT_PRESSED;
sf::Uint8 a_pressed = KEY_NOT_PRESSED;
sf::Uint8 s_pressed = KEY_NOT_PRESSED;
sf::Uint8 d_pressed = KEY_NOT_PRESSED;
sf::Int32 rel_mouse_movement = 0;
sf::Uint8 w_pressed = KEY_NOT_PRESSED; // This is a fix so that the mouse will not move outside the window and
sf::Uint8 a_pressed = KEY_NOT_PRESSED; // cause the user to click on another program.
sf::Uint8 s_pressed = KEY_NOT_PRESSED; // Note: Does not work well with fast movement.
sf::Uint8 d_pressed = KEY_NOT_PRESSED; if(client_has_focus)
sf::Int32 rel_mouse_movement = 0; {
if (sf::Keyboard::isKeyPressed(sf::Keyboard::A))
{
a_pressed = KEY_PRESSED;
}
if (sf::Keyboard::isKeyPressed(sf::Keyboard::D))
{
d_pressed = KEY_PRESSED;
}
if (sf::Keyboard::isKeyPressed(sf::Keyboard::W))
{
w_pressed = KEY_PRESSED;
}
if (sf::Keyboard::isKeyPressed(sf::Keyboard::S))
{
s_pressed = KEY_PRESSED;
}
rel_mouse_movement = sf::Mouse::getPosition(*m_window).x - m_width / 2;
sf::Mouse::setPosition(sf::Vector2i(m_width / 2, m_height / 2), *m_window);
}
// This is a fix so that the mouse will not move outside the window and // Send an update to the server if something has changed
// cause the user to click on another program. if(((*m_players)[current_player].w_pressed != w_pressed) ||
// Note: Does not work well with fast movement. ((*m_players)[current_player].a_pressed != a_pressed) ||
if(client_has_focus) ((*m_players)[current_player].s_pressed != s_pressed) ||
{ ((*m_players)[current_player].d_pressed != d_pressed) ||
if (sf::Keyboard::isKeyPressed(sf::Keyboard::A)) ((*m_players)[current_player].rel_mouse_movement != rel_mouse_movement))
{ {
a_pressed = KEY_PRESSED; sf::Uint8 packet_type = PLAYER_UPDATE;
} client_packet.clear();
if (sf::Keyboard::isKeyPressed(sf::Keyboard::D)) client_packet << packet_type;
{ client_packet << current_player;
d_pressed = KEY_PRESSED; client_packet << w_pressed;
} client_packet << a_pressed;
if (sf::Keyboard::isKeyPressed(sf::Keyboard::W)) client_packet << s_pressed;
{ client_packet << d_pressed;
w_pressed = KEY_PRESSED; client_packet << rel_mouse_movement;
}
if (sf::Keyboard::isKeyPressed(sf::Keyboard::S))
{
s_pressed = KEY_PRESSED;
}
rel_mouse_movement = sf::Mouse::getPosition(*m_window).x - m_width / 2;
sf::Mouse::setPosition(sf::Vector2i(m_width / 2, m_height / 2), *m_window);
}
// Send an update to the server if something has changed m_net_client->sendData(client_packet);
if((w_pressed_prev != w_pressed) ||
(a_pressed_prev != a_pressed) ||
(s_pressed_prev != s_pressed) ||
(d_pressed_prev != d_pressed) ||
(rel_mouse_movement_prev != rel_mouse_movement))
{
client_packet << w_pressed;
client_packet << a_pressed;
client_packet << s_pressed;
client_packet << d_pressed;
client_packet << rel_mouse_movement;
m_net_client->sendData(client_packet); (*m_players)[current_player].w_pressed = w_pressed;
(*m_players)[current_player].a_pressed = a_pressed;
w_pressed_prev = w_pressed; (*m_players)[current_player].s_pressed = s_pressed;
a_pressed_prev = a_pressed; (*m_players)[current_player].d_pressed = d_pressed;
s_pressed_prev = s_pressed; (*m_players)[current_player].rel_mouse_movement = rel_mouse_movement;
d_pressed_prev = d_pressed; }
rel_mouse_movement_prev = rel_mouse_movement; }
} else if(!registered_player)
{
sf::Uint8 packet_type = PLAYER_CONNECT;
client_packet.clear();
client_packet << packet_type;
client_packet << current_player;
client_packet << current_player_name;
m_net_client->sendData(client_packet);
registered_player = true;
}
m_net_client->Transmit(); m_net_client->Transmit();
} }

8
src/client/Client.h
View File

@ -18,14 +18,14 @@ class Client
public: public:
Client(); Client();
~Client(); ~Client();
void run(bool fullscreen, int width, int height); void run(bool fullscreen, int width, int height, std::string pname);
protected: protected:
bool create_window(bool fullscreen, int width, int height); bool create_window(bool fullscreen, int width, int height);
bool initgl(); bool initgl();
void resize_window(int width, int height); void resize_window(int width, int height);
void update(double elapsed_time); void update(double elapsed_time);
void redraw(); void redraw();
void draw_player(refptr<Player> player); void draw_player(Player player);
void draw_map(); void draw_map();
void draw_overlay(); void draw_overlay();
void draw_sky(); void draw_sky();
@ -34,7 +34,9 @@ class Client
refptr<sf::Window> m_window; refptr<sf::Window> m_window;
sf::Clock m_clock; sf::Clock m_clock;
Map m_map; Map m_map;
refptr<Player> m_player; sf::Uint8 current_player;
std::string current_player_name;
refptr< std::map<sf::Uint8, Player> > m_players;
int m_width; int m_width;
int m_height; int m_height;
GLProgram m_obj_program; GLProgram m_obj_program;

9
src/client/main.cc
View File

@ -8,12 +8,14 @@ int main(int argc, char *argv[])
bool fullscreen = false; bool fullscreen = false;
int width = 1200; int width = 1200;
int height = 900; int height = 900;
std::string player_name = "Player";
struct option longopts[] = { struct option longopts[] = {
{"fullscreen", no_argument, NULL, 'f'}, {"fullscreen", no_argument, NULL, 'f'},
{"height", required_argument, NULL, 'h'}, {"height", required_argument, NULL, 'h'},
{"width", required_argument, NULL, 'w'}, {"width", required_argument, NULL, 'w'},
{NULL, 0, NULL, 0} {"name", required_argument, NULL, 'n'},
{NULL, 0, NULL, 0}
}; };
for (;;) for (;;)
{ {
@ -31,12 +33,15 @@ int main(int argc, char *argv[])
case 'w': case 'w':
width = atoi(optarg); width = atoi(optarg);
break; break;
case 'n':
player_name = std::string(optarg);
break;
} }
} }
Client client; Client client;
client.run(fullscreen, width, height); client.run(fullscreen, width, height, player_name);
return 0; return 0;
} }

10
src/common/Player.cc
View File

@ -1,10 +1,18 @@
#include "Player.h" #include "Player.h"
#include <math.h>
Player::Player() Player::Player()
{ {
x = 0.0; x = 0.0;
y = 0.0; y = 0.0;
direction = 0.0; direction = M_PI_2;
hover = 1.0; hover = 1.0;
name = "";
w_pressed = KEY_NOT_PRESSED;
a_pressed = KEY_NOT_PRESSED;
s_pressed = KEY_NOT_PRESSED;
d_pressed = KEY_NOT_PRESSED;
rel_mouse_movement = 0;
updated = false;
} }

8
src/common/Player.h
View File

@ -3,6 +3,8 @@
#define PLAYER_H #define PLAYER_H
#include <string> #include <string>
#include "Types.h"
#include "SFML/Config.hpp"
class Player class Player
{ {
@ -12,6 +14,12 @@ class Player
double y; double y;
double direction; /* 0 = East, M_PI_2 = North, M_PI = West, ... */ double direction; /* 0 = East, M_PI_2 = North, M_PI = West, ... */
double hover; double hover;
sf::Uint8 w_pressed;
sf::Uint8 a_pressed;
sf::Uint8 s_pressed;
sf::Uint8 d_pressed;
sf::Int32 rel_mouse_movement;
bool updated;
Player(); Player();
}; };

5
src/common/Types.h
View File

@ -4,6 +4,9 @@
#define KEY_PRESSED 0xA5u #define KEY_PRESSED 0xA5u
#define KEY_NOT_PRESSED 0x5Au #define KEY_NOT_PRESSED 0x5Au
#define PLAYER_CONNECT 0x1Au
#define PLAYER_DISCONNECT 0x2Bu
#define PLAYER_DEATH 0x3Cu
#define PLAYER_UPDATE 0x4Du
#endif #endif

184
src/server/Server.cc
View File

@ -6,10 +6,8 @@ Server::Server(sf::Uint16 port)
{ {
m_net_server = new Network(); m_net_server = new Network();
m_net_server->Create(port, sf::IpAddress::None); m_net_server->Create(port, sf::IpAddress::None);
m_player = new Player(); m_players = new std::map<sf::Uint8, Player>;
m_player->x = 0; m_players->clear();
m_player->y = 0;
m_player->direction = M_PI_2;
} }
Server::~Server() Server::~Server()
@ -40,65 +38,137 @@ void Server::update( double elapsed_time )
static Player player_prev; static Player player_prev;
const double move_speed = 75.0; const double move_speed = 75.0;
sf::Packet server_packet; sf::Packet server_packet;
static sf::Uint8 w_pressed = KEY_NOT_PRESSED;
static sf::Uint8 a_pressed = KEY_NOT_PRESSED;
static sf::Uint8 s_pressed = KEY_NOT_PRESSED;
static sf::Uint8 d_pressed = KEY_NOT_PRESSED;
static sf::Int32 rel_mouse_movement = 0;
m_net_server->Receive(); m_net_server->Receive();
// Handle all received data (only really want the latest) // Handle all received data (only really want the latest)
while(m_net_server->getData(server_packet)) while(m_net_server->getData(server_packet))
{ {
server_packet >> w_pressed; sf::Uint8 ptype;
server_packet >> a_pressed; // Get packet type
server_packet >> s_pressed; server_packet >> ptype;
server_packet >> d_pressed; switch(ptype)
server_packet >> rel_mouse_movement; {
case PLAYER_CONNECT:
{
Player p;
std::string pname;
sf::Uint8 pindex;
server_packet >> pindex;
server_packet >> pname;
// When a player connects, we need to associate
// that player with a new ID. find first unused id
// player zero means a player does not exist.
if(pindex == 0)
{
for(pindex = 1u; pindex < 255u; pindex++ )
{
if(m_players->end() == m_players->find(pindex))
{
break;
}
}
p.name = pname;
(*m_players)[pindex] = p;
// Send a response to the newly added player
server_packet.clear();
server_packet << ptype;
server_packet << pindex;
server_packet << p.name;
m_net_server->sendData(server_packet, true);
}
break;
}
case PLAYER_UPDATE:
{
// Need to determine the correct player id
// then update the stored contents.
sf::Uint8 pindex;
server_packet >> pindex;
if(m_players->end() != m_players->find(pindex))
{
server_packet >> (*m_players)[pindex].w_pressed;
server_packet >> (*m_players)[pindex].a_pressed;
server_packet >> (*m_players)[pindex].s_pressed;
server_packet >> (*m_players)[pindex].d_pressed;
server_packet >> (*m_players)[pindex].rel_mouse_movement;
}
break;
}
case PLAYER_DISCONNECT:
{
// This completely removes the player from the game
// Deletes member from the player list
break;
}
case PLAYER_DEATH:
{
// This just forces the player to dissapper from the
// playing field.
break;
}
default:
{
// Just eat the packet
break;
}
}
} }
for(std::map<sf::Uint8, Player>::iterator piter = m_players->begin(); piter != m_players->end(); piter++)
{
sf::Uint8 pindex = piter->first;
double direction = (*m_players)[pindex].direction;
direction -= M_PI * 0.5 * (*m_players)[pindex].rel_mouse_movement / 1000;
if(direction != (*m_players)[pindex].direction)
{
(*m_players)[pindex].direction = direction;
(*m_players)[pindex].updated = true;
}
if (KEY_PRESSED == (*m_players)[pindex].a_pressed)
{
direction = (*m_players)[pindex].direction + M_PI_2;
(*m_players)[pindex].x += cos(direction) * move_speed * elapsed_time;
(*m_players)[pindex].y += sin(direction) * move_speed * elapsed_time;
(*m_players)[pindex].updated = true;
}
if (KEY_PRESSED == (*m_players)[pindex].d_pressed)
{
direction = (*m_players)[pindex].direction - M_PI_2;
(*m_players)[pindex].x += cos(direction) * move_speed * elapsed_time;
(*m_players)[pindex].y += sin(direction) * move_speed * elapsed_time;
(*m_players)[pindex].updated = true;
}
if (KEY_PRESSED == (*m_players)[pindex].w_pressed)
{
direction = (*m_players)[pindex].direction;
(*m_players)[pindex].x += cos(direction) * move_speed * elapsed_time;
(*m_players)[pindex].y += sin(direction) * move_speed * elapsed_time;
(*m_players)[pindex].updated = true;
}
if (KEY_PRESSED == (*m_players)[pindex].s_pressed)
{
direction = (*m_players)[pindex].direction + M_PI;
(*m_players)[pindex].x += cos(direction) * move_speed * elapsed_time;
(*m_players)[pindex].y += sin(direction) * move_speed * elapsed_time;
(*m_players)[pindex].updated = true;
}
server_packet.clear();
if (KEY_PRESSED == a_pressed) // Send the player update if there were changes
{ if((*m_players)[pindex].updated)
double direction = m_player->direction + M_PI_2; {
m_player->x += cos(direction) * move_speed * elapsed_time; sf::Uint8 ptype = PLAYER_UPDATE;
m_player->y += sin(direction) * move_speed * elapsed_time; server_packet << ptype;
} server_packet << pindex;
if (KEY_PRESSED == d_pressed) server_packet << (*m_players)[pindex].direction;
{ server_packet << (*m_players)[pindex].x;
double direction = m_player->direction - M_PI_2; server_packet << (*m_players)[pindex].y;
m_player->x += cos(direction) * move_speed * elapsed_time; m_net_server->sendData(server_packet);
m_player->y += sin(direction) * move_speed * elapsed_time; (*m_players)[pindex].updated = false;
} }
if (KEY_PRESSED == w_pressed) }
{
double direction = m_player->direction;
m_player->x += cos(direction) * move_speed * elapsed_time;
m_player->y += sin(direction) * move_speed * elapsed_time;
}
if (KEY_PRESSED == s_pressed)
{
double direction = m_player->direction + M_PI;
m_player->x += cos(direction) * move_speed * elapsed_time;
m_player->y += sin(direction) * move_speed * elapsed_time;
}
m_player->direction -= M_PI * 0.5 * rel_mouse_movement / 1000;
server_packet.clear();
// Send the player update if there were changes
if((player_prev.direction != m_player->direction) ||
(player_prev.x != m_player->x) ||
(player_prev.y != m_player->y))
{
server_packet << m_player->direction;
server_packet << m_player->x;
server_packet << m_player->y;
m_net_server->sendData(server_packet);
player_prev.direction = m_player->direction;
player_prev.x = m_player->x;
player_prev.y = m_player->y;
}
m_net_server->Transmit(); m_net_server->Transmit();
} }

3
src/server/Server.h
View File

@ -1,6 +1,7 @@
#include "Network.h" #include "Network.h"
#include "Player.h" #include "Player.h"
#include "refptr.h" #include "refptr.h"
#include "SFML/Config.hpp"
class Server{ class Server{
public: public:
@ -11,6 +12,6 @@ class Server{
protected: protected:
void update(double elapsed_time); void update(double elapsed_time);
refptr<Network> m_net_server; refptr<Network> m_net_server;
refptr<Player> m_player; refptr< std::map<sf::Uint8, Player> > m_players;
sf::Clock m_clock; sf::Clock m_clock;
}; };