예제 #1
0
Test(Player, create)
{
	player_t *pl = player_create();

	cr_assert(pl);
	player_delete(pl);
}
예제 #2
0
Test(Player, inventory_list_gfx)
{
	player_t *pl = player_create_at((vector2d_t){4, 7});

	player_inventory_add(pl, FOOD);
	dynbuf_t *buf = player_inventory_list(pl);
	cr_log_info(buf->b_data);
	cr_expect_neq(strstr(buf->b_data, "food 1"), 0);
	dynbuf_delete(buf);

	player_inventory_add(pl, FOOD);
	buf = player_inventory_list(pl);
	cr_log_info(buf->b_data);
	cr_expect_neq(strstr(buf->b_data, "food 2"), 0);
	dynbuf_delete(buf);

	player_inventory_add(pl, SIBUR);
	player_inventory_add(pl, SIBUR);
	player_inventory_add(pl, SIBUR);
	player_inventory_add(pl, SIBUR);
	buf = player_inventory_list_gfx(pl);
	cr_log_info(buf->b_data);
	cr_assert_str_eq(buf->b_data, "2 0 0 4 0 0 0");
	dynbuf_delete(buf);

	player_delete(pl);
}
예제 #3
0
Test(Player, inv_add)
{
	player_t *pl = player_create();

	cr_assert(pl);
	player_inventory_add(pl, FOOD);
	player_inventory_add(pl, FOOD);
	player_inventory_add(pl, FOOD);
	player_inventory_add(pl, FOOD);
	player_inventory_add(pl, FOOD);
	player_inventory_add(pl, FOOD);
	player_inventory_add(pl, FOOD);
	player_inventory_add(pl, FOOD);
	player_inventory_add(pl, FOOD);
	player_inventory_add(pl, FOOD);
	cr_expect_eq(player_inventory_get(pl, FOOD), 10);

	player_inventory_add(pl, SIBUR);
	player_inventory_add(pl, THYSTAME);
	player_inventory_add(pl, THYSTAME);
	player_inventory_add(pl, THYSTAME);
	player_inventory_add(pl, THYSTAME);
	player_inventory_add(pl, DERAUMERE);
	player_inventory_add(pl, DERAUMERE);
	cr_expect_eq(player_inventory_get(pl, FOOD), 10);
	cr_expect_eq(player_inventory_get(pl, SIBUR), 1);
	cr_expect_eq(player_inventory_get(pl, THYSTAME), 4);
	cr_expect_eq(player_inventory_get(pl, DERAUMERE), 2);
	player_delete(pl);
}
예제 #4
0
파일: script.c 프로젝트: metiscus/memoria
static sexp sexp_player_delete_stub (sexp ctx, sexp self, sexp_sint_t n, sexp arg0) {
  sexp res;
  if (! (sexp_pointerp(arg0) && (sexp_pointer_tag(arg0) == sexp_unbox_fixnum(sexp_opcode_arg1_type(self)))))
    return sexp_type_exception(ctx, self, sexp_unbox_fixnum(sexp_opcode_arg1_type(self)), arg0);
  res = ((player_delete((struct player**)sexp_cpointer_value(arg0))), SEXP_VOID);
  return res;
}
예제 #5
0
파일: game.c 프로젝트: xymostech/FPSGame
void terminate() {
	player_delete(my_player);
	world_delete(my_world);
	hud_delete(my_hud);
	
	server_disconnect(my_server);
	server_delete(my_server);
}
예제 #6
0
파일: player.c 프로젝트: rsenn/tichu
/* -------------------------------------------------------------------------- *
 * -------------------------------------------------------------------------- */
