// Just handle any keypresses that come up, not mode dependent. Crappyx
// Returns 0 for quit, 1 for anything else
int handle_input(char c, ui_settings_t* ui, player_t* p, room_t* r)
{
if(c == ',')
move_player(p, r, 0);
else if(c == 'o')
move_player(p, r, 1);
else if(c == 'e')
move_player(p, r, 2);
else if(c == 'a')
move_player(p, r, 3);
if(c == 'q')
return 0;
if(c == 'd')
attempt_open_door(p, r);
if(c == 'p')
{
if(ui->display_pos)
{
ui->display_pos = 0;
}
else
{
ui->display_pos = 1;
}
}
return 1;
}
void handle_input() {
if (keys[SDLK_q]) {
game_running = false;
}
if (keys[SDLK_w]) move_player('w');
if (keys[SDLK_a]) move_player('a');
if (keys[SDLK_s]) move_player('s');
if (keys[SDLK_d]) move_player('d');
}
void get_input() {
int key = getch();
switch (key) {
case 'w': { return move_player(NORTH); }
case 'a': { return move_player(WEST); }
case 's': { return move_player(SOUTH); }
case 'd': { return move_player(EAST); }
case 'j': { return fire(); }
}
}
void _smash_trap_spell(int cmd, variant *res)
{
switch (cmd)
{
case SPELL_NAME:
var_set_string(res, "Smash Trap");
break;
case SPELL_DESC:
var_set_string(res, "Sets off a trap, then destroy that trap.");
break;
case SPELL_CAST:
{
int dir;
var_set_bool(res, FALSE);
if (!get_rep_dir2(&dir)) return;
move_player(dir, easy_disarm, TRUE);
var_set_bool(res, TRUE);
break;
}
default:
default_spell(cmd, res);
break;
}
}
void ram(void) {
while(1) {
if (!screen_intro()){
setTextColor(0xff,0x00);
return;
}
game.rokets = 3;
game.level = 1;
game.score = 0;
init_game();
screen_level();
while (game.rokets>=0) {
////checkISP();
lcdFill(0x00);
check_end();
move_ufo();
move_shot();
move_shots();
move_player();
move_enemy();
draw_score();
draw_ufo();
draw_bunker();
draw_player();
draw_enemy();
draw_shots();
// draw_status();
lcdDisplay();
delayms(12);
}
if (!screen_gameover())
setTextColor(0xff,0x00);
return;
}
}
/**
* Handles a channel kick request.
*/
void *c_req_kick_channel(char *data, unsigned int len, struct player *pl)
{
uint32_t target_id;
char *reason, *ptr;
struct player *target;
struct channel *def_chan;
struct server *s = pl->in_chan->in_server;
if (len != 60) {
logger(LOG_WARN, "c_req_kick_channel, packet has invalid size : %i instead of %i.", len, 60);
return NULL;
}
ptr = data + 24;
target_id = ru32(&ptr);
target = get_player_by_public_id(s, target_id);
def_chan = get_default_channel(s);
if (target != NULL) {
send_acknowledge(pl); /* ACK */
if (player_has_privilege(pl, SP_OTHER_CH_KICK, target->in_chan)) {
ptr = data + 28;
reason = rstaticstring(29, &ptr);
logger(LOG_INFO, "Reason for kicking player %s : %s", target->name, reason);
s_notify_kick_channel(pl, target, reason, pl->in_chan);
move_player(pl, def_chan);
/* TODO update player channel privileges etc... */
free(reason);
}
}
return NULL;
}
/**
* Walk in the given direction.
*/
void do_cmd_walk(struct command *cmd)
{
int x, y, dir;
/* Don't disarm on movement if the player is trapsafe,
* or the trap is disabled */
bool disarm = player->timed[TMD_TRAPSAFE] ? false : true;
/* Get arguments */
if (cmd_get_direction(cmd, "direction", &dir, false) != CMD_OK)
return;
/* Apply confusion if necessary */
/* Confused movements use energy no matter what */
if (player_confuse_dir(player, &dir, false))
player->upkeep->energy_use = z_info->move_energy;
/* Verify walkability */
y = player->py + ddy[dir];
x = player->px + ddx[dir];
if (!do_cmd_walk_test(y, x))
return;
/* Don't disarm if it's a disabled trap */
if (square_isdisabledtrap(cave, y, x)) disarm = false;
player->upkeep->energy_use = z_info->move_energy;
move_player(dir, disarm);
}
void ram(void) {
splash_scene();
long frame_count = 0;
init_game();
while(1) {
frame_count++;
lcdFill(0);
update_platforms(frame_count);
move_player(frame_count);
draw_platforms();
draw_player();
draw_hud();
blink_led();
lcdDisplay();
if(!game.running) {
if(!gameover_scene()){
delayms_queue_plus(10,1);
return;
}
init_game();
}
delayms_queue_plus(24,0);
}
}
int run(t_env* env)
{
int ret;
int status;
int i;
//t_player save;
i = 0;
while (i < 2)
{
ret = fork();
if (ret == 0)
{
move_player(env, i);
return 10;
}
i = i + 1;
}
waitpid(ret, &status, 0);
usleep(50000);
refresh_pos(env);
//save_pos(&save);
check_coll(env);
return (0);
}
int main()
{
char cmd;
int bLoop = 1;
while(bLoop) {
printf("명령을 선택하세요, \r\n\
i(up),j(left),k(right), \r\n\
m(down),s(show map),x(exit)\r\n");
for(int i=0;i<64;i++) {
buffer_map[i] = world_map[i];
}
scanf("%c",&cmd);
getchar();
move_player(cmd);
buffer_map[ player_xpos + player_ypos*8 ] = 3;
switch(cmd) {
case 's':
map_drawAll(buffer_map);
break;
case 'x':
bLoop = 0;
printf("bye bye~ \r\n");
break;
}
}
return 0;
}
int right(int socket, t_env *e)
{
if (move_player(e, socket, 0, 1) == 0)
send(socket, "OK", strlen("OK"), MSG_NOSIGNAL);
else
send(socket, "KO", strlen("KO"), MSG_NOSIGNAL);
return 0;
}
bool process_input(){
key = getKeyB();
if(key == -1 || key == 44){
quit = 1;
}
if(RIGHT && maze[py][px+1] != B){
move_player(py, px+1);
interact();
}
if(LEFT && maze[py][px-1]!= B ){
move_player(py, px-1);
interact();
}
if(UP && maze[py+1][px] != B){
move_player(py+1, px);
interact();
}
if(DOWN && maze[py-1][px] != B){
move_player(py-1, px);
interact();
}
return true;
}
void sdl_event()
{
extern t_sdl t;
SDL_WaitEvent(&t.event);
if (t.event.type == SDL_QUIT)
t.continuer = 0;
if (t.event.type == SDL_KEYDOWN)
{
if (t.event.key.keysym.sym == SDLK_ESCAPE)
t.continuer = 0;
if (t.event.key.keysym.sym == SDLK_UP)
t.pos = move_player(1);
if (t.event.key.keysym.sym == SDLK_DOWN)
t.pos = move_player(2);
if (t.event.key.keysym.sym == SDLK_RIGHT)
t.pos = move_player(3);
if (t.event.key.keysym.sym == SDLK_LEFT)
t.pos = move_player(4);
if (t.event.key.keysym.sym == SDLK_SPACE && (t.pos == 0 || t.pos == 1))
t.pos = move_player(5);
if (t.event.key.keysym.sym == SDLK_SPACE && t.pos == 2)
t.pos = move_player(6);
if (t.event.key.keysym.sym == SDLK_SPACE && t.pos == 3)
t.pos = move_player(7);
}
}
void _travel()
{
if (_travel_pos_x != -1 && _travel_pos_y != -1)
{
_travel_key = get_key_to_move_towards_goal(_travel_pos_x, _travel_pos_y);
}
bool did_move = _travel_key != 0 ? move_player(_travel_key) : false;
bool see_creature = false;
bool found_item = false;
if (did_move)
{
for (auto it = current_dungeon->creatures.begin(); it != current_dungeon->creatures.end(); ++it)
{
if (player.sees(*it))
{
append_msg_log("Stopped travel because of %s.", (*it)->name);
see_creature = true;
break;
}
}
if (!see_creature && !_travel_ignore_items)
{
for (const item_t* item : current_dungeon->items)
{
if (item->pos.x == player.pos.x && item->pos.y == player.pos.y)
{
found_item = true;
break;
}
}
if (!found_item)
{
auto tid = get_tile_at(current_dungeon, player.pos.x, player.pos.y)->id;
if (tid == TILE_STAIRS_DOWN || tid == TILE_STAIRS_UP)
{
found_item = true;
}
}
}
}
if (!did_move || see_creature || found_item)
{
statestack_pop();
}
else
{
sys::sleep(1000 / 60);
}
}
//State Machine Definitions
int tickFct_Keypad(int state) {
char key = GetKeypadKey();
switch(state) {
case keypad_start:
state = keypad_poll;
break;
case keypad_poll:
state = keypad_poll;
break;
}
switch(state) {
case keypad_start:
break;
case keypad_poll:
switch(key) {
case '\0':
break;
case '1':
if( gameover == OFF ) {
toggle_pause();
}
else if( gameover == ON ) {
restart_game();
}
break;
case '4':
if( gameover == OFF ) {
move_player(PLAYER_TOP);
}
break;
case '7':
if( gameover == OFF ) {
move_player(PLAYER_BOT);
}
break;
default:
break;
}
break;
}
return state;
}
void frame_play()
{
manage_sprites();
move_player();
move_camera();
animate_tilemap();
all_sprite_move(); // sprite movement and collisions
update_hud();
}
void main_key(const bool *keys, t_ray *ray)
{
if (keys[BKS_A] || keys[BKS_E])
strafe(((keys[BKS_A]) ? 1 : 0), ray);
if (keys[BKS_Z] || keys[BKS_S])
move_player(((keys[BKS_Z]) ? 1 : 0), ray);
if (keys[BKS_Q] || keys[BKS_D])
rotate_player(((keys[BKS_Q]) ? 1 : 0), ray);
if (keys[BKS_M])
main_slowmo(ray);
}
void update_game(void)
{
switch(state) {
case GAME_STATE_WORLD : if (move_player(game_player, game_world))
set_game_state(GAME_STATE_BATTLE);
break;
case GAME_STATE_MENU : break;
case GAME_STATE_BATTLE : move_battle(game_battle);
break;
default : break;
}
}
/*
* Helper function for the "walk" and "jump" commands
*/
static void do_cmd_walk_or_jump(int pickup)
{
int py = p_ptr->py;
int px = p_ptr->px;
int y, x, dir;
/* Get a direction (or abort) */
if (!get_rep_dir(&dir)) return;
/* Get location */
y = py + ddy[dir];
x = px + ddx[dir];
/* Verify legality */
if (!do_cmd_walk_test(y, x)) return;
/* Take a turn */
p_ptr->energy_use = 100;
/* Confuse direction */
if (confuse_dir(&dir))
{
/* Get location */
y = py + ddy[dir];
x = px + ddx[dir];
}
/* Verify legality */
if (!do_cmd_walk_test(y, x)) return;
/* Allow repeated command */
if (p_ptr->command_arg)
{
/* Set repeat count */
p_ptr->command_rep = p_ptr->command_arg - 1;
/* Redraw the state */
p_ptr->redraw |= (PR_STATE);
/* Cancel the arg */
p_ptr->command_arg = 0;
}
/* Move the player */
move_player(dir, pickup);
}
void check_env_map7_2(t_data *data)
{
if ((data->mouse->x >= 891 && data->mouse->x <= 1001) &&
(data->mouse->y >= 277 && data->mouse->y <= 529) &&
data->cupa_end == 1)
{
move_player(851, 512, data);
data->map.end = 1;
data->inv.open = 0;
}
else
position_handle(data->mouse->x, data->mouse->y, data);
}
int get_input(struct Game* game)
{
int key = getch();
switch(key)
{
case 'q':
game->running = false;
break;
case KEY_UP:
move_player(game, 0);
break;
case KEY_DOWN:
move_player(game, 1);
break;
case KEY_LEFT:
move_player(game, 2);
break;
case KEY_RIGHT:
move_player(game, 3);
break;
}
}
void disp_game(t_data *data)
{
if (data->player.real_pos.x >= 0 && data->player.real_pos.x
<= END_GAME)
draw_bg(data);
move_player(data);
if (data->player.real_pos.x >= 0 && data->player.real_pos.x
<= END_GAME)
{
bunny_blit(&data->window->buffer, data->back.fence,
&data->back.pos_fence);
bunny_blit(&data->window->buffer, data->back.tree2,
&data->back.pos_tree2);
}
}
static void my_expulse_right(t_server *serv,
t_player *drone,
t_player *victim)
{
int x;
int y;
char buff[512];
int len;
x = victim->pos % serv->width;
y = victim->pos / serv->width;
x += 1;
adjust_coord(serv, &x, &y);
move_player(serv, victim, victim->pos, COORD(x, y));
len = snprintf(buff, sizeof(buff), "deplacement: %d\n",
get_direction(serv, drone, victim));
buff_append(victim->wrbuff, buff, len);
}
/*
* Walk into a trap.
*/
void do_cmd_jump(cmd_code code, cmd_arg args[])
{
int x, y;
int dir = args[0].direction;
/* Apply confusion if necessary */
confuse_dir(&dir);
/* Verify walkability */
y = p_ptr->py + ddy[dir];
x = p_ptr->px + ddx[dir];
if (!do_cmd_walk_test(y, x))
return;
p_ptr->energy_use = 100;
move_player(dir, FALSE);
}
void play(SDL_Surface* screen)
{
int x;
int y;
x = 10;
while (g_playloop == 1)
{
y = 23;
SDL_FillRect(screen, 0, SDL_MapRGB(screen->format, 5, 5, 5));
fontmap_printf(x, y, screen,
"304-PACMAN <PAYET-S> + 1UP: 0 + "
"SCORE: %03d + TIME: %d", g_score, g_time);
y += FONTMAP_SIZE * 2;
fontmap_print(x, y, screen, g_prompt.c_str());
y += FONTMAP_SIZE * 2;
handle_event(screen, y);
y += FONTMAP_SIZE * 2;
for (auto line : g_map)
{
fontmap_print(x, y, screen, line.c_str());
y += FONTMAP_SIZE;
}
if (g_choose_file == 1)
g_prompt = "$> Choose a map.";
else if (g_count <= (g_score / 10))
g_prompt = "$> Congratulation!";
else if (g_pause == 0)
{
g_prompt = "$> GO!";
g_time += 1;
if ((g_time % 100) == 0)
{
move_player();
move_ghost();
}
}
else if (g_pause == 1)
{
g_prompt = "$> Game is paused.";
}
SDL_Flip(screen);
}
}
/**
* This is similar to handle_player(), but is only used by the new
* client/server stuff.
*
* This is sort of special, in that the new client/server actually uses
* the new speed values for commands.
* @param pl Player to handle.
* @retval -1 Player is invalid.
* @retval 0 No more actions to do.
* @retval 1 There are more actions we can do. */
int handle_newcs_player(player *pl)
{
object *op = pl->ob;
if (!op || !OBJECT_ACTIVE(op))
{
return -1;
}
handle_client(&pl->socket, pl);
if (!op || !OBJECT_ACTIVE(op) || pl->socket.status == Ns_Dead)
{
return -1;
}
/* Check speed. */
if (op->speed_left < 0.0f)
{
return 0;
}
/* If we are here, we're never paralyzed anymore. */
CLEAR_FLAG(op, FLAG_PARALYZED);
if (op->direction && (CONTR(op)->run_on || CONTR(op)->fire_on))
{
/* All move commands take 1 tick, at least for now. */
op->speed_left--;
move_player(op, op->direction);
if (op->speed_left > 0)
{
return 1;
}
else
{
return 0;
}
}
return 0;
}
int main()
{
//intalize
initialize_file_pointers();
a=time(0);
initialize_feld(FIELD_S,FIELD_C_S,FIELD_B);
write_to_file_everything();
memset(&players[0], 0 ,sizeof(player));
for (int i = 0; i < num_of_players; ++i)
{
initialize_player(&players[i]);
}
//intalize
// main loop
while(1)
{
//for (int i = 0; i < num_of_players; ++i)
{
move_player(comand(),&players[0]);
}
update();
DONT_GET_OUT();
eat_food();
spawn_food();
b=time(0);
printf("%llu\n%lf FPS\n",tiks, (double)tiks/(double)(b-a) );
tiks++;
system("sleep 0.010960");
}
return 0;
}
bool logic(Map& level, Player& player1, Viewpoint& camera, Idevice& input)
{
int mapvalue;
if (input.get_click() == ON)
{
mapvalue = find_tile(level, input, camera);
if (mapvalue == WARP) click_warp(level, player1, input, camera);
if (mapvalue == EXIT) click_door(level, player1, input, camera);
if (mapvalue == UPSTAIRS || mapvalue == DOWNSTAIRS) click_stairs(level, player1, input, camera);
if (mapvalue == CAVE) click_dungeon(level, player1, input, camera);
if (mapvalue == CITY) click_town(level, player1, input, camera);
}
input.put_click(OFF);
if(player1.check_map() | player1.check_floor()) return 0;
move_player(level, player1, input);
move_camera(level, player1, camera);
return 1;
}
/**
* Walk into a trap.
*/
void do_cmd_jump(struct command *cmd)
{
int x, y, dir;
/* Get arguments */
if (cmd_get_direction(cmd, "direction", &dir, false) != CMD_OK)
return;
/* Apply confusion if necessary */
if (player_confuse_dir(player, &dir, false))
player->upkeep->energy_use = z_info->move_energy;
/* Verify walkability */
y = player->py + ddy[dir];
x = player->px + ddx[dir];
if (!do_cmd_walk_test(y, x))
return;
player->upkeep->energy_use = z_info->move_energy;
move_player(dir, false);
}
/*
* Walk in the given direction.
*/
void do_cmd_walk(cmd_code code, cmd_arg args[])
{
int x, y;
int dir = args[0].direction;
/* Apply confusion if necessary */
player_confuse_dir(p_ptr, &dir, FALSE);
/* Confused movements use energy no matter what */
if (dir != args[0].direction)
p_ptr->energy_use = 100;
/* Verify walkability */
y = p_ptr->py + ddy[dir];
x = p_ptr->px + ddx[dir];
if (!do_cmd_walk_test(y, x))
return;
p_ptr->energy_use = 100;
move_player(dir, TRUE);
}
