void test_init_player(void)
{
printf("\ntest_init_player\n");
s_player p1, p2, p3, p4, p5;
int result;
result = init_player(&p1, 1, "my name 1", 1, STRATEGY_NONE, 10);
assert_int_equals(result, INIT_PLAYER_OK);
assert_str_equals(p1.name, "my name 1");
assert_int_equals(p1.id, 1);
assert_int_equals(p1.nb_cells, 0);
assert_int_equals(p1.nb_pawns, 10);
assert_int_equals(p1.strategy, STRATEGY_NONE);
assert_int_equals(p1.is_human, 1);
result = init_player(&p2, 2, "my name 2", 1, STRATEGY_OFFENCE, 10);
assert_int_equals(result, PLAYER_ERROR_INIT_PLAYER_STRATEGY);
result = init_player(&p3, 3, "my name 3", 0, STRATEGY_NONE, 10);
assert_int_equals(result, PLAYER_ERROR_INIT_PLAYER_STRATEGY);
result = init_player(&p4, 4, "my name 4", 0, STRATEGY_SPREAD, 10);
assert_int_equals(result, INIT_PLAYER_OK);
assert_str_equals(p4.name, "my name 4");
assert_int_equals(p4.id, 4);
assert_int_equals(p4.nb_cells, 0);
assert_int_equals(p4.nb_pawns, 10);
assert_int_equals(p4.strategy, STRATEGY_SPREAD);
assert_int_equals(p4.is_human, 0);
//~
result = init_player(&p5, 5, "", 1, STRATEGY_NONE, 10);
assert_int_equals(result, PLAYER_ERROR_INIT_PLAYER_EMPTY_NAME);
}
int init_board(board_t *board){
printf("[INIT]\n\tInitializing board...\n");
memset(board,0,sizeof(board_t));
board->turn_count = 1;
init_player(&board->players[0]);
init_player(&board->players[1]);
printf("\tBoard successfully initialized.\n[/INIT]\n");
return 0;
}
void init_board(struct board_t *board) {
int corr;
for(corr = 0; corr < 5; corr++) {
board->slot[0][corr].hp = 0;
board->slot[1][corr].hp = 0;
}
init_player(&board->pl[0]);
init_player(&board->pl[1]);
}
int main(int argc, char** argv)
{
#ifndef TARGET_ESC64
//disable line-buffering on stdin
struct termios old_tio, new_tio;
assert(!tcgetattr(STDIN_FILENO, &old_tio));
new_tio = old_tio;
new_tio.c_lflag &= (~ICANON & ~ECHO);
assert(!tcsetattr(STDIN_FILENO, TCSANOW, &new_tio));
#endif
for(;;)
{
fputs("\x1B[2J\x1B[H\x1B[?25l", stdout); //clear screen, cursor to home, cursor invis
player1.pos.x = 16;
player2.pos.x = 60;
//initialize / generate
gen_terrain();
init_player(&player1);
init_player(&player2);
curPlayer = &player1;
//draw
draw_static();
draw_terrain();
draw_player(&player1);
draw_player(&player2);
draw_stats(&player1);
draw_stats(&player2);
while(player1.hull > 0 && player2.hull > 0)
{
if(player_input()) { break; }
TERM_DRAWSTR(MSG_X, MSG_Y + 1, "shot fired");
shoot();
curPlayer = curPlayer == &player1 ? &player2 : &player1;
}
}
#ifndef TARGET_ESC64
//restore old settings line-buffering settings
//tcsetattr(STDIN_FILENO, TCSANOW, &old_tio);
#endif
//return 0;
}
// Programm Eintritt
int main(int argc, char *argv[])
{
int selected, points=0, width, height;
// Größe einstellen
switch(argc)
{
default:
width=DEFAULT_WIDTH;
height=DEFAULT_HEIGHT;
break;
case 2:
width=height=atoi(argv[1]);
break;
case 3:
width=atoi(argv[1]);
height=atoi(argv[2]);
break;
}
// STDOUT aufstellen
init_player();
init(points, width, height);
// Mainmenu zeigen und Spiel starten
do
{
selected=menu();
game_launch(&selected, &points);
} while(selected!='q');
return 0;
}
/**
* Init the players, between 2 and nb_max_players
*
* @return void
*/
void game_select_players(s_board *b, s_player *players, const uint8_t nb_max_players, const uint16_t nb_pawns_per_player)
{
int p;
p = 0;
char player_name[PLAYER_NAME_LEN];
char name_prompt[19], names_informations[96];
sprintf(names_informations, "Please select between 2 and %d players.\n\
Validate an empty name when you have enough players.", nb_max_players);
ui_info(names_informations);
while (p < nb_max_players) {
// @TODO loop on each player, ask if the player is an AI or a human
// @TODO ask for the player name and the strategy if AI
sprintf(name_prompt, "Name of player %d: ", p+1);
ui_prompt(name_prompt, player_name, (size_t) PLAYER_NAME_LEN);
if (strlen(player_name) > 0) {
init_player(&players[p], p+1, player_name, 1, STRATEGY_NONE, nb_pawns_per_player);
board_add_player(b, &players[p]);
p++;
}
else if (p >= 2) {
break;
}
}
}
int main()
{
t_board board;
SDL_Surface *ecran;
char *levelname;
if (SDL_Init(SDL_INIT_VIDEO) == -1)
{
xwrite(2, "SDL_INIT Error\n", 15);
exit(EXIT_FAILURE);
}
if ((levelname = getlevel()) != NULL)
get_map(&board, levelname);
else
return (1);
board.mobs = create_mobs(&board);
init_player(&board.player.ix, &board.player.iy, &board);
board.player.nb_life = 3;
ecran = xSDL_SetVideoMode(board.size * 30 , board.h * 30, 32,
SDL_HWSURFACE | SDL_DOUBLEBUF);
SDL_WM_SetCaption("Epikong", NULL);
board.ecran = ecran;
aff_board(&board, ecran);
play_the_game(&board);
return (0);
}
void start_replay(void *arg) {
ReplayStage *rstg;
StageInfo *gstg;
int i;
replay_copy(&global.replay, (Replay*)arg);
global.replaymode = REPLAY_PLAY;
if(global.replay.stgcount == 1)
pickedstage = 0;
init_player(&global.plr);
for(i = pickedstage; i < global.replay.stgcount; ++i) {
replay_select(&global.replay, i);
rstg = global.replay.current;
gstg = stage_get(rstg->stage);
if(!gstg) {
printf("start_replay(): Invalid stage %d in replay at %i skipped.\n", rstg->stage, i);
continue;
}
gstg->loop();
if(global.game_over == GAMEOVER_ABORT)
break;
global.game_over = 0;
}
global.game_over = 0;
global.replaymode = REPLAY_RECORD;
replay_destroy(&global.replay);
replayview->instantselect = False;
}
void init_lvl1()
{
init_UI();
init_player();
init_lvl1Graphics();
init_lvlOnePickups();
}
void test_cell_set_nb_pawns(void)
{
printf("\ntest_cell_set_nb_pawns\n");
s_cell c;
s_player p;
int result;
init_cell(&c, 1, 4);
init_player(&p, 1, "test", 1, STRATEGY_NONE, 10);
result = cell_set_nb_pawns(&c, 13);
assert_int_equals(result, CELL_ERROR_SET_PAWNS_NO_OWNER);
assert_int_equals(c.nb_pawns, 0);
cell_set_owner(&c, &p);
result = cell_set_nb_pawns(&c, 13);
assert_int_equals(result, CELL_ERROR_SET_PAWNS_NOT_ENOUGH_PAWNS);
assert_int_equals(c.nb_pawns, 0);
result = cell_set_nb_pawns(&c, 10);
assert_int_equals(result, CELL_SET_PAWNS_OK);
assert_int_equals(c.nb_pawns, 10);
free_cell(&c);
}
void setup_exchange_player_number(void)
{
struct PlayerInfo *player;
struct Packet *pckt;
int i,k;
SYNCDBG(6,"Starting");
clear_packets();
player = get_my_player();
pckt = get_packet_direct(my_player_number);
set_packet_action(pckt, PckA_InitPlayerNum, player->field_2C, settings.video_rotate_mode, 0, 0);
if (LbNetwork_Exchange(pckt))
ERRORLOG("Network Exchange failed");
k = 0;
for (i=0; i<NET_PLAYERS_COUNT; i++)
{
pckt = get_packet_direct(i);
if ((net_player_info[i].active) && (pckt->action == PckA_InitPlayerNum))
{
player = get_player(k);
player->id_number = k;
player->field_0 |= 0x01;
if (pckt->field_8 < 1)
player->field_4B5 = 2;
else
player->field_4B5 = 5;
player->field_2C = pckt->field_6;
init_player(player, 0);
strncpy(player->field_15,net_player[i].name,sizeof(struct TbNetworkPlayerName));
k++;
}
}
}
World *load_world(char *path) {
World *world = malloc(sizeof(*world));
struct parser_data *data = malloc(sizeof(*data));
data = parse(path);
/*int i;
for(i = 0; i < sizeof(data->nodes); i++) {
if((data->nodes[i].data[0] == NULL) || (strcmp(data->nodes[i].name, "") == 0)) {
break;
}
if((data->nodes[i].data[0] != NULL)) {
fprintf(stderr, "node: %d name: %s\n", i, data->nodes[i].name);
int j;
for(j = 0; j < sizeof(data->nodes[i].data); j++) {
if((data->nodes[i].data[j] == NULL) || (strcmp(data->nodes[i].data[j], "") == 0)) {
break;
}
fprintf(stderr, "data: %s\n", data->nodes[i].data[j]);
}
}
}*/
char *world_dir = malloc((strlen(path) - strlen("world_description.wd")) + strlen("landscape.png"));
strncpy(world_dir, path, strlen(path) - strlen("world_description.wd"));
strcat(world_dir, "landscape.png");
world->landscape = load_image(world_dir);
memset(world_dir, 0, strlen(world_dir));
world_dir = malloc((strlen(path) - strlen("world_description.wd")) + strlen("landscape.png"));
strncpy(world_dir, path, strlen(path) - strlen("world_description.wd"));
world->player = init_player(data, world_dir);
free(data);
return world;
}
t_return parse_argument(int ac, char **av,
t_player players[MAX_PLAYERS], t_env *env)
{
int i;
int curs_player;
i = 1;
curs_player = 0;
while (i < ac)
{
if (ft_strcmp(av[i], "-dump") == 0 && i + 1 == ac)
return (PERROR("missing arguement after -dump."));
else if (ft_strcmp(av[i], "-dump") == 0)
env->cycles_to_dump = ft_atoi(av[i++ + 1]);
else if (ft_strcmp(av[i], "-g") == 0)
env->graphics = 1;
else if (ft_strcmp(av[i], "-n") == 0 && i + 2 >= ac)
return (PERROR("missing champ file after -n."));
else if (ft_strcmp(av[i], "-n") == 0)
curs_player = ft_atoi(av[i++ + 1]) - 1;
else if (av[i][0] == '-')
return (PERROR("Invalid option."));
else if (init_player(players + curs_player, &curs_player, av[i])
== _ERR)
return (PERROR("init_player: error during creation."));
i++;
}
return (_SUCCESS);
}
/* add the recently connected client to the game as a player */
void join_player(struct socket_node *socket) {
struct packet_version packet;
struct packet_welcome packet2;
int i;
struct action_node *action;
struct socket_node *p;
socket->player = get_free_player();
init_player(socket->player, INIT_PLAYER_HUMAN);
/* send version */
packet.version = swap_int(PROGRAM_VERSION);
send_socket(socket, PACKET_VERSION, &packet, sizeof(struct packet_version));
/* send welcome */
packet2.player = swap_int(socket->player);
send_socket(socket, PACKET_WELCOME, &packet2, sizeof(struct packet_welcome));
/* send all previous players to the new client */
for (i = 0; i < NUM_PLAYERS; i++) {
if (IS_ACTIVE(i) && i != socket->player) {
send_player_info(socket, i, 0);
/* send any already selected action */
action = find_action(i, current_turn);
if (action && action->action != ACTION_NOTHING)
send_action(socket, i, current_turn);
}
}
/* send the new player to ALL clients */
for (p = socket_list; p != NULL; p = p->next) {
if (p->type == SOCKET_CLIENT)
send_player_info(p, socket->player, 1);
}
telegram("\n%s has\nconnected to the server.\n", GET_NAME(socket->player));
}
static void setup_players(void) {
n_players = 2;
players = malloc(n_players * sizeof(player_t));
init_player(&players[0], mkcolor(255, 0, 0));
players[0].keydefs[0] = KEYDEF(3, 0x10000000) /* right */;
players[0].keydefs[1] = KEYDEF(3, 0x40000000) /* up */;
players[0].keydefs[2] = KEYDEF(3, 0x08000000) /* left */;
players[0].keydefs[3] = KEYDEF(3, 0x20000000) /* down */;
init_player(&players[1], mkcolor(0, 255, 0));
players[1].keydefs[0] = KEYDEF(0, 0x00000002) /* s */;
players[1].keydefs[1] = KEYDEF(0, 0x00002000) /* w */;
players[1].keydefs[2] = KEYDEF(0, 0x00000001) /* a */;
players[1].keydefs[3] = KEYDEF(0, 0x00000040) /* z */;
}
int init(t_env* env)
{
init_env(env);
tputs(env->cl, 1, id_put);
init_shm(env);
init_cadre(env);
init_player(env);
return (0);
}
int player_born(t_game *game, int id_player, int team)
{
t_player *pl;
if (game->player == NULL)
{
init_player(game, id_player, team);
return (1);
}
pl = my_l_find(game->player, &team, find_player);
if (pl == NULL)
{
init_player(game, id_player, team);
return (1);
}
pl->player_id = id_player;
return (2);
}
void create_player(t_server *server, t_client *client)
{
t_player *player;
player = xmalloc(sizeof(t_player));
init_player(player, client->socket, client->team);
add_player(server, player, server->width, server->height);
player->client = client;
client->player = player;
}
void board_init(board_t *board) {
init_player(&board->p[P_ONE]);
init_player(&board->p[P_TWO]);
int i;
// null the board
for(i=0; i<5; i++) {
board->lanes[P_ONE][i].name[0] = '\0';
board->lanes[P_ONE][i].life = 0;
board->lanes[P_ONE][i].force = 0;
board->lanes[P_ONE][i].cost = 0;
}
for(i=0; i<5; i++) {
board->lanes[P_TWO][i].name[0] = '\0';
board->lanes[P_TWO][i].life = 0;
board->lanes[P_TWO][i].force = 0;
board->lanes[P_TWO][i].cost = 0;
}
}
void board1(void)
{
//prints("helloworld", 0, 0, 1,1.5);
make_space();
init_player(2, 2000);
player1_position = 0;
player2_position = 0;
//DEBUG TEST
do {
if (player[1] > 0) {
player1_turn();
#ifdef __APPLE__
sleep(1);
#else
Sleep(1000);
#endif
}
else
printf("Player[1] is bankrupted, skip\n\n");
if (player[2] > 0) {
player2_turn();
#ifdef __APPLE__
sleep(1);
#else
Sleep(1000);
#endif
}
else
printf("Player[2] is bankrupted, skip\n\n");
} while (player[1] > 0 || player[2] > 0);
//analysis
printf("\n\n");
for (int i=0; i<40; i++) {
if (space[i].occupy_condition == -1 || space[i].occupy_condition == 0) {
printf("[%d]%s is owned by the Mother Nature\n",i, space[i].space_name);
}
else
printf("[%d]%s is owned by Player[%d]\n",i, space[i].space_name, space[i].occupy_condition);
}
//dice_ui(-1, 1);
}
void create_player_at_pos(t_server *server, t_client *client, \
int x, int y)
{
t_player *player;
player = xmalloc(sizeof(t_player));
init_player(player, client->socket, client->team);
add_player_to_pos(server, player, x, y);
player->client = client;
client->player = player;
}
char init_game(t_player *p)
{
key_t key;
key = ftok("/", 0);
if (key == -1)
return (my_perror());
if (!init_sh_resources(key, p) || !init_player(p))
return (FAILURE);
return (SUCCESS);
}
void init_world(t_world *world, int starting_cells)
{
int i;
world->player_number = 1;
if (!(world->players = (t_player *)malloc(sizeof(t_player) * world->player_number)))
exit(-42);
i = -1;
while (++i < world->player_number)
world->players[i] = init_player(starting_cells);
}
static int create_player(struct player *player, char *name)
{
assert(name != NULL);
assert(player != NULL);
init_player(player, name);
player->elo = DEFAULT_ELO;
player->is_rankable = 0;
player->is_modified = 1;
return 1;
}
void init_struct(t_mega *all)
{
all->e.refresh = 1;
init_hook(&all->hook);
init_cam(&all->cam, (int)START_X, (int)START_Y);
init_player(&all->player);
init_textures(all);
all->sprites = init_sprites(all);
init_minimap(&all->e, &all->hook.minimap);
stock_minimap(all);
all->door.x = 0;
}
/*
* main:
* The main program, of course
*/
int main(int argc, char **argv)
{
md_init();
initJedi();
/*
* get home and options from environment
*/
#ifdef __linux__
strcpy(file_name, "/var/lib/griffin/rogue.save");
#else
strcpy(file_name, "rogue.save");
#endif
open_score();
/*
* check for print-score option
*/
if (argc == 2)
{
if (strcmp(argv[1], "-s") == 0)
{
score(0, -1, 0);
exit(0);
}
}
init_check(); /* check for legal startup */
restore("-r");
init_probs(); /* Set up prob tables for objects */
init_player(); /* Set up initial player stats */
init_names(); /* Set up names of scrolls */
init_colors(); /* Set up colors of potions */
init_stones(); /* Set up stone settings of rings */
init_materials(); /* Set up materials of wands */
setup();
displayMessage("WELCOME TO THE DUNGEONS OF DOOM");
new_level(); /* Draw current level */
/*
* Start up daemons and fuses
*/
start_daemon(runners, 0, AFTER);
start_daemon(doctor, 0, AFTER);
fuse(swander, 0, WANDERTIME, AFTER);
start_daemon(stomach, 0, AFTER);
playit();
return(0);
}
int main()
{
struct board_t board;
init_board(&board);
board.player_turn = 0;
init_player(&board.players[0]);
init_player(&board.players[1]);
init_hand_cards(&board.players[0].hand);
init_hand_cards(&board.players[1].hand);
int card_to_play, card = 2, j;
board.players[0].name = "ПешУ";
board.players[1].name = "ГошУ";
load_deck(&board, "deck1.csv");
board.player_turn = 1;
load_deck(&board, "deck_2.csv");
for (j = 0; j<=4; j++)
{
draw_card(&board.players[0].deck, &board.players[0].hand);
draw_card(&board.players[1].deck, &board.players[1].hand);
}
/*
if(board.players[!board.player_turn].hand.hand_cards[card].damage < 0)
{
special_effect(&board, card);
}
*/
print_board(&board);
return 0;
}
// function for maze
Maze *construct_maze(int shape[MAZE_HEIGHT][MAZE_WIDTH], int px, int py, int ex, int ey) {
Maze *maze = (Maze *) malloc(sizeof(Maze));
init_player(&maze->player1, px, py);
init_exit(&maze->exit1, ex, ey);
for (int i = 0; i < MAZE_HEIGHT; i++) {
for (int j = 0; j < MAZE_WIDTH; j++) {
maze->wall1.shape[i][j] = shape[i][j];
}
}
maze->xsize = MAZE_WIDTH;
maze->ysize = MAZE_HEIGHT;
return maze;
}
int main(int ac, char **av)
{
t_player *player;
ac--;
av++;
check_input(ac, av);
if (!(player = init_player(ft_atoi(av[0]))))
ERROR_LEMIPC;
wait_ncurse(player);
loop(player);
free_player(player);
return (EXIT_SUCCESS);
}
void test_cell_set_owner(void)
{
printf("\ntest_cell_set_owner\n");
s_cell c;
s_player p;
init_cell(&c, 1, 4);
init_player(&p, 1, "test", 1, STRATEGY_NONE, 10);
assert_null(c.owner);
cell_set_owner(&c, &p);
assert_str_equals(c.owner->name, "test");
assert_int_equals(c.owner->nb_cells, 1);
free_cell(&c);
}
