gmueller/gremlin
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

use yaml for messages

Browse Source
This commit is contained in:
gmueller
2011-01-24 23:52:12 +01:00
parent 89a4b6ffb2
commit 1dbdb25f30
71 changed files with 7632 additions and 154 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/common/CMakeLists.txt
View File

@ -9,11 +9,11 @@ add_library( common
)
add_dependencies( common
enet pugixml bullet trimeshloader
enet pugixml bullet trimeshloader yaml-cpp
)
target_link_libraries(common
enet pugixml bullet trimeshloader
enet pugixml bullet trimeshloader yaml-cpp
)
if (WIN32)

300
src/common/Network.cpp
View File

@ -11,6 +11,7 @@
#include <iostream>
#include <cmath>
#include <typeinfo>
Network::Network(Game *game) :
game(game), client_peer(0) {
@ -80,7 +81,7 @@ void Network::sendGameUpdates() {
if (game->player[i].status == 0)
continue;
player_update_message_t msg;
msg.msg_id = MESSAGE_PLAYER_UPDATE;
//msg.msg_id = MESSAGE_PLAYER_UPDATE;
msg.player_id = game->player[i].id;
btVector3 v = game->player[i].body->getLinearVelocity();
btVector3 p = game->player[i].body->getWorldTransform().getOrigin();
@ -97,7 +98,7 @@ void Network::sendGameUpdates() {
}
for (i = 0; i < game->teams.size(); i++) {
team_update_message_t msg;
msg.msg_id = MESSAGE_TEAM_UPDATE;
//msg.msg_id = MESSAGE_TEAM_UPDATE;
msg.team_id = game->teams[i].id;
msg.points = game->teams[i].points;
msg.wins = game->teams[i].wins;
@ -108,121 +109,141 @@ void Network::sendGameUpdates() {
enet_host_flush(host);
}
template<class T>
T *_message_cast(void *p, size_t l) {
if (sizeof(T) != l) {
std::cout << sizeof(T) << std::endl;
std::cout << l << std::endl;
throw(typeid(T).name());
}
return (T *) p;
}
void Network::dispatch(enet_uint8 *data, size_t length) {
#if 0
message_t *msg = (message_t *) data;
switch (msg->msg_id) {
case MESSAGE_PLAYER_SPAWN: {
player_spawn_message_t *sm = (player_spawn_message_t *) data;
Team *team = game->getTeam(sm->team_id);
player_t *player = game->spawnPlayerWithId(team, sm->player_id);
break;
}
case MESSAGE_PLAYER_KILL: {
player_kill_message_t *sm = (player_kill_message_t *) data;
player_t *player = game->getPlayer(sm->player_id);
player->status = 0;
player->team = 0;
break;
}
case MESSAGE_ACCEPT: {
accept_message_t *am = (accept_message_t *) data;
game->local_player = game->getPlayer(am->player_id);
std::cout << "[Network] accpeted player " << am->player_id << std::endl;
break;
}
case MESSAGE_PLAYER_UPDATE: {
player_update_message_t *um = (player_update_message_t *) data;
player_t *player = game->getPlayer(um->player_id);
case MESSAGE_PLAYER_SPAWN: {
player_spawn_message_t *sm = _message_cast<player_spawn_message_t> (
data, length);
Team *team = game->getTeam(sm->team_id);
player_t *player = game->spawnPlayerWithId(team, sm->player_id);
break;
}
case MESSAGE_PLAYER_KILL: {
player_kill_message_t *sm = _message_cast<player_kill_message_t> (data,
length);
player_t *player = game->getPlayer(sm->player_id);
player->status = 0;
player->team = 0;
break;
}
case MESSAGE_ACCEPT: {
accept_message_t *am = _message_cast<accept_message_t> (data, length);
game->local_player = game->getPlayer(am->player_id);
std::cout << "[Network] accpeted player " << am->player_id << std::endl;
break;
}
case MESSAGE_PLAYER_UPDATE: {
player_update_message_t *um = _message_cast<player_update_message_t> (
data, length);
player_t *player = game->getPlayer(um->player_id);
#if 1
btVector3 v = player->body->getLinearVelocity();
btVector3 p = player->body->getWorldTransform().getOrigin();
btVector3 v1(um->vx, um->vy, um->vz);
btVector3 p1(um->x, um->y, um->z);
player->body->activate(true);
player->body->setLinearVelocity(v1);
player->body->getWorldTransform().setOrigin((2 * p + p1) / 3);
//player->body->applyCentralForce((v1 -v)/10.0);
btVector3 v = player->body->getLinearVelocity();
btVector3 p = player->body->getWorldTransform().getOrigin();
btVector3 v1(um->vx, um->vy, um->vz);
btVector3 p1(um->x, um->y, um->z);
player->body->activate(true);
player->body->setLinearVelocity(v1);
player->body->getWorldTransform().setOrigin((2 * p + p1) / 3);
//player->body->applyCentralForce((v1 -v)/10.0);
#endif
#if 0
std::cout << " v:" << um->vx << " " << um->vy << " " << um -> vz
<< std::endl;
std::cout << " p:" << um->x << " " << um->y << " " << um -> z
<< std::endl;
double threshold = 0.1;
double dx = um->x - player->x;
double dy = um->y - player->y;
double dz = um->z - player->z;
std::cout << " d:" << dx << " " << dy << " " << dz << std::endl;
if (fabs(dx) < threshold) {
player->x += 0.1 * dx;
} else {
player->x = um->x;
}
if (fabs(dy) < threshold) {
player->y += 0.1 * dy;
} else {
player->y = um->y;
}
if (fabs(dz) < threshold) {
player->z += 0.1 * dz;
} else {
player->z = um->z;
}
player->vx = um->vx;
player->vy = um->vy;
player->vz = um->vz;
std::cout << " v:" << um->vx << " " << um->vy << " " << um -> vz
<< std::endl;
std::cout << " p:" << um->x << " " << um->y << " " << um -> z
<< std::endl;
double threshold = 0.1;
double dx = um->x - player->x;
double dy = um->y - player->y;
double dz = um->z - player->z;
std::cout << " d:" << dx << " " << dy << " " << dz << std::endl;
if (fabs(dx) < threshold) {
player->x += 0.1 * dx;
} else {
player->x = um->x;
}
if (fabs(dy) < threshold) {
player->y += 0.1 * dy;
} else {
player->y = um->y;
}
if (fabs(dz) < threshold) {
player->z += 0.1 * dz;
} else {
player->z = um->z;
}
player->vx = um->vx;
player->vy = um->vy;
player->vz = um->vz;
#endif
player->points = um->points;
break;
}
case MESSAGE_POINT_UPDATE: {
point_update_mesage_t *msg = (point_update_mesage_t *) data;
point_t *p = &game->point[msg->point_index];
p->status = msg->status;
p->x = msg->x;
p->y = msg->y;
p->z = msg->z;
break;
}
case MESSAGE_PLAYER_ACCELERATE: {
player_accelerate_message_t *um = (player_accelerate_message_t *) data;
player_t *player = game->getPlayer(um->player_id);
player->vx += um->x;
player->vy += um->y;
player->vz += um->z;
player->body->activate(true);
player->body->applyCentralImpulse(btVector3(um->x, um->y, um->z));
break;
}
case MESSAGE_BOMB_DROP: {
bomb_drop_meesage_t *m = (bomb_drop_meesage_t *) data;
bomb_t *bomb = game->spawn_bomb();
if (bomb == NULL)
return;
bomb->x = m->x + m->vx * 0.0001;
bomb->y = m->y + m->vy * 0.0001;
bomb->z = m->z + m->vz * 0.0001;
bomb->vx = m->vx;
bomb->vy = m->vy;
bomb->vz = m->vz;
bomb->ttl = m->ttl;
if (client_peer == NULL) {
ENetPacket * packet = enet_packet_create(data, length,
ENET_PACKET_FLAG_RELIABLE);
enet_host_broadcast(host, 0, packet);
std::cout << um->z << std::endl;
player->points = um->points;
break;
}
break;
}
case MESSAGE_TEAM_UPDATE: {
team_update_message_t *m = (team_update_message_t *) data;
Team *team = game->getTeam(m->team_id);
if (team == NULL)
case MESSAGE_POINT_UPDATE: {
point_update_mesage_t *msg = _message_cast<point_update_mesage_t> (
data, length);
point_t *p = &game->point[msg->point_index];
p->status = msg->status;
p->x = msg->x;
p->y = msg->y;
p->z = msg->z;
break;
}
case MESSAGE_PLAYER_ACCELERATE: {
player_accelerate_message_t *um = _message_cast<
player_accelerate_message_t> (data, length);
player_t *player = game->getPlayer(um->player_id);
player->vx += um->x;
player->vy += um->y;
player->vz += um->z;
player->body->activate(true);
player->body->applyCentralImpulse(btVector3(um->x, um->y, um->z));
break;
}
case MESSAGE_BOMB_DROP: {
bomb_drop_meesage_t *m = _message_cast<bomb_drop_meesage_t> (data,
length);
bomb_t *bomb = game->spawn_bomb();
if (bomb == NULL)
return;
team->points = m->points;
team->wins = m->wins;
break;
}
bomb->x = m->x + m->vx * 0.0001;
bomb->y = m->y + m->vy * 0.0001;
bomb->z = m->z + m->vz * 0.0001;
bomb->vx = m->vx;
bomb->vy = m->vy;
bomb->vz = m->vz;
bomb->ttl = m->ttl;
if (client_peer == NULL) {
ENetPacket * packet = enet_packet_create(data, length,
ENET_PACKET_FLAG_RELIABLE);
enet_host_broadcast(host, 0, packet);
}
break;
}
case MESSAGE_TEAM_UPDATE: {
team_update_message_t *m = _message_cast<team_update_message_t> (data,
length);
Team *team = game->getTeam(m->team_id);
if (team == NULL)
return;
team->points = m->points;
team->wins = m->wins;
break;
}
};
#endif
}
void Network::service(uint32_t timeout) {
@ -238,12 +259,12 @@ void Network::service(uint32_t timeout) {
std::cout << "A new client connected from "
<< event.peer->address.host << " "
<< event.peer->address.port << std::endl;
#if 0
// bring new client up to date
size_t i;
for (i = 0; i < GAME_PLAYER_COUNT; i++) {
if (game->player[i].status == 0)
continue;
continue;
// send player spawn message
player_spawn_message_t spwan_msg;
spwan_msg.msg_id = MESSAGE_PLAYER_SPAWN;
@ -256,7 +277,7 @@ void Network::service(uint32_t timeout) {
for (i = 0; i < GAME_POINT_COUNT; i++) {
if (game->point[i].status == 0)
continue;
continue;
point_update_mesage_t msg;
msg.msg_id = MESSAGE_POINT_UPDATE;
msg.point_index = i;
@ -289,7 +310,7 @@ void Network::service(uint32_t timeout) {
packet = enet_packet_create(&msg, sizeof(msg),
ENET_PACKET_FLAG_RELIABLE);
enet_peer_send(event.peer, 0, packet);
#endif
// send state
}
break;
@ -299,14 +320,12 @@ void Network::service(uint32_t timeout) {
enet_packet_destroy(event.packet);
break;
}
case ENET_EVENT_TYPE_DISCONNECT:
//printf("%s disconected.\n", event.peer -> data);
{
case ENET_EVENT_TYPE_DISCONNECT: {
/* Reset the peer's client information. */
player_t *player = (player_t *) event.peer->data;
player->status = 0;
player->team = 0;
#if 0
// send player spawn message
player_kill_message_t msg;
msg.msg_id = MESSAGE_PLAYER_KILL;
@ -314,6 +333,7 @@ void Network::service(uint32_t timeout) {
ENetPacket * packet = enet_packet_create(&msg, sizeof(msg),
ENET_PACKET_FLAG_RELIABLE);
enet_host_broadcast(host, 0, packet);
#endif
}
event.peer->data = NULL;
break;
@ -322,6 +342,56 @@ void Network::service(uint32_t timeout) {
}
#define EMIT_START(msg) YAML::Emitter& operator <<(YAML::Emitter& out, const msg& m) { out << YAML::Key << "id" << YAML::Value << msg::id;
#define EMIT_FIELD(name) out << YAML::Key << #name << YAML::Value << m.name;
#define EMIT_END() out << YAML::EndMap;return out;}
EMIT_START(player_spawn_message_t)
EMIT_FIELD(team_id)
EMIT_FIELD(player_id)
EMIT_END()
EMIT_START(player_accelerate_message_t)
EMIT_FIELD(player_id)
EMIT_FIELD(x)
EMIT_FIELD(y)
EMIT_FIELD(z)
EMIT_END()
EMIT_START(bomb_drop_meesage_t)
EMIT_FIELD(x)
EMIT_FIELD(y)
EMIT_FIELD(z)
EMIT_FIELD(vx)
EMIT_FIELD(vy)
EMIT_FIELD(vz)
EMIT_FIELD(ttl)
EMIT_END()
#define PARSE_START(msg) void operator >>(const YAML::Node& node, msg& m) {
#define PARSE_FIELD(name) node[#name] >> m.name;
#define PARSE_END() }
PARSE_START(player_spawn_message_t) PARSE_FIELD(team_id)
PARSE_FIELD(player_id)PARSE_END()
//void Network::sendMessage(message_t &m) {
// if (client_peer) {
// msgpack::sbuffer b;
// msgpack::packer<msgpack::sbuffer> packer(b);
// m.pack(packer);
// ENetPacket * packet = enet_packet_create(b.data(), b.size(),
// ENET_PACKET_FLAG_RELIABLE);
// enet_peer_send(client_peer, 0, packet);
// } else {
// // dispatch
// }
//}
void Network::send(const YAML::Emitter &em) {
sendMessage((uint8_t *) em.c_str(), em.size());
}
void Network::sendMessage(uint8_t *data, size_t length) {
if (client_peer) {
ENetPacket * packet = enet_packet_create(data, length,

88
src/common/Network.h
View File

@ -11,7 +11,8 @@
#include "Game.h"
#include "common.h"
#include <enet/enet.h>
#include "enet/enet.h"
#include "yaml-cpp/yaml.h"
#include <string>
@ -25,70 +26,90 @@
#define MESSAGE_POINT_UPDATE 7
#define MESSAGE_TEAM_UPDATE 8
typedef struct message_t {
uint16_t msg_id;
} message_t;
struct player_spawn_message_t {
enum {
id = 0
};
size_t team_id;
size_t player_id;
};
typedef struct player_spawn_message_t {
uint16_t msg_id;
uint8_t team_id;
struct player_kill_message_t {
enum {
id = 1
};
uint16_t player_id;
} player_spawn_message_t;
};
typedef struct player_kill_message_t {
uint16_t msg_id;
struct accept_message_t {
enum {
id = 2
};
uint16_t player_id;
} player_kill_message_t;
};
typedef struct accept_message_t {
uint16_t msg_id;
struct player_update_message_t {
enum {
id = 3
};
uint16_t player_id;
} accept_message_t;
typedef struct player_update_message_t {
uint16_t msg_id;
uint16_t player_id;
unsigned int session;
// unsigned int session;
double x, y, z;
double vx, vy, vz;
uint16_t points;
} player_update_message_t;
};
typedef struct player_accelerate_message_t {
uint16_t msg_id;
struct player_accelerate_message_t {
enum {
id = 4
};
uint16_t player_id;
double x, y, z;
} player_accelerate_message_t;
};
typedef struct bomb_drop_meesage_t {
uint16_t msg_id;
struct bomb_drop_meesage_t {
enum {
id = 5
};
double x, y, z;
double vx, vy, vz;
double ttl;
} bomb_drop_meesage_t;
};
typedef struct bomb_update_meesage_t {
uint16_t msg_id;
struct bomb_update_meesage_t {
enum {
id = 5
};
uint16_t bomb_index;
double x, y, z;
double vx, vy, vz;
double ttl;
} bomb_update_meesage_t;
};
typedef struct point_update_mesage_t {
uint16_t msg_id;
struct point_update_mesage_t {
enum {
id = 7
};
uint16_t point_index;
uint8_t status;
double x, y, z;
} point_update_meesage_t;
};
struct team_update_message_t {
uint16_t msg_id;
enum {
id = 8
};
uint16_t team_id;
uint16_t points;
uint16_t wins;
};
#define EMIT_DEFINE(msg) YAML::Emitter& operator <<(YAML::Emitter& out, const msg& m);
EMIT_DEFINE(player_spawn_message_t)
EMIT_DEFINE(player_accelerate_message_t)
EMIT_DEFINE(bomb_drop_meesage_t)
class Network {
public:
Network(Game* game);
@ -98,6 +119,7 @@ public:
void service(uint32_t timeout);
void sendGameUpdates();
void sendMessage(uint8_t *data, size_t length);
void send(const YAML::Emitter &em);
protected:
Game *game;
ENetHost *host;