void player_clear(void) 
{
  struct player *player;
  struct node *next;
  
  dlink_foreach_safe(&player_list, player, next)
    player_delete(player);
} 
예제 #7
0
Test(Player, MoveUp)
{
	player_t *pl = player_create_at((vector2d_t){12, 12});
	board_t *bd = board_create(24, 24);

	pl->p_dir = (vector2d_t){0, -1};
	cr_assert_eq(pl->p_pos.v_y, 12);
	cr_assert_eq(pl->p_pos.v_x, 12);
	player_move_foward(pl, bd);
	cr_assert_eq(pl->p_pos.v_y, 11);
	cr_assert_eq(pl->p_pos.v_x, 12);
	player_move_foward(pl, bd);
	cr_assert_eq(pl->p_pos.v_y, 10);
	cr_assert_eq(pl->p_pos.v_x, 12);
	player_move_foward(pl, bd);
	cr_assert_eq(pl->p_pos.v_y, 9);
	cr_assert_eq(pl->p_pos.v_x, 12);
	player_move_foward(pl, bd);
	cr_assert_eq(pl->p_pos.v_y, 8);
	cr_assert_eq(pl->p_pos.v_x, 12);
	player_move_foward(pl, bd);
	cr_assert_eq(pl->p_pos.v_y, 7);
	cr_assert_eq(pl->p_pos.v_x, 12);
	player_move_foward(pl, bd);
	cr_assert_eq(pl->p_pos.v_y, 6);
	cr_assert_eq(pl->p_pos.v_x, 12);
	player_move_foward(pl, bd);
	cr_assert_eq(pl->p_pos.v_y, 5);
	cr_assert_eq(pl->p_pos.v_x, 12);
	player_move_foward(pl, bd);
	cr_assert_eq(pl->p_pos.v_y, 4);
	cr_assert_eq(pl->p_pos.v_x, 12);
	player_move_foward(pl, bd);
	cr_assert_eq(pl->p_pos.v_y, 3);
	cr_assert_eq(pl->p_pos.v_x, 12);
	player_move_foward(pl, bd);
	cr_assert_eq(pl->p_pos.v_y, 2);
	cr_assert_eq(pl->p_pos.v_x, 12);
	player_move_foward(pl, bd);
	cr_assert_eq(pl->p_pos.v_y, 1);
	cr_assert_eq(pl->p_pos.v_x, 12);
	player_move_foward(pl, bd);
	cr_assert_eq(pl->p_pos.v_y, 0);
	cr_assert_eq(pl->p_pos.v_x, 12);
	player_move_foward(pl, bd);
	cr_assert_eq(pl->p_pos.v_y, 23, "got %d", pl->p_pos.v_y);
	cr_assert_eq(pl->p_pos.v_x, 12);
	player_move_foward(pl, bd);
	cr_assert_eq(pl->p_pos.v_y, 22);
	cr_assert_eq(pl->p_pos.v_x, 12);
	player_move_foward(pl, bd);
	cr_assert_eq(pl->p_pos.v_y, 21);
	cr_assert_eq(pl->p_pos.v_x, 12);

	board_delete(bd);
	player_delete(pl);
}
예제 #8
0
파일: login.c 프로젝트: gefla/empserver
/*ARGSUSED*/
void
player_login(void *ud)
{
    time_t deadline;
    char buf[128];
    char space[128];
    int res, ac, cmd, prev_state;

    player->proc = empth_self();

    pr_id(player, C_INIT, "Empire server ready\n");

    for (;;) {
        deadline = player_io_deadline(player, 0);
        if (io_outputwaiting(player->iop)) {
            if (io_output(player->iop, deadline) <= 0)
                break;
            continue;
        }
        if (io_gets(player->iop, buf, sizeof(buf)) < 0) {
            res = io_input(player->iop, deadline);
            if (res <= 0)
                break;
            continue;
        }
        journal_input(buf);
        ac = parse(buf, space, player->argp, NULL, NULL, NULL);
        if (ac <= 0) {
            pr_id(player, C_BADCMD, "Can't parse command\n");
            continue;
        }
        cmd = comtch(player->argp[0], login_coms, 0);
        if (cmd < 0) {
            pr_id(player, C_BADCMD, "Command %s not found\n", player->argp[0]);
            continue;
        }
        switch (login_coms[cmd].c_addr()) {
        case RET_OK:
            break;
        case RET_FAIL:
            break;
        case RET_SYN:
            pr_id(player, C_BADCMD, "Usage %s\n", login_coms[cmd].c_form);
            break;
        default:
            break;
        }
    }
    prev_state = player->state;
    player->state = PS_SHUTDOWN;
    if (prev_state == PS_PLAYING)
        empth_rwlock_unlock(shutdown_lock);
    pr_id(player, C_EXIT, "so long...\n");
    player_delete(player);
    empth_exit();
    /*NOTREACHED*/
}
예제 #9
0
Test(Player, eject)
{
	player_t *pl1 = player_create_at((vector2d_t){9, 9});
	player_t *pl2 = player_create_at((vector2d_t){9, 9});
	player_t *pl3 = player_create_at((vector2d_t){9, 9});
	player_t *pl4 = player_create_at((vector2d_t){9, 15});
	game_t *gm = game_create(20, 20, 7, 5);

	cr_assert(pl1);
	cr_assert(pl2);
	cr_assert(pl2);
	cr_assert(gm);
	game_add_team(gm, "pandas");
	game_add_team(gm, "red-pandas");
	pl1->p_teamname = strdup("pandas");
	pl3->p_teamname = strdup("pandas");
	pl2->p_teamname = strdup("red-pandas");
	pl4->p_teamname = strdup("red-pandas");
	cr_assert_neq(game_register_player(gm, pl1), -1);
	cr_assert_neq(game_register_player(gm, pl2), -1);
	cr_assert_neq(game_register_player(gm, pl3), -1);
	cr_assert_neq(game_register_player(gm, pl4), -1);

	pl2->p_dir = (vector2d_t){-1, 0};

	player_eject(pl1, gm->ga_players, gm->ga_board);

	cr_expect_eq(pl2->p_pos.v_x, 8);
	cr_expect_eq(pl2->p_pos.v_y, 9);
	cr_expect_eq(pl3->p_pos.v_x, 10);
	cr_expect_eq(pl3->p_pos.v_y, 9);

	player_eject(pl1, gm->ga_players, gm->ga_board);
	cr_expect_eq(pl2->p_pos.v_x, 8);
	cr_expect_eq(pl2->p_pos.v_y, 9);
	cr_expect_eq(pl3->p_pos.v_x, 10);
	cr_expect_eq(pl3->p_pos.v_y, 9);

	player_delete(pl1);
	player_delete(pl2);
	player_delete(pl3);
	game_delete(gm);
}
예제 #10
0
Test(Player, Move)
{
	player_t *pl = player_create_at((vector2d_t){12, 12});
	board_t *bd = board_create(24, 24);

	cr_assert_eq(pl->p_pos.v_x, 12);
	cr_assert_eq(pl->p_pos.v_y, 12);
	player_move_foward(pl, bd);
	cr_assert_eq(pl->p_pos.v_x, 13);
	cr_assert_eq(pl->p_pos.v_y, 12);
	player_move_foward(pl, bd);
	cr_assert_eq(pl->p_pos.v_x, 14);
	cr_assert_eq(pl->p_pos.v_y, 12);
	player_move_foward(pl, bd);
	cr_assert_eq(pl->p_pos.v_x, 15);
	cr_assert_eq(pl->p_pos.v_y, 12);
	player_move_foward(pl, bd);
	cr_assert_eq(pl->p_pos.v_x, 16);
	cr_assert_eq(pl->p_pos.v_y, 12);
	player_move_foward(pl, bd);
	cr_assert_eq(pl->p_pos.v_x, 17);
	cr_assert_eq(pl->p_pos.v_y, 12);
	player_move_foward(pl, bd);
	cr_assert_eq(pl->p_pos.v_x, 18);
	cr_assert_eq(pl->p_pos.v_y, 12);
	player_move_foward(pl, bd);
	cr_assert_eq(pl->p_pos.v_x, 19);
	cr_assert_eq(pl->p_pos.v_y, 12);
	player_move_foward(pl, bd);
	cr_assert_eq(pl->p_pos.v_x, 20);
	cr_assert_eq(pl->p_pos.v_y, 12);
	player_move_foward(pl, bd);
	cr_assert_eq(pl->p_pos.v_x, 21);
	cr_assert_eq(pl->p_pos.v_y, 12);
	player_move_foward(pl, bd);
	cr_assert_eq(pl->p_pos.v_x, 22);
	cr_assert_eq(pl->p_pos.v_y, 12);
	player_move_foward(pl, bd);
	cr_assert_eq(pl->p_pos.v_x, 23);
	cr_assert_eq(pl->p_pos.v_y, 12);
	player_move_foward(pl, bd);
	cr_assert_eq(pl->p_pos.v_x, 0);
	cr_assert_eq(pl->p_pos.v_y, 12);
	player_move_foward(pl, bd);
	cr_assert_eq(pl->p_pos.v_x, 1);
	cr_assert_eq(pl->p_pos.v_y, 12);
	player_move_foward(pl, bd);
	cr_assert_eq(pl->p_pos.v_x, 2);
	cr_assert_eq(pl->p_pos.v_y, 12);
	board_delete(bd);
	player_delete(pl);
}
예제 #11
0
파일: player.c 프로젝트: rsenn/tichu
/* -------------------------------------------------------------------------- *
 * Destroy game heaps and cancel timer.                                       *
 * -------------------------------------------------------------------------- */
