static int
proto_server_pickup_handler(Proto_Session *s){
int id,rc,ret;
Proto_Msg_Hdr sh;
Proto_Msg_Hdr rh;
Player* p;
Proto_Session *us;
bzero(&sh, sizeof(sh));
bzero(&rh, sizeof(rh));
sh.type = proto_session_hdr_unmarshall_type(s);
sh.type += PROTO_MT_REP_BASE_RESERVED_FIRST;
proto_session_hdr_unmarshall(s, &rh);
id = rh.pstate.v0.raw;
p = gamestate_get_player(Server_Gamestate,id);
ret = player_obj_pickup(p,Server_ObjectMap,Server_Gamestate);
sh.pstate.v0.raw = id;//same header for both reply and update
sh.pstate.v1.raw = ret; //sending back the actual thing picked up
proto_session_hdr_marshall(s, &sh);
rc = proto_session_send_msg(s,1);
if(ret >= 0){
us = proto_server_event_session();
sh.type = PROTO_MT_EVENT_BASE_MOVE;
proto_session_hdr_marshall(us,&sh);
proto_server_post_event();
}
return rc;
}
static int
proto_server_mt_leave_game_handler(Proto_Session *s)
{
Proto_Msg_Hdr h;
int rc;
int dummy_reply = 1;
if (proto_debug())
fprintf(stderr, "proto_server_mt_leave_game_handler: invoked for session:\n");
//proto_session_dump(s);
// Call game logic: remove player from game
// TODO: update game version if necesary
// pthread_mutex_lock(&server_data_mutex);
// pthread_mutex_unlock(&server_data_mutex);
if (proto_debug())
fprintf(stderr, "proto_server_mt_leave_game_handler: remove player reply:%d\n", 1);
bzero(&h, sizeof(h));
h.type = proto_session_hdr_unmarshall_type(s);
h.type += PROTO_MT_REP_BASE_RESERVED_FIRST;
h.sver.raw = server_gameData.version;
h.gstate.v0.raw = server_gameData.state;
proto_session_hdr_marshall(s, &h);
proto_session_body_marshall_int(s, dummy_reply);
rc = proto_session_send_msg(s, 1);
// TODO: update subscribers
// doUpdateClientsGame(0);
return rc;
}
static int proto_server_mt_numhome_handler(Proto_Session *s)
{
int numhome, rc, teamNo;
Proto_Msg_Hdr h;
if (proto_debug()) {
fprintf(stderr, "proto_server_mt_move_handler: invoked for session:\n");
//proto_session_dump(s);
}
proto_session_body_unmarshall_int(s, 0, &teamNo);
if (proto_debug())
fprintf(stderr, "proto_server_mt_numhome_handler: requested teamNo = %d\n", teamNo);
numhome = findNumHome(teamNo); //numhome = 5;
//pthread_mutex_lock(&game_mutex); //pthread_mutex_unlock(&game_mutex);
if (proto_debug())
fprintf(stderr, "proto_server_mt_numhome_handler: maze.c func returned = %d\n", numhome);
// create replay message
bzero(&h, sizeof(h));
h.type = proto_session_hdr_unmarshall_type(s);
h.type += PROTO_MT_REP_BASE_RESERVED_FIRST;
proto_session_hdr_marshall(s, &h);
if (proto_session_body_marshall_int(s, numhome) < 0 )
fprintf(stderr, "proto_server_mt_numhome_handler: "
"proto_session_body_marshall_bytes failed\n");
rc = proto_session_send_msg(s, 1);
// TODO: return failed if an error occours
return rc;
}
static int proto_server_mt_numfloor_handler(Proto_Session *s)
{
int numfloor, rc;
Proto_Msg_Hdr h;
if (proto_debug()) {
fprintf(stderr, "proto_server_mt_numfloor_handler: invoked for session:\n");
//proto_session_dump(s);
}
numfloor = findNumFloor();//numfloor = 12345; // call mze.c numjail(teamNo) func
if (proto_debug())
fprintf(stderr, "proto_server_mt_numfloor_handler: maze.c::func returned = %d\n", numfloor);
// create replay message
bzero(&h, sizeof(h));
h.type = proto_session_hdr_unmarshall_type(s);
h.type += PROTO_MT_REP_BASE_RESERVED_FIRST;
proto_session_hdr_marshall(s, &h);
if (proto_session_body_marshall_int(s, numfloor) < 0 )
fprintf(stderr, "proto_server_mt_numfloor_handler: "
"proto_session_body_marshall_bytes failed\n");
rc = proto_session_send_msg(s, 1);
// TODO: return failed if an error occours
return rc;
}
// Assigment 3 rpc
static int
do_numhome_rpc(Proto_Client_Handle ch, Proto_Msg_Types mt, int data)
{
int rc;
Proto_Session *s;
Proto_Client *c = ch;
Proto_Msg_Hdr h;
if (proto_debug())
fprintf(stderr, "do_numhome_rpc (team = %d)\n", data);
s = &(c->rpc_session);
bzero(&h, sizeof(h));
h.type = mt;
proto_session_hdr_marshall(s, &h);
if (proto_session_body_marshall_int(s, data) < 0)
fprintf(stderr,
"get_numHome_rpc: proto_session_body_marshall_char failed. "
"Not enough available sbufer space\n");
rc = proto_session_rpc(s);
if (rc == 1) {
if(proto_session_body_unmarshall_int(s, 0, &rc) < 0)
fprintf(stderr, "do_numhome_rpc: proto_session_body_unmarshall_bytes failed\n");
if (proto_debug())
fprintf(stderr, "do_numhome_rpc: unmarshalled response rc = %d \n", rc);
}
else {
c->session_lost_handler(s);
close(s->fd);
}
return rc;
}
static int proto_server_mt_dump_handler(Proto_Session *s)
{
int rc;
Proto_Msg_Hdr h;
if (proto_debug()) {
fprintf(stderr, "proto_server_mt_dump_handler: invoked for session:\n");
//proto_session_dump(s);
}
dumpMap();
// create replay message
bzero(&h, sizeof(h));
h.type = proto_session_hdr_unmarshall_type(s);
h.type += PROTO_MT_REP_BASE_RESERVED_FIRST;
proto_session_hdr_marshall(s, &h);
rc = 1;
if (proto_session_body_marshall_int(s, rc) < 0 )
fprintf(stderr, "proto_server_mt_dump_handler: "
"proto_session_body_marshall_bytes failed\n");
rc = proto_session_send_msg(s, 1);
// TODO: return failed if an error occours
return rc;
}
static int
do_numwall_rpc(Proto_Client_Handle ch, Proto_Msg_Types mt)
{
int rc;
Proto_Session *s;
Proto_Client *c = ch;
Proto_Msg_Hdr h;
if (proto_debug())
fprintf(stderr, "do_numwall_rpc\n");
s = &(c->rpc_session);
bzero(&h, sizeof(h));
h.type = mt;
proto_session_hdr_marshall(s, &h);
rc = proto_session_rpc(s);
if (rc == 1) {
if(proto_session_body_unmarshall_int(s, 0, &rc) < 0)
fprintf(stderr, "get_numwall_rpc: proto_session_body_unmarshall_bytes failed\n");
if (proto_debug())
fprintf(stderr, "do_numwall_rpc: unmarshalled response rc = %d \n", rc);
}
else {
c->session_lost_handler(s);
close(s->fd);
}
return rc;
}
static int
do_cinfo_rpc(Proto_Client_Handle ch, int x, int y, Proto_Msg_Types mt){
int rc=0;
Proto_Session *s;
Proto_Client *c = ch;
Proto_Msg_Hdr *hdr = malloc(sizeof(Proto_Msg_Hdr));
s = &(c->rpc_session);
bzero(hdr, sizeof(Proto_Msg_Hdr));
hdr->pstate.v0.raw=x;
hdr->pstate.v1.raw=y;
hdr->type = mt;
proto_session_hdr_marshall(s,hdr);
proto_dump_msghdr(&(s->shdr));
rc = proto_session_rpc(s);
if(rc==1){
proto_session_hdr_unmarshall(s,&s->rhdr);
proto_dump_msghdr(&(s->rhdr));
}
else
c->session_lost_handler(s);
return rc;
}
static int
do_goodbye_rpc(Proto_Client_Handle ch, Player *p, Proto_Msg_Types mt){
int rc=0;
Proto_Session *s;
Proto_Client *c = ch;
Proto_Msg_Hdr hdr;
s = &(c->rpc_session);
bzero(&hdr, sizeof(Proto_Msg_Hdr));
hdr.type = mt;
proto_session_hdr_marshall(s,&hdr);
proto_session_body_marshall_player(s,p);
rc = proto_session_rpc(s);
if(rc==1){
proto_session_hdr_unmarshall(s,&s->rhdr);
// proto_dump_msghdr(&(s->rhdr));
}
else
c->session_lost_handler(s);
return rc;
}
// Broadcasts changes in the game to Subscribers
int
doUpdateClientsGame(int updateMapVersion)
{
Proto_Session *s;
Proto_Msg_Hdr hdr;
if (proto_debug())
fprintf(stderr, "doUpdateClientsGame called\n");
bzero(&hdr, sizeof(hdr));
s = proto_server_event_session();
// set sver if nescesary
hdr.type = PROTO_MT_EVENT_BASE_UPDATE;
// pthread_spin_lock(&server_data_spinlock);
hdr.sver.raw = server_gameData.version;
hdr.gstate.v0.raw = server_gameData.state;
// pthread_spin_unlock(&server_data_spinlock);
proto_session_hdr_marshall(s, &hdr);
// test
proto_server_test_msg(s);
proto_server_post_event();
return 1;
}
static void
marshall_mtonly(Proto_Session *s, Proto_Msg_Types mt) {
Proto_Msg_Hdr h;
bzero(&h, sizeof(h));
h.type = mt;
proto_session_hdr_marshall(s, &h);
}
static int
do_cinfo_rpc(Proto_Client_Handle ch, Proto_Msg_Types mt, int x, int y)
{
int rc;
char cell, team, occupied;
Proto_Session *s;
Proto_Client *c = ch;
Proto_Msg_Hdr h;
s = &(c->rpc_session);
bzero(&h, sizeof(h));
h.type = mt;
proto_session_hdr_marshall(s, &h);
if (proto_debug())
fprintf(stderr, "do_cinfo_rpc: cinfo(%d, %d) \n", x, y);
if (proto_session_body_marshall_int(s, x) < 0)
fprintf(stderr,
"do_cinfo_rpc: proto_session_body_marshall_char failed. "
"Not enough available sbufer space\n");
if (proto_session_body_marshall_int(s, y) < 0)
fprintf(stderr,
"do_cinfo_rpc: proto_session_body_marshall_char failed. "
"Not enough available sbufer space\n");
rc = proto_session_rpc(s);
if (rc == 1) {
// unmarshall
if (proto_session_body_unmarshall_char(s, 0, &cell) < 0)
fprintf(stderr, "do_cinfo_rpc: proto_session_body_unmarshall_bytes failed\n");
if (proto_session_body_unmarshall_char(s, 1, &team) < 0)
fprintf(stderr, "do_cinfo_rpc: proto_session_body_unmarshall_bytes failed\n");
if (proto_session_body_unmarshall_char(s, 2, &occupied) < 0)
fprintf(stderr, "do_cinfo_rpc: proto_session_body_unmarshall_bytes failed\n");
if (proto_debug())
fprintf(stderr, "do_cinfo_rpc: unmarshalled response cell = %X, %c \n", cell & 0xFF, cell);
if (proto_debug())
fprintf(stderr, "do_cinfo_rpc: unmarshalled response team = %X, %c \n", team & 0xFF, team);
if (proto_debug())
fprintf(stderr, "do_cinfo_rpc: unmarshalled response occupied = %X, %c \n", occupied & 0xFF, occupied);
rc = 0;
rc =((cell & 0xFF)<<8) | ((team & 0xFF)<<16) | ((occupied & 0xFF)<<24);
if (proto_debug())
fprintf(stderr, "do_cinfo_rpc: return value = %X \n", rc);
}
else {
c->session_lost_handler(s);
close(s->fd);
}
return rc;
}
int
doUpdateClients(void) {
Proto_Session *s;
Proto_Msg_Hdr hdr;
s = proto_server_event_session();
hdr.type = PROTO_MT_EVENT_BASE_UPDATE;
proto_session_hdr_marshall(s, &hdr);
proto_server_post();
return 1;
}
static int proto_server_mt_cinfo_handler(Proto_Session *s)
{
int in_x, in_y, rc;
char cell, team, occupied;
Proto_Msg_Hdr h;
if (proto_debug()) {
fprintf(stderr, "proto_server_mt_cinfo_handler: invoked for session:\n");
//proto_session_dump(s);
}
// read msg here
proto_session_body_unmarshall_int(s, 0, &in_x);
proto_session_body_unmarshall_int(s, sizeof(int), &in_y);
if (proto_debug())
fprintf(stderr, "proto_server_mt_numjail_handler: requested cellinfo( %d, %d )\n", in_x, in_y);
//cell = '#';//cell = (char)0xCC; // call mze.c numjail(teamNo) func
//team = '1';//team = (char)0xDD;
//occupied = 'Y';//occupied = (char)0xEE;
cell = get_cell_type( in_x, in_y );
team = get_cell_team( in_x, in_y );
occupied = is_cell_occupied( in_x, in_y );
//findCInfo(in_x, in_y);
if (proto_debug())
fprintf(stderr, "proto_server_mt_numjail_handler: maze.c::func returned\n"
" cell='%c', team='%c', occupied='%c'\n", cell, team, occupied);
// create replay message
bzero(&h, sizeof(h));
h.type = proto_session_hdr_unmarshall_type(s);
h.type += PROTO_MT_REP_BASE_RESERVED_FIRST;
proto_session_hdr_marshall(s, &h);
if (proto_session_body_marshall_char(s, cell) < 0 )
fprintf(stderr, "proto_server_mt_cinfo_handler: "
"proto_session_body_marshall_bytes failed\n");
if (proto_session_body_marshall_char(s, team) < 0 )
fprintf(stderr, "proto_server_mt_cinfo_handler: "
"proto_session_body_marshall_bytes failed\n");
if (proto_session_body_marshall_char(s, occupied) < 0 )
fprintf(stderr, "proto_server_mt_cinfo_handler: "
"proto_session_body_marshall_bytes failed\n");
rc = proto_session_send_msg(s, 1);
// TODO: return failed if an error occours
return rc;
}
//send back an ack reply then close session
static int
proto_server_goodbye_handler(Proto_Session *s){
Proto_Msg_Hdr h;
Proto_Session *us;
Player p;
int rc=1;
proto_session_body_unmarshall_player(s,0,&p);
bzero(&h, sizeof(h));
h.type = PROTO_MT_REP_BASE_GOODBYE;
proto_session_hdr_marshall(s, &h);
rc = proto_session_send_msg(s,1);
if(p.team == TEAM1){
numPlayers1--;
if(p.state == SAFE)
numplayershome1--;
} else{
numPlayers2--;
if(p.state == SAFE)
numplayershome2--;
}
gamestate_remove_player(Server_Gamestate,p.id);
pidx = player_find_next_id(Server_Gamestate->plist);
if(pidx<0)
gamefull = 1;
else
gamefull = 0;
us = proto_server_event_session();
h.type = PROTO_MT_EVENT_BASE_PLAYER_QUIT;
proto_session_hdr_marshall(us,&h);
proto_session_body_marshall_player(us, &p);
proto_server_post_event();
return rc;
}
static int
proto_server_dump_handler(Proto_Session *s){
Proto_Msg_Hdr h;
int i;
map_dump(Server_Map);
bzero(&h, sizeof(h));
h.type = PROTO_MT_REP_BASE_DUMP;
proto_session_hdr_marshall(s, &h);
proto_session_body_marshall_int(s, 1);
return proto_session_send_msg(s,1);
}
static int
proto_server_mt_join_game_handler(Proto_Session *s)
{
int rc, player, dimy, dimx;
Proto_Msg_Hdr h;
player = 1;
char dummy_maze[] = {'1','2','3','4','5','6','7','8','9'};
if (proto_debug())
fprintf(stderr, "proto_server_mt_join_game_handler: invoked for session:\n");
//proto_session_dump(s);
// prepare reply message
bzero(&h, sizeof(s));
h.type = proto_session_hdr_unmarshall_type(s);
h.type += PROTO_MT_REP_BASE_RESERVED_FIRST;
// send to client the current state and version
h.sver.raw = server_gameData.version;
h.gstate.v0.raw = server_gameData.state;
proto_session_hdr_marshall(s, &h);
// TODO: call game logic
dimx = 3;//dimx = get_maze_dimx();
dimy = 3;//dimy = get_maze_dimy();
// TODO: update game version and state if necesary
// pthread_mutex_lock(&server_data_mutex);
// pthread_mutex_unlock(&server_data_mutex);
// relpy: pID, xdim, ydim, maze
if (proto_session_body_marshall_int(s, player) < 0)
fprintf(stderr, "proto_server_mt_join_game_handler: "
"proto_session_body_marshall_int failed\n");
if (proto_session_body_marshall_int(s, dimx) < 0 )
fprintf(stderr, "proto_server_mt_join_game_handler: "
"proto_session_body_marshall_int failed\n");
if (proto_session_body_marshall_int(s, dimy) < 0 )
fprintf(stderr, "proto_server_mt_join_game_handler: "
"proto_session_body_marshall_int failed\n");
if (proto_session_body_marshall_bytes(s, dimx*dimy, &dummy_maze[0]) < 0)
fprintf(stderr, "proto_server_mt_join_game_handler: "
"proto_session_body_marshall_bytes failed\n");
rc = proto_session_send_msg(s,1);
// TODO: update subscribers
doUpdateClientsGame(0);
return rc;
}
//This function is used for RPC's that do not contain anything in the body
//Parameter: Proto_Msg_Hdr ch - that contains all necessary information for the RPC
// Proto_Client_Handle *h - Handle to the Proto_Client
//Returns: Return Code - as specified in Game_Error_Types in types.h
extern int
do_no_body_rpc(Proto_Client_Handle ch, Proto_Msg_Hdr * h)
{
int rc;
Proto_Session *s;
Proto_Client *c = ch;
s = &(c->rpc_session);
proto_session_hdr_marshall(s,h);
rc = proto_session_send_msg(s,1);
rc = proto_session_rcv_msg(s);
if(rc<=0) rc =-1;
return rc;
}
static int
do_item_action_rpc(Proto_Client_Handle ch, Proto_Msg_Types mt, char item, char action)
{
int rc;
Proto_Session *s;
Proto_Client *c = ch;
Proto_Msg_Hdr h;
// prepare message
s = &(c->rpc_session);
bzero(&h, sizeof(h));
h.type = mt;
proto_session_hdr_marshall(s, &h);
if (proto_debug())
fprintf(stderr, "do_item_action: pId: %d, item: #%c#, action = #%c#\n", playerdata.id, item, action);
if (proto_session_body_marshall_int(s, playerdata.id) < 0)
fprintf(stderr, "do_item_action_rpc: proto_session_body_marshall_int failed. "
"Not enough available sbufer space\n");
if (proto_session_body_marshall_char(s, item) < 0)
fprintf(stderr, "do_item_action: proto_session_body_marshall_char failed. "
"Not enough available sbufer space\n");
if (proto_session_body_marshall_char(s, action) < 0)
fprintf(stderr, "do_item_action: proto_session_body_marshall_char failed. "
"Not enough available sbufer space\n");
rc = proto_session_rpc(s);
// process response
if (rc == 1)
{
proto_session_hdr_unmarshall(s, &h);
wait_for_event(h.sver.raw);
if (proto_session_body_unmarshall_int(s, 0, &rc) < 0)
fprintf(stderr, "do_item_action: proto_session_body_unmarshall_int failed\n");
if (proto_debug())
fprintf(stderr, "do_item_action: unmarshalled response rc = %d, game version = %llu, game state = %d \n",
rc, h.sver.raw, h.gstate.v0.raw);
}
else
{
c->session_lost_handler(s);
close(s->fd);
}
return rc;
}
static int
do_move_rpc(Proto_Client_Handle ch, Proto_Msg_Types mt, char data)
{
int rc, temp_version;
Proto_Session *s;
Proto_Client *c = ch;
Proto_Msg_Hdr h;
// prepare message: pID, move_command
s = &(c->rpc_session);
bzero(&h, sizeof(h));
h.type = mt;
proto_session_hdr_marshall(s, &h);
if (proto_debug())
fprintf(stderr, "do_move_rpc:\n pId: %d\n move: #%c#\n", playerdata.id, data);
if (proto_session_body_marshall_int(s, playerdata.id) < 0)
fprintf(stderr, "do_move_rpc: proto_session_body_marshall_int failed. "
"Not enough available sbufer space\n");
if (proto_session_body_marshall_char(s, data) < 0)
fprintf(stderr, "do_move_rpc: proto_session_body_marshall_char failed. "
"Not enough available sbufer space\n");
rc = proto_session_rpc(s);
// process reply
if (rc == 1)
{
proto_session_hdr_unmarshall(s, &h);
// wait until we have recieved the envent update
wait_for_event(h.sver.raw);
if (proto_session_body_unmarshall_int(s, 0, &rc) < 0)
fprintf(stderr, "do_move_rpc: proto_session_body_unmarshall_int failed\n");
if (proto_debug())
fprintf(stderr, "do_move_rpc: unmarshalled response rc = %d, game version = %llu, game state = %d \n",
rc, h.sver.raw, h.gstate.v0.raw);
}
else
{
c->session_lost_handler(s);
close(s->fd);
}
return rc;
}
static int
proto_server_mt_item_action_handler(Proto_Session *s)
{
int rc, player_id;
char item, action;
int dummy_reply = 1;
Proto_Msg_Hdr h;
if (proto_debug())
fprintf(stderr, "proto_server_mt_item_action_handler: invoked for session:\n");
// proto_session_dump(s);
// Read rpc message: pID, item, action
proto_session_body_unmarshall_int(s, 0, &player_id);
proto_session_body_unmarshall_char(s, sizeof(int), &item);
proto_session_body_unmarshall_char(s, sizeof(int)+sizeof(char), &action);
if (proto_debug())
fprintf(stderr, "proto_server_mt_move_handler: Recieved:\n"
" pId: %d\n item #%c#\n action #%c#\n", player_id, item, action);
// TODO: call game logic
// TODO: update game version if necesary
// pthread_mutex_lock(&server_data_mutex);
// pthread_mutex_unlock(&server_data_mutex);
if (proto_debug())
fprintf(stderr, "proto_server_mt_move_handler: Send: game logic_reply: %d\n", dummy_reply);
// rpc reply
bzero(&h, sizeof(h));
h.type = proto_session_hdr_unmarshall_type(s);
h.type += PROTO_MT_REP_BASE_RESERVED_FIRST;
h.sver.raw = server_gameData.version;
h.gstate.v0.raw = server_gameData.state;
proto_session_hdr_marshall(s, &h);
proto_session_body_marshall_int(s, dummy_reply);
rc = proto_session_send_msg(s, 1);
// TODO: update subscribers
// doUpdateClientsGame(0);
return rc;
}
static int
do_dim_rpc(Proto_Client_Handle ch, Proto_Msg_Types mt)
{
int rc, x, y;
Proto_Session *s;
Proto_Client *c = ch;
Proto_Msg_Hdr h;
if (proto_debug())
fprintf(stderr, "do_dim_rpc\n");
s = &(c->rpc_session);
bzero(&h, sizeof(h));
h.type = mt;
proto_session_hdr_marshall(s, &h);
rc = proto_session_rpc(s);
if (rc == 1) {
if (proto_session_body_unmarshall_int(s, 0, &x) < 0)
fprintf(stderr, "do_dim_rpc: proto_session_body_unmarshall_bytes failed\n");
if (proto_session_body_unmarshall_int(s, sizeof(int), &y) < 0)
fprintf(stderr, "do_dim_rpc: proto_session_body_unmarshall_bytes failed\n");
if (proto_debug())
fprintf(stderr, "do_dim_rpc: unmarshalled response x = %X \n", x);
if (proto_debug())
fprintf(stderr, "do_dim_rpc: unmarshalled response y = %X \n", y);
rc = (x << 16) | y;
if (proto_debug())
fprintf(stderr, "do_dim_rpc: return value = %X \n", rc);
}
else {
c->session_lost_handler(s);
close(s->fd);
}
return rc;
}
//This function is used for RPC's that do not contain anything in the body
//Parameter: Proto_Msg_Hdr *h - that contains all necessary information for the RPC
// Proto_Client_Handle ch - Handle to the Proto_Client
// Pos current - current position of the player
// Pos next - next position that the players wants to move to
//Returns: Return Code - as specified in Game_Error_Types in types.h
extern int
do_action_request_rpc(Proto_Client_Handle ch, Proto_Msg_Hdr * hdr,Pos current, Pos next)
{
int rc;
Proto_Session *s;
Proto_Client *c = ch;
s = &(c->rpc_session);
proto_session_hdr_marshall(s,hdr);
if( hdr->gstate.v1.raw >= ACTION_MOVE &&
hdr->gstate.v1.raw <= ACTION_PICKUP_SHOVEL)
{
proto_session_body_marshall_bytes(s,sizeof(Pos),(char*)¤t);
proto_session_body_marshall_bytes(s,sizeof(Pos),(char*)&next);
}
rc = proto_session_send_msg(s,1);
rc = proto_session_rcv_msg(s);
if(rc<=0) rc =-1;
return rc;
}
static int
proto_server_mt_null_handler(Proto_Session *s){
int rc=1;
Proto_Msg_Hdr h;
fprintf(stderr, "proto_server_mt_null_handler: invoked for session:\n");
proto_session_dump(s);
// setup dummy reply header : set correct reply message type and
// everything else empty
bzero(&h, sizeof(h));
h.type = proto_session_hdr_unmarshall_type(s);
h.type += PROTO_MT_REP_BASE_RESERVED_FIRST;
proto_session_hdr_marshall(s, &h);
// setup a dummy body that just has a return code
proto_session_body_marshall_int(s, 0xdeadbeef);
rc=proto_session_send_msg(s,1);
return rc;
}
static int proto_server_mt_dim_handler(Proto_Session *s)
{
int dimx, dimy, rc;
Proto_Msg_Hdr h;
if (proto_debug()) {
fprintf(stderr, "proto_server_mt_dim_handler: invoked for session:\n");
//proto_session_dump(s);
}
//dimx = 1;//dimx = 0x0000AAAA; // call mze.c numjail(teamNo) func
//dimy = 2;//dimy = 0x0000BBBB; // call mze.c numjail(teamNo) func
dimx = get_maze_dimx();
dimy = get_maze_dimy();
if (proto_debug())
fprintf(stderr, "proto_server_mt_dim_handler: maze.c::func returned x=%d, y=%d\n", dimx, dimy);
// create replay message
bzero(&h, sizeof(h));
h.type = proto_session_hdr_unmarshall_type(s);
h.type += PROTO_MT_REP_BASE_RESERVED_FIRST;
proto_session_hdr_marshall(s, &h);
if (proto_session_body_marshall_int(s, dimx) < 0 )
fprintf(stderr, "proto_server_mt_dim_handler: "
"proto_session_body_marshall_bytes failed\n");
if (proto_session_body_marshall_int(s, dimy) < 0 )
fprintf(stderr, "proto_server_mt_dim_handler: "
"proto_session_body_marshall_bytes failed\n");
rc = proto_session_send_msg(s, 1);
// TODO: return failed if an error occours
return rc;
}
static int
do_join_game_rpc(Proto_Client_Handle ch, Proto_Msg_Types mt)
{
int rc, X, Y, ii, size;
Proto_Session *s;
Proto_Client *c = ch;
Proto_Msg_Hdr h;
if (proto_debug())
fprintf(stderr, "do_join_game_rpc started.\n");
// prepare msessage
s = &(c->rpc_session);
bzero(&h, sizeof(h));
h.type = mt;
proto_session_hdr_marshall(s, &h);
if (proto_debug())
fprintf(stderr, "do_move_rpc:\n pId: %d\n", playerdata.id);
if (proto_session_body_marshall_int(s, playerdata.id) < 0)
fprintf(stderr, "do_join_game_rpc: proto_session_body_marshall_int failed. "
"Not enough available sbufer space\n");
// sned message
rc = proto_session_rpc(s);
// process reply: pID, xdim, ydim, maze
if (rc == 1)
{
proto_session_hdr_unmarshall(s, &h);
if (proto_session_body_unmarshall_int(s, 0, &rc) < 0)
fprintf(stderr, "do_join_game_rpc: proto_session_body_unmarshall_int failed\n");
if (rc < 0)
{
if (proto_debug())
fprintf(stderr, "do_join_game_rpc: returned player id = %d\n", rc);
return rc;
}
if (proto_session_body_unmarshall_int(s, sizeof(int), &X) < 0)
fprintf(stderr, "do_join_game_rpc: proto_session_body_unmarshall_int failed\n");
if (proto_session_body_unmarshall_int(s, 2*sizeof(int), &Y) < 0)
fprintf(stderr, "do_join_game_rpc: proto_session_body_unmarshall_int failed\n");
pthread_mutex_lock(&client_data_mutex);
if ( gamedata.game_version == 0 )
{
// initialize game version and state
playerdata.id = rc;
gamedata.game_state = h.gstate.v0.raw;
gamedata.game_version = h.sver.raw;
themaze.rows = Y;
themaze.columns = X;
size = X*Y;
themaze.maze = (char*) malloc( size*sizeof(char) + 1 );
themaze.cell_version = (unsigned long long*) malloc(size*sizeof(unsigned long long));
if (proto_session_body_unmarshall_bytes(s, 3*sizeof(int), size, themaze.maze) < 0)
fprintf(stderr, "do_join_game_rpc: proto_session_body_unmarshall_bytes failed\n");
for (ii = 0; ii < size; ii++)
themaze.cell_version[ii] = h.sver.raw;
themaze.maze[X*Y] = 0;
if (proto_debug())
fprintf(stderr, "do_join_game_rpc: unmarshalled response\n"
" game version = %llu\n trs=%llu\n game state = %d\n player id = %d\n"
" dimx = %d\n dimy = %d\n", h.sver.raw, h.gstate.v1.raw, h.gstate.v0.raw, rc, X, Y);
}
else
fprintf(stderr, "do_join_game_rpc: WARNING: gamedata had been initialized before\n");
pthread_mutex_unlock(&client_data_mutex);
}
else
{
c->session_lost_handler(s);
close(s->fd);
}
return rc;
}
static int
proto_server_hello_handler(Proto_Session *s){
int rc = 1;
int x;
Player* p;
Proto_Msg_Hdr sh;
Proto_Session *us;
p = player_create();
bzero(&sh, sizeof(sh));
sh.type = proto_session_hdr_unmarshall_type(s);
sh.type += PROTO_MT_REP_BASE_RESERVED_FIRST;
x = player_find_empty_home(p,nextTeam, Server_ObjectMap, pidx);
// x = !gamefull;
if(x){
gamestate_add_player(Server_Gamestate,p);
printf("New player joining:\n");
printf("Location: %d,%d\n", p->pcell->x, p->pcell->y);
player_dump(p);
sh.pstate.v0.raw = 1;
sh.pstate.v1.raw = p->id;
gamestate_dump(Server_Gamestate);
proto_session_body_marshall_gamestate(s,Server_Gamestate);
// proto_session_body_marshall_map(s,Server_Map);
if(nextTeam == TEAM1){
nextTeam = TEAM2;
numPlayers1++;
} else{
nextTeam = TEAM1;
numPlayers2++;
}
pidx = player_find_next_id(Server_Gamestate->plist);
if(pidx<0)
gamefull = 1;
s->player = p;
} else {
sh.pstate.v0.raw = 0;
}
proto_session_hdr_marshall(s, &sh);
// proto_dump_msghdr(&(s->shdr));
rc = proto_session_send_msg(s,1);
if(x){ //if new player joining, tell everyone
us = proto_server_event_session();
bzero(&sh, sizeof(sh));
sh.type = PROTO_MT_EVENT_BASE_PLAYER_JOIN;
sh.pstate.v0.raw = p->id;
sh.pstate.v1.raw = p->pcell->x;
sh.pstate.v2.raw = p->pcell->y;
proto_session_hdr_marshall(us, &sh);
proto_session_body_marshall_player(us,p);
proto_server_post_event();
}
return rc;
}
static int
proto_server_move_handler(Proto_Session *s){
int i,rx,ry,id,rc, winner;
dir_t dir;
Cell *cell = malloc(sizeof(Cell));
Proto_Msg_Hdr sh;
Proto_Msg_Hdr rh;
Player* p;
Proto_Session *us;
int valid;
int flagindex;
object_t flag = -1;
Proto_Session *fs;
bzero(&sh, sizeof(sh));
bzero(&rh, sizeof(rh));
sh.type = proto_session_hdr_unmarshall_type(s);
sh.type += PROTO_MT_REP_BASE_RESERVED_FIRST;
proto_session_hdr_unmarshall(s, &rh);
id = rh.pstate.v0.raw;
dir = rh.pstate.v1.raw;
p = gamestate_get_player(Server_Gamestate,id);
valid = 0;
flagindex = -1;
valid = player_move(dir,p,Server_ObjectMap, Server_Gamestate);
// printf("Valid bit%d\n", valid);
if (valid>0) {
sh.pstate.v3.raw = 1;
printf("Player %d is moving to (%d,%d)\n",id,p->pcell->x,p->pcell->y);
if(!DEBUG_MAP){
flagindex = objectmap_flag_visible(p,Server_ObjectMap);
if(flagindex>=0)
flag = Server_ObjectMap->objects[flagindex]->obj;
if(flag == FLAG1){
if(!flag1found)
flag1found = 1;
else
flagindex = -1;
}
if(flag == FLAG2){
if(!flag2found)
flag2found = 1;
else
flagindex = -1;
}
}
} else {
sh.pstate.v3.raw = 0;
printf("Player %d attemped an invalid move\n",id);
}
sh.pstate.v0.raw = p->id;
sh.pstate.v1.raw = p->pcell->x;
sh.pstate.v2.raw = p->pcell->y;
proto_session_hdr_marshall(s, &sh);
rc = proto_session_send_msg(s,1);
if(valid){
us = proto_server_event_session();
sh.type = PROTO_MT_EVENT_BASE_MOVE;
proto_session_hdr_marshall(us,&sh);
proto_server_post_event();
}
bzero(&sh, sizeof(sh));
if(flagindex>=0){
fs = proto_server_event_session();
sh.type = PROTO_MT_EVENT_BASE_FLAG;
//gstate.v0 holds the flag itself
//gstate.v1 holds the index in the objectmap where that flag is located
sh.gstate.v0.raw = Server_ObjectMap->objects[flagindex]->obj;
sh.gstate.v1.raw = flagindex;
proto_session_hdr_marshall(fs,&sh);
proto_server_post_event();
}
bzero(&sh, sizeof(sh));
if((winner = gamestate_team_wins()) >= 0){
sh.type = PROTO_MT_EVENT_BASE_WIN;
sh.gstate.v0.raw = winner;
proto_session_hdr_marshall(fs,&sh);
proto_server_post_event();
}
return rc;
}