예제 #1
0
extern int
proto_client_move(Proto_Client_Handle ch, Player_Move direction)
{
  int rc = 1, offset = 0;
  Proto_Session *s;
  Proto_Client *c = ch;
  s = &(c->rpc_session);

  //printf("Sending move command to server...\n\n");


  marshall_mtonly(s, PROTO_MT_REQ_BASE_MOVE);
  player_marshall(s, ClientGameState.me);
  proto_session_body_marshall_int(s, direction);

  rc = proto_session_rpc(s);

  if (rc != 1)
  {
	  c->session_lost_handler(s);
	  return rc;
  }
  else
  {
	offset = proto_session_body_unmarshall_int(s, 0, &rc);
	player_unmarshall(s, offset, ClientGameState.me);
  }

  if (rc < 0) printf("player move Error!\n");
  // else if (rc == 0) printf("player move rejected by server!\n");
//  else printf("Player move successful.\n");
  return rc;

}
예제 #2
0
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;
}
예제 #3
0
static int
do_dump_rpc(Proto_Client_Handle ch, Proto_Msg_Types mt)
{
    int rc;
    Proto_Session *s;
    Proto_Client *c = ch;

    if (proto_debug())
       fprintf(stderr, "do_dump_rpc \n");

    s = &(c->rpc_session);
    marshall_mtonly(s, mt);
    rc = proto_session_rpc(s);

    if (rc == 1)
    {
        proto_session_body_unmarshall_int(s, 0, &rc);
    }
    else
    {
        c->session_lost_handler(s);
        close(s->fd);
    }
    return rc;
}
예제 #4
0
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;
}
예제 #5
0
extern int
proto_client_pickup_shovel(Proto_Client_Handle ch) {
  int rc, offset;
  Player *p = ClientGameState.me;
  Proto_Session *s;
  Proto_Client *c = ch;

  s = &(c->rpc_session);
  marshall_mtonly(s, PROTO_MT_REQ_BASE_PICKUP_SHOVEL);
  player_marshall(s,p);

  rc = proto_session_rpc(s);  

  if (rc != 1)
  {
        c->session_lost_handler(s);
	return rc;
  }
  else
  {
	offset = proto_session_body_unmarshall_int(s, 0, &rc);
	player_unmarshall(s, offset, ClientGameState.me);
  }

  return rc;
}
예제 #6
0
// 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;
}
예제 #7
0
extern int
proto_client_drop_flag(Proto_Client_Handle ch) {
  Player *p = ClientGameState.me;
  int rc, offset;
  Proto_Session *s;
  Proto_Client *c = ch;

  s = &(c->rpc_session);
  marshall_mtonly(s, PROTO_MT_REQ_BASE_DROP_FLAG);
  player_marshall(s,p);

  rc = proto_session_rpc(s);  

  if (rc != 1)
  {
        c->session_lost_handler(s);
	return rc;
  }
  else
  {
	offset = proto_session_body_unmarshall_int(s, 0, &rc);
	player_unmarshall(s, offset, ClientGameState.me);
  }

  return rc;
}
예제 #8
0
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;
}
예제 #9
0
extern int
proto_client_cell_info(Proto_Client_Handle ch, int x, int y, int * buf) {
  int team, oc, rc;
  char cell_type;
  Proto_Session *s;
  Proto_Client *c = ch;

  s = &(c->rpc_session);
  marshall_mtonly(s, PROTO_MT_REQ_BASE_GET_CELL_INFO);
  proto_session_body_marshall_int(s, x);
  proto_session_body_marshall_int(s, y);
  rc = proto_session_rpc(s);

  if (rc == 1) {
    proto_session_body_unmarshall_char(s, 0, &cell_type);
    if(cell_type == 'i')
      return -1;
    proto_session_body_unmarshall_int(s, sizeof(char), &team);
    proto_session_body_unmarshall_int(s, sizeof(char) + sizeof(int), &oc);

    buf[0] = (int)cell_type;
    buf[1] = team;
    buf[2] = oc;
  }

  else
    c->session_lost_handler(s);

  return rc;
}
예제 #10
0
// all rpc's are assume to only reply only with a return code in the body
// eg.  like the null_mes
static int
do_generic_dummy_rpc(Proto_Client_Handle ch, Proto_Msg_Types mt)
{
    int rc;
    Proto_Session *s;
    Proto_Client *c = ch;

    s = &(c->rpc_session);
    // marshall

    marshall_mtonly(s, mt);
    rc = proto_session_rpc(s);

    if (rc == 1)
    {
        proto_session_body_unmarshall_int(s, 0, &rc);
    }
    else
    {
        c->session_lost_handler(s);
        close(s->fd);
    }

    return rc;
}
예제 #11
0
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;
}
예제 #12
0
extern int
proto_client_hello(Proto_Client_Handle ch)
{
  int i = 0, rc = 1, offset = 0;
  Proto_Session *s;
  Proto_Client *c = ch;
  s = &(c->rpc_session);

  printf("Loading...\n\n");

  marshall_mtonly(s, PROTO_MT_REQ_BASE_HELLO);
  proto_session_body_marshall_int(s,i);
 
  rc = proto_session_rpc(s);
  
  if (rc == 1) 
    maze_unmarshall_row(s, offset, i);
  else
    c->session_lost_handler(s);
  
  if (Board.size / 20 > 0) {
    for (i = 1; i < Board.size / 20; i++) {
  
      proto_session_reset_send(s);
      marshall_mtonly(s, PROTO_MT_REQ_BASE_HELLO);
      proto_session_body_marshall_int(s,i);
      rc = proto_session_rpc(s);
      
      if (rc == 1)
	  maze_unmarshall_row(s, 0, i);
      else
	  c->session_lost_handler(s);
    }
  }
  //dump(); 

  return i;
}
예제 #13
0
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;
}
예제 #14
0
extern int
proto_client_dump_maze(Proto_Client_Handle ch) {
  int rc;
  Proto_Session *s;
  Proto_Client *c = ch;

  s = &(c->rpc_session);
  marshall_mtonly(s, PROTO_MT_REQ_BASE_DUMP);
  rc = proto_session_rpc(s);

  if (rc == 1)
    proto_session_body_unmarshall_int(s, 0, &rc);
  else
    c->session_lost_handler(s);

  return rc;
}
예제 #15
0
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;
}
예제 #16
0
extern int
proto_client_new_player(Proto_Client_Handle ch, int * id)
{
  int rc = 1, offset = 0;
  Proto_Session *s;
  Proto_Client *c = ch;
  Player clientPlayer;
  memset(&clientPlayer, '\0', sizeof(clientPlayer));
  s = &(c->rpc_session);

  //printf("Requesting to create a new player...\n\n");

  marshall_mtonly(s, PROTO_MT_REQ_BASE_NEW_PLAYER);

  rc = proto_session_rpc(s);
  
  if (rc != 1)
  {
	  printf("new player rpc returned -1\n");
	  c->session_lost_handler(s);
	  return rc;
  }
  else 
  {

    rc = player_unmarshall(s,0, &clientPlayer);
    *id = clientPlayer.fd;
   
    // put the client player in it's proper place based on team and id.
    player_copy(&(ClientGameState.players[clientPlayer.team][clientPlayer.id]),&clientPlayer);
    
    //player_dump(&(ClientGameState.players[clientPlayer.team][clientPlayer.id]));
    // set the ClientGameState.me pointer to this address. This is where our player will
    // be unmarshalled from now on, with every update from the server.
    ClientGameState.me = &(ClientGameState.players[clientPlayer.team][clientPlayer.id]);
    
    //player_dump(ClientGameState.me);
  }

  //printf("new player id = %d, team = %d\n",p->id,p->team);

  if (rc < 0) printf("Player_unmarshall Error!\n");
  return rc;

}
예제 #17
0
extern int
proto_client_maze_info(Proto_Client_Handle ch, char type) {
  int rc;
  Proto_Session *s;
  Proto_Client *c = ch;

  s = &(c->rpc_session);
  marshall_mtonly(s, PROTO_MT_REQ_BASE_GET_MAZE_INFO);
  proto_session_body_marshall_char(s, type);
  rc = proto_session_rpc(s);

  if (rc == 1)
    proto_session_body_unmarshall_int(s, 0, &rc);
  else
    c->session_lost_handler(s);

  return rc;
}
예제 #18
0
extern int 
proto_client_goodbye(Proto_Client_Handle ch, int id, Player * p)
{
  int rc;
  Proto_Session *s;
  Proto_Client *c = ch;

  s = &(c->rpc_session);
  marshall_mtonly(s, PROTO_MT_REQ_BASE_GOODBYE);

  proto_session_body_marshall_int(s,id);
  player_marshall(s,p);

  rc = proto_session_rpc(s);

  close(&(c->rpc_session.fd)); 
  close(&(c->event_session.fd));

  return rc;
}
예제 #19
0
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;
}
예제 #20
0
static int
do_generic_dummy_rpc(Proto_Client_Handle ch, Proto_Msg_Types mt){
  int rc;
  Proto_Session *s;
  Proto_Client *c = ch;

  s = &(c->rpc_session);  

  marshall_mtonly(s, mt);

  rc = proto_session_rpc(s);

  if (rc==1) {
    if(mt == PROTO_MT_REQ_BASE_HELLO){
      proto_session_hdr_unmarshall(s,&s->rhdr);
    } else
      proto_session_body_unmarshall_int(s, 0, &rc);
  } else {
    c->session_lost_handler(s);
  }

  return rc;
}
예제 #21
0
static int
do_leave_game_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_leave_rpc\n");

    s = &(c->rpc_session);
    bzero(&h, sizeof(h));

    marshall_mtonly(s, mt);
    rc = proto_session_rpc(s);

    if (rc == 1)
    {
        proto_session_hdr_unmarshall(s, &h);
        wait_for_event(h.sver.raw); // i dont think I need it here

        if (proto_session_body_unmarshall_int(s, 0, &rc) < 0)
            fprintf(stderr, "do_leave_game: proto_session_body_unmarshall_int failed\n");
        if (proto_debug())
            fprintf(stderr, "do_leave_game: 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;
}
예제 #22
0
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;
}