void player_shutdown(void)
{
  struct player *player;
  struct node *next;
  
  log(player_log, L_status, "Shutting down [player] module...");

  dlink_foreach_safe(&player_list, player, next)
    player_delete(player);

  mem_static_destroy(&player_heap);
  
  log_source_unregister(player_log);
}
예제 #12
0
Test(Player, TurnLeft)
{
	player_t *pl = player_create_at((vector2d_t){12, 12});

	pl->p_dir = (vector2d_t){1, 0};
	player_turn_left(pl);
	cr_assert_eq(pl->p_dir.v_x, 0);
	cr_assert_eq(pl->p_dir.v_y, 1);
	player_turn_left(pl);
	cr_assert_eq(pl->p_dir.v_x, -1);
	cr_assert_eq(pl->p_dir.v_y, 0);
	player_turn_left(pl);
	cr_assert_eq(pl->p_dir.v_x, 0);
	cr_assert_eq(pl->p_dir.v_y, -1);
	player_turn_left(pl);
	cr_assert_eq(pl->p_dir.v_x, 1);
	cr_assert_eq(pl->p_dir.v_y, 0);
	player_delete(pl);
}
예제 #13
0
파일: accept.c 프로젝트: fstltna/empserver
/*ARGSUSED*/
void
player_accept(void *unused)
{
    static int conn_cnt;
    struct sockaddr *sap;
    struct player *np;
    socklen_t len;
    const char *p;
    int ns;
    int set = 1;
    int stacksize;
    char buf[128];
#ifdef RESOLVE_IPADDRESS
    struct hostent *hostp;
#endif

    /* auto sockaddr_storage would be simpler, but less portable */
    sap = malloc(player_addrlen);
    len = player_addrlen;
    if (getsockname(player_socket, sap, &len)) {
	logerror("getsockname() failed: %s", strerror(errno));
	p = NULL;
    } else {
	p = sockaddr_ntop(sap, buf, sizeof(buf));
	CANT_HAPPEN(!p);
    }
    logerror("Listening on %s", p ? buf : "unknown address");

    while (1) {
	empth_select(player_socket, EMPTH_FD_READ, NULL);
	len = player_addrlen;
	ns = accept(player_socket, sap, &len);
	/* FIXME accept() can block on some systems (RST after select() reports ready) */
	if (ns < 0) {
	    logerror("new socket accept");
	    continue;
	}
	(void)setsockopt(ns, SOL_SOCKET, SO_KEEPALIVE, &set, sizeof(set));
	np = player_new(ns);
	if (!np) {
	    logerror("can't create player for fd %d", ns);
	    close(ns);
	    continue;
	}
	if (!sockaddr_ntop(sap, np->hostaddr, sizeof(np->hostaddr))) {
	    CANT_REACH();
	    player_delete(np);
	    continue;
	}
	logerror("Connect from %s", np->hostaddr);
#ifdef RESOLVE_IPADDRESS
	hostp = gethostbyaddr(inaddr, player_addrlen, sap->sa_family);
	if (NULL != hostp)
	    strcpy(np->hostname, hostp->h_name);
#endif /* RESOLVE_IPADDRESS */
	/* FIXME ancient black magic; figure out true stack need */
	stacksize = 100000
/* budget */  + MAX(WORLD_SZ() * sizeof(int) * 7,
/* power */ MAXNOC * sizeof(struct powstr));
	sprintf(buf, "Conn%d", conn_cnt++);
	empth_create(player_login, stacksize, 0, buf, np);
    }
}
예제 #14
0
/*
	Read data from the network and work with it
*/
int
network_loop ()
{
    char data[MAX_UDPDATA];
    struct pkg *packet = (struct pkg *) data;
    int inlen,
      i;

    _net_addr addr;

    if (bman.state != GS_running && bman.state != GS_ready)
        timestamp = SDL_GetTicks ();

    /* 
       as long as we get any new data, work with them
     */
    inlen = udp_get (bman.sock, data, MAX_UDPDATA, &addr.sAddr, bman.net_ai_family);
    addr.port[0] = addr.host[0] = 0;
    if (inlen > 0)
        dns_filladdr (addr.host, LEN_SERVERNAME, addr.port, LEN_PORT, bman.net_ai_family,
                      &addr.sAddr);

    while (inlen > 0) {
        do_pkg (packet, &addr, inlen);

        //  printf ("Network : inlen (%d) typ (%d) Size (%d)\n", inlen, packet->typ, pkglen);
        inlen = udp_get (bman.sock, data, MAX_UDPDATA, &addr.sAddr, bman.net_ai_family);
        addr.port[0] = addr.host[0] = 0;
        if (inlen > 0)
            dns_filladdr (addr.host, LEN_SERVERNAME, addr.port, LEN_PORT,
                          bman.net_ai_family, &addr.sAddr);
    }

    /*
       check here for old connections who aren't answering
     */
    if (bman.state == GS_wait || bman.state == GS_ready || bman.state == GS_running) {
        if (GT_MP_PTPS) {
            if (net_check_timeout (bman.p_servnr)) {
                d_printf ("Server Timed Out\n");
                bman.state = GS_startup;
            }
        }
        else if (GT_MP_PTPM) {
            for (i = 1; i < MAX_PLAYERS; i++)
                if (i != bman.p_nr && net_check_timeout (i)) {
                    d_printf ("Player %d Timed Out\n", i);
                    player_delete (i);
                }
        }
    }

    /*
       resend_cache.... 
     */
    rscache_loop ();

    /*
       dynamic calibration of the network traffic option
     */
    net_dyn_pkgoption ();

    return 0;
};