예제 #1
0
void
proto_server_post_event(void)
{
    int i;
    int num;

    pthread_mutex_lock(&Proto_Server.EventSubscribersLock);

    i = 0;
    num = Proto_Server.EventNumSubscribers;
    while (num > 0)
    {
        Proto_Server.EventSession.fd = Proto_Server.EventSubscribers[i];
        if (Proto_Server.EventSession.fd != -1)
        {
            num--;
            if (proto_session_send_msg(&Proto_Server.EventSession, 0) < 0)
            {
                // must have lost an event connection
                close(Proto_Server.EventSession.fd);
                Proto_Server.EventSubscribers[i] = -1;
                Proto_Server.EventNumSubscribers--;
                Proto_Server.session_lost_handler(&Proto_Server.EventSession);
            }
            // FIXME: add ack message here to ensure that game is updated
            // correctly everywhere... at the risk of making server dependent
            // on client behaviour  (use time out to limit impact... drop
            // clients that misbehave but be carefull of introducing deadlocks
        }
        i++;
    }
    proto_session_reset_send(&Proto_Server.EventSession);
    pthread_mutex_unlock(&Proto_Server.EventSubscribersLock);
}
예제 #2
0
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;
}
예제 #3
0
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;
}
예제 #4
0
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;
}
예제 #5
0
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;
}
예제 #6
0
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;
}
예제 #7
0
extern int
proto_session_rpc(Proto_Session *s){
  int rc=0;
  
  proto_session_send_msg(s, 1);
  rc = proto_session_rcv_msg(s);

  return rc;
}
예제 #8
0
extern int
proto_session_rpc(Proto_Session *s)
{
    int rc;
    
    rc = proto_session_send_msg(s,1);
    if (rc==1) {
        rc = proto_session_rcv_msg(s);
    }
    return rc;
}
예제 #9
0
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;
}
예제 #10
0
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);
}
예제 #11
0
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;
}
예제 #12
0
extern int
proto_session_rpc(Proto_Session *s)
{
  int rc;  
  // HACK
  // fprintf(stderr, "Sent bytes:\n", );
  // print_mem(&s->shdr, sizeof(Proto_Msg_Hdr));

  rc = proto_session_send_msg(s, 0);
  rc = proto_session_rcv_msg(s);


  // fprintf(stderr, "Rcv msg returns : %d\n", rc);

  return rc;
}
예제 #13
0
extern int
proto_session_rpc(Proto_Session *s) 
{
   int rc;

   if (proto_session_send_msg(s, 1) != -1)
   {
      rc = proto_session_rcv_msg(s);
   }
   else
   {
      rc = -1;
   }

   return rc;
}
예제 #14
0
//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;
}
예제 #15
0
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;
}
extern int
proto_session_rpc(Proto_Session *s) {
    int rc;

    // ADD CODE
    int n1;
    int n2;
    n1 = proto_session_send_msg(s, 1);
    if (n1 != 1) {
        printf("prote_session_rpc error: sending messge");
        return -1;
    }
    n2 = proto_session_rcv_msg(s);

    if (n2 == 1)
        rc = 1;
    else
        rc = -1;

    return rc;
}
예제 #17
0
//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;
}
예제 #18
0
//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*)&current);
      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;
}
예제 #19
0
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;
}
예제 #20
0
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;
}
예제 #21
0
void
proto_server_post_event(void){
  int i;
  int num;

  pthread_mutex_lock(&Proto_Server.EventSubscribersLock);

  i = 0;
  num = Proto_Server.EventNumSubscribers;

  while (num) {
    Proto_Server.EventSession.fd = Proto_Server.EventSubscribers[i];
    if (Proto_Server.EventSession.fd != -1) {
      num--;
      
      if (proto_session_send_msg(&(Proto_Server.EventSession),0)<0) {

	printf("Lost a connection.\n");

	// must have lost an event connection
	close(Proto_Server.EventSession.fd);
	Proto_Server.EventSubscribers[i]=-1;
	Proto_Server.EventNumSubscribers--;
	//	NYI; //Proto_Server.ADD CODE
	//I Have no idea^^ -B 4/24/13
	// may have to issue a remove player for this subscriber...-chris 4/24/13
      } 
      // FIXME: add ack message here to ensure that game is updated 
      // correctly everywhere... at the risk of making server dependent
      // on client behaviour  (use time out to limit impact... drop
      // clients that misbehave but be carefull of introducing deadlocks
    }
    i++;  }
  proto_session_reset_send(&Proto_Server.EventSession);
  pthread_mutex_unlock(&Proto_Server.EventSubscribersLock);
}
예제 #22
0
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;
}
예제 #23
0
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;
}