void world::detect_collisions()
{
if(m_ball->X() + m_ball->L() >= (m_screen->w - p2->W()))
{
if(m_ball->Y()+m_ball->L() >= p2->Y() && m_ball->Y() <= p2->Y() + p2->H())
{
m_ball->reverse_x();
++m_collisions;
}
}
else if(m_ball->X() <= p1->W())
{
if(m_ball->Y()+m_ball->L() >= p1->Y() && m_ball->Y() <= p1->Y() + p1->H())
{
m_ball->reverse_x();
++m_collisions;
}
}
if(m_ball->Y() >= m_screen->h || m_ball->Y() <= 0)
{
m_ball->reverse_y();
}
if ( m_ball->X() + m_ball->L() >= m_screen->w)
{
++m_p1_wins;
reset_game();
}
else if(m_ball->X() <= 0)
{
++m_p2_wins;
reset_game();
}
}
int demo_manager::start_recording(char *filename)
{
if (!current_level) return 0;
record_file=open_file(filename,"wb");
if (record_file->open_failure()) { delete record_file; return 0; }
char name[100];
strcpy(name,current_level->name());
the_game->load_level(name);
record_file->write((void *)"DEMO,VERSION:2",14);
record_file->write_uint8(strlen(name)+1);
record_file->write(name,strlen(name)+1);
if (DEFINEDP(symbol_value(l_difficulty)))
{
if (symbol_value(l_difficulty)==l_easy) record_file->write_uint8(0);
else if (symbol_value(l_difficulty)==l_medium) record_file->write_uint8(1);
else if (symbol_value(l_difficulty)==l_hard) record_file->write_uint8(2);
else record_file->write_uint8(3);
} else record_file->write_uint8(3);
state=RECORDING;
reset_game();
return 1;
}
void main()
{
ENABLE_RAM_MBC1;
SWITCH_ROM_MBC1(7);
kwakwa_screen();
//disable_APA();
credits = 0U;
while(1)
{
ENABLE_RAM_MBC1;
SWITCH_ROM_MBC1(7);
title_screen();
credits = 0U;
reset_game();
disable_APA();
while(credits == 0U)
{
game_screen();
}
//disable_APA();
ENABLE_RAM_MBC1;
SWITCH_ROM_MBC1(7);
credits_screen();
disable_APA();
}
}
void main_app_handle_button_up()
{
if (!button_held)
{
pulse_cancel_timer(&button_timer_id);
if (current_screen == SCREEN_CLOCK)
{
cancel_sleep();
reset_game();
pulse_blank_canvas();
current_screen = SCREEN_GAME_OVER;
printf("Click to start.\n\n\nClick while \nyou're in the \nair to do a \ndouble jump!");
prepare_to_sleep();
}
else if (current_screen == SCREEN_GAME_OVER)
{
time_now_ms = pulse_get_millis();
if (time_now_ms - time_last_box_drawn_ms >= 500) {
cancel_sleep();
pulse_blank_canvas();
current_screen = SCREEN_GAMEPLAY;
}
}
else if (current_screen == SCREEN_GAMEPLAY)
press = false;
}
else
button_held = false;
}
void main_app_handle_button_up()
{
if (!button_held)
{
pulse_cancel_timer(&button_timer_id);
if (current_screen == SCREEN_CLOCK)
{
cancel_sleep();
pulse_blank_canvas();
reset_game();
current_screen = SCREEN_GAME_OVER;
printf("\n\n\n\n\n Click to start");
prepare_to_sleep();
}
else if (current_screen == SCREEN_GAME_OVER)
{
time_now_ms = pulse_get_millis();
// Check if it's been at least 500 ms since the game ended to prevent accidental clicks
if (time_now_ms - time_last_box_drawn_ms > 500)
{
cancel_sleep();
pulse_blank_canvas();
current_screen = SCREEN_GAMEPLAY;
}
}
else if (current_screen == SCREEN_GAMEPLAY)
press = false;
}
else
button_held = false;
}
void process_game(t_game *game)
{
int collisiontype;
int i;
if (game->playing)
{
handle_bar_position(game);
if (!game->bar.sticky_ball)
{
i = -1;
while (++i < 10)
{
if ((collisiontype = future_ball_collision(game)))
{
handle_collision(game, collisiontype);
break ;
}
else
do_ball_motion(game);
}
}
if (game->ball.y > WIN_HEIGHT - BAR_MARGIN + 15)
reset_game(game);
if (count_brick(game->bricks->next) == 0)
change_level(game);
}
}
/* Called when an "action" input (ie. a mouse button or the space bar) is
* pressed. Starts the game if we're on the title screen, jumps to the title
* screen if the game is over, or unparks the ball if the game is running and
* the ball is parked. */
static void action_pressed(nbstate *state)
{
if(state->state == STATE_TITLESCREEN) increment_level(state);
else if(state->state == STATE_GAMEWON ||
state->state == STATE_GAMELOST)
reset_game(state);
else state->ball.parked = 0;
}
void checkend(void)
{
register int i,k;
struct player *p;
/* First, we check that no one is dogfighting anymore */
for(i=0,p=&players[0];i<MAXPLAYER;i++,p++)
{
if (p->p_status == PFREE) continue;
if (p == me) continue;
if (tracks[i].t_flags & (PU_NOTCONTEST)) continue;
if (tracks[i].t_flags & (PU_DOG|PU_WAIT))
{
#ifdef DOGDEBUG
ERROR(2,("Returning on %d",i));
#endif
return;
}
}
/* Next, we check that all schedules are played */
for(i=0;i<MAXPLAYER;i++)
{
if (tracks[i].t_flags & PU_NOTCONTEST) continue;
if (players[i].p_status==PFREE) continue;
if (i == me->p_no) continue;
for (k=0;k<MAXPLAYER;k++)
{
if (k == i) continue;
if (tracks[k].t_flags & PU_NOTCONTEST) continue;
if (k == me->p_no) continue;
if (players[k].p_status==PFREE) continue;
if (get_num_matches(i,k) < nummatch)
{
#ifdef DOGDEBUG
ERROR(2,("Returning on %d %d",i,k));
#endif
return;
}
}
if (!toolate2join)
{
messAll(255,roboname,"No more players will be allowed to join the tournament until completed.");
toolate2join = 1;
}
tracks[i].t_flags |= PU_DONE;
tracks[i].t_flags &= ~PU_CONTEST;
}
player_maint(); /* seems to be necessary -Jon */
reset_game();
}
/* Description:
Sets up all the hardware in the MSP430 used by the SPACEWAR game.
Stops the watchdog timer. Sets the internal cpu clock to a maximun.
Sets the timer to cause an interrupt every 10ms. Sets the SPI interface
to talk to the dual DAC. Sets the A to D to use an external reference
and unipolar operation. Finally initializes all the variable used by the game.
*/
void init_all(rkt_data *rkt1, rkt_data *rkt2)
{
WDTCTL = WDTPW + WDTHOLD; // Stop watchdog timer
BCSCTL1 = 0x08; // Setup DCO highest range
DCOCTL = 0xe0; // biggest DCO
P1OUT = 0x04; // TLV5618A CS high
P1DIR |= 0x01+0x04; // P1.0=LED, P1.2=TLV5618A_cs
P1SEL = 0x08; // P1.3 = VREF
//BCSCTL2 = 0x00; // SMCLK divider = 1
//BCSCTL2 = 0x02; // SMCLK divider = 2
//BCSCTL2 = 0x04; // SMCLK divider = 4
BCSCTL2 = 0x06; // SMCLK divider = 8
CCTL0 = CCIE; // CCR0 interrupt enabled
CCR0 = 23500;
TACTL = TASSEL_2 + MC_1; // SMCLK, upmode
_BIS_SR(GIE); // enable interrupts
// USICTL0 |= USIPE7+USIPE6+USIPE5+USIMST+USIOE; // Port, SPI master
// USICKCTL = USIDIV_0+USISSEL_2+USICKPL; // divide by 1 SMCLK, inactive high
// USICTL0 &= ~USISWRST; // release USI for operation
// USICTL1 = USICKPH; // take data on falling edge
// SD16CTL = SD16SSEL_1; // exter ref, SMCLK
// SD16CCTL0 = SD16UNI + SD16SNGL; // 256OSR, unipolar, inter
// SD16AE = 0; // P1.1 A4+, A4- = VSS
// // P1.4 A2+, A2- = VSS
// SD16INCTL0 = SD16INCH_4; // A4+/- start with rocket 1
// SD16CCTL0 |= SD16SC; // Start A2D conversion
reset_rkts(rkt1, rkt2); // reset rkt positons
reset_game(rkt1);
reset_game(rkt2);
rkt1->game = 0;
rkt2->game = 0;
flags |= time_tick; // force an update at startup
}
void game_over() {
pulse_vibe_on();
pulse_mdelay(60);
pulse_vibe_off();
//int vib_timer = pulse_register_timer(75, &pulse_vibe_off, 0);
current_screen = SCREEN_GAME_OVER;
pulse_blank_canvas();
if (score > highscore)
highscore = score;
printf ("GAME OVER\n\nScore: %d\n\nHighscore: %d\n\nClick to restart",score,highscore);
reset_game();
prepare_to_sleep();
}
static void do_time_out()
{
GtkWidget *dialog;
gchar info[64];
sprintf(info, "很遗憾，你己超时\n正确答案:%d", random_num);
dialog = gtk_message_dialog_new(NULL,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK, info);
gtk_window_set_icon(GTK_WINDOW(dialog), window_icon_buf);
gtk_window_set_title(GTK_WINDOW(dialog), "超时");
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
reset_game();
}
static void do_win(unsigned int input)
{
GtkWidget *dialog;
gchar info[64];
sprintf(info, "猜对了！你真聪明!\n答案:%d", input);
dialog = gtk_message_dialog_new(NULL,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_INFO,
GTK_BUTTONS_OK, info, "title");
gtk_window_set_icon(GTK_WINDOW(dialog), window_icon_buf);
gtk_window_set_title(GTK_WINDOW(dialog), "猜对了");
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
reset_game();
}
static ssize_t device_write(struct file *filp, const char *buff, size_t len, loff_t * off)
{
if (strstr(buff,RESET_COMMAND)) {
reset_game();
return len;
}
if (ai_turn == FALSE && make_move(PLAYER_X, simple_strtol(buff, NULL, 10))) {
ai_turn = TRUE;
return len;
}
else
return -1;
}
/* ARGSUSED */
void do_force_newgame(int mflags, int sendto)
{
/****MK - stats are cleared*/
#ifdef NEWGAME_RESET
messAll(255,roboname,"Clearing Player Stats for the Newgame");
reset_game();
#else
messAll(255,roboname,"NEWGAME is disabled on this server.");
#endif
/****End added code */
}
Game::Game() {
kill = false;
srand(time(NULL));
if (!texture.loadFromFile("solitaire_sprite_sheet.png")) {
kill = true;
freopen("error.txt", "w", stdout);
std::cout << "Fatal error: Could not load sprite sheet" << "\n";
return;
}
texture.setSmooth(true);
backside.set_texture(texture);
three_card_rule = true;
init_rect();
init_text();
reset_game();
}
int check_keys ( XEvent *e, Game *game )
{
//Was there input from the keyboard?
if ( e->type == KeyPress ) {
int key = XLookupKeysym ( &e->xkey, 0 );
switch ( key ) {
case XK_p:
game->sub_menu^=true;
break;
case XK_o:
game->gameover^=true;
break;
case XK_f:
game->showfps ^= 1;
break;
case XK_i:
reset_game(game);
break;
case XK_j:
game->troll_lilypad ^= 1;
break;
case XK_h:
game->help_menu ^= true;
break;
case XK_k:
game->stresstest ^= 1;
break;
case XK_s:
game->swarmOn ^= 1;
break;
case XK_r:
break;
case XK_t:
game->demo.on^=1;
break;
case XK_Escape:
game->sub_menu^=true;
break;
case XK_b:
game->bossGO ^= true;
break;
return 1;
}
}
return 0;
}
void reset(void) //각종 변수 초기화
{
level = 1;
level_goal = 1000;
key = 0;
crush_on = 0;
cnt = 0;
score = 0;
speed = 100;
system("cls"); //화면지움
reset_game();
draw_stat();
draw_game();
b_type_next = rand() % 7; //다음번에 나올 블록 종류를 랜덤하게 생성
new_block(); //새로운 블록을 하나 만듦
}
void do_key(char key)
{
short i, j;
while (ANYKEY())
{
readkeyboard();
do_halt();
}
if (minefield[key])
{
// boom
drawstring("Oops, you appear to have stepped", 0, 176);
drawstring("on a rotten egg and died. ", 0, 184);
for (j = 0; j < 20; j++)
{
playfx(1);
for (i = 0; i < 32*21; i++)
{
if (xorshift8() > 220)
*((char*)0x4000+192*32+i) = xorshift8() & 7;
}
for (i = 0; i < 51; i++) xorshift8();
do_halt();
}
reset_game();
}
else
{
drawval(key, count_mines(key));
if (minefound[key] == 0)
{
minefound[key] = 1;
found++;
if (found == total)
{
framecounter = 0;
drawstring("Congratulations!! You did it! ", 0, 176);
drawstring("Step on a mine for a new game. ", 0, 184);
}
}
playfx(0);
}
}
int demo_manager::start_playing(char *filename)
{
uint8_t sig[15];
record_file=open_file(filename,"rb");
if (record_file->open_failure()) { delete record_file; return 0; }
char name[100],nsize,diff;
if (record_file->read(sig,14)!=14 ||
memcmp(sig,"DEMO,VERSION:2",14)!=0 ||
record_file->read(&nsize,1)!=1 ||
record_file->read(name,nsize)!=nsize ||
record_file->read(&diff,1)!=1)
{ delete record_file; return 0; }
const size_t tnamesize = 100;
char tname[tnamesize],*c;
strncpy(tname,name,tnamesize-1); tname[tnamesize-1] = 0;
c=tname;
while (*c) { if (*c=='\\') *c='/'; c++; }
bFILE *probe=open_file(tname,"rb"); // see if the level still exists?
if (probe->open_failure()) { delete record_file; delete probe; return 0; }
delete probe;
the_game->load_level(tname);
initial_difficulty = l_difficulty;
switch (diff)
{
case 0: l_difficulty->SetValue(l_easy); break;
case 1: l_difficulty->SetValue(l_medium); break;
case 2: l_difficulty->SetValue(l_hard); break;
case 3: l_difficulty->SetValue(l_extreme); break;
}
state=PLAYING;
reset_game();
return 1;
}
int main()
{
int key;
init_display();
play_again:
reset_game();
display_board(&grid);
play_game();
movecur(15, 9 + brd_h * 2);
textcolour(12);
strout("Game Over! Press ESCAPE to exit or ENTER to play again.");
do {
key = os_wait_for_key();
} while (key != ESC_KEY && key != ENTER_KEY);
if (key == ENTER_KEY) goto play_again;
end_program();
}
void Game::state_mainmenu(SDL_Event* event)
{
int m_x, m_y;
SDL_GetMouseState(&m_x, &m_y);
if (event->key.type == SDL_MOUSEBUTTONDOWN)
{
if (event->button.button == SDL_BUTTON_LEFT)
{
for (iter_mainmenu_button = mainmenu_buttons.begin(); iter_mainmenu_button != mainmenu_buttons.end(); iter_mainmenu_button++)
{
if ((m_x > (*iter_mainmenu_button)->get_x()) && (m_x < (*iter_mainmenu_button)->get_x() + (*iter_mainmenu_button)->get_width()) && (m_y
> (*iter_mainmenu_button)->get_y()) && (m_y < (*iter_mainmenu_button)->get_y() + (*iter_mainmenu_button)->get_height()))
{
switch ((*iter_mainmenu_button)->get_type())
{
case BUTTON_STARTGAME:
reset_game();
game_state = GAME_PAUSED;
break;
case BUTTON_HIGHSCORE:
update_highscore_sprites();
game_state = HIGHSCORE;
break;
case BUTTON_VIEW_HELP:
game_state = VIEW_HELP;
break;
case BUTTON_EXITGAME:
game_running = false;
break;
}
}
}
}
}
}
void
keyboard(unsigned char key, int x, int y)
{
switch(key) {
case 'w':
key_list_add(W);
break;
case 's':
key_list_add(S);
break;
case 'a':
key_list_add(A);
break;
case 'd':
key_list_add(D);
break;
case 'r':
reset_game();
break;
case 'm':
map = !map;
break;
}
}
void checkstatus(void)
{
int i;
struct player *j;
Track *track;
int numplayers = 0;
/* avoid dead slots, me, other robots (which aren't hostile) */
for (i = 0, j = &players[i], track = &tracks[i];
i < MAXPLAYER; i++, j++, track++)
{
if ((j == me) ||
(j->p_status == PFREE) ||
(track->t_flags & PU_FILLER) ||
(track->t_flags & PU_SITOUT)) /*ignore puck,filler,watchers*/
continue;
numplayers++;
}
if (numplayers >= contestsize)
{
if (!inprogress)
{
inprogress = 1;
faceoff = FACEOFF;
}
}
else if (inprogress)
{
messAll(255,roboname,"Too many people have left. The contest is over.");
reset_game();
}
}
void main()
{
// unsigned char i;
y8 = 1;
reset_game();
/*
for (i = 0; i < 40; i++)
if (minefield[i] == 0)
drawval(i, count_mines(i));
*/
while(1)
{
drawscore();
readkeyboard();
if (KEYDOWN(1)) do_key(0);
if (KEYDOWN(2)) do_key(1);
if (KEYDOWN(3)) do_key(2);
if (KEYDOWN(4)) do_key(3);
if (KEYDOWN(5)) do_key(4);
if (KEYDOWN(6)) do_key(5);
if (KEYDOWN(7)) do_key(6);
if (KEYDOWN(8)) do_key(7);
if (KEYDOWN(9)) do_key(8);
if (KEYDOWN(0)) do_key(9);
if (KEYDOWN(Q)) do_key(10);
if (KEYDOWN(W)) do_key(11);
if (KEYDOWN(E)) do_key(12);
if (KEYDOWN(R)) do_key(13);
if (KEYDOWN(T)) do_key(14);
if (KEYDOWN(Y)) do_key(15);
if (KEYDOWN(U)) do_key(16);
if (KEYDOWN(I)) do_key(17);
if (KEYDOWN(O)) do_key(18);
if (KEYDOWN(P)) do_key(19);
if (KEYDOWN(A)) do_key(20);
if (KEYDOWN(S)) do_key(21);
if (KEYDOWN(D)) do_key(22);
if (KEYDOWN(F)) do_key(23);
if (KEYDOWN(G)) do_key(24);
if (KEYDOWN(H)) do_key(25);
if (KEYDOWN(J)) do_key(26);
if (KEYDOWN(K)) do_key(27);
if (KEYDOWN(L)) do_key(28);
if (KEYDOWN(ENTER)) do_key(29);
if (KEYDOWN(SHIFT)) do_key(30);
if (KEYDOWN(Z)) do_key(31);
if (KEYDOWN(X)) do_key(32);
if (KEYDOWN(C)) do_key(33);
if (KEYDOWN(V)) do_key(34);
if (KEYDOWN(B)) do_key(35);
if (KEYDOWN(N)) do_key(36);
if (KEYDOWN(M)) do_key(37);
if (KEYDOWN(SYM)) do_key(38);
if (KEYDOWN(SPACE)) do_key(39);
framecounter++;
do_halt();
if (framecounter > 500)
{
framecounter = 0;
// 12345678901234567890123456789012
switch (infoloop)
{
case 0:
drawstring("Welcome to \"Rotten Egg Mines\" ", 0, 176);
drawstring("By Jari Komppa http://iki.fi/sol", 0, 184);
break;
case 1:
drawstring("How to play: ", 0, 176);
drawstring("Press keys to find mines. ", 0, 184);
break;
case 2:
case 4:
case 6:
case 8:
drawstring(". . . . . . . . . . . . . . . . ", 0, 176);
drawstring(" . . . . . . . . . . . . . . . .", 0, 184);
break;
case 3:
drawstring("Sound effects played via ", 0, 176);
drawstring("BeepFX by Shiru ", 0, 184);
break;
case 5:
drawstring("Art made by using the ", 0, 176);
drawstring("Image Spectrumizer ", 0, 184);
break;
case 7:
drawstring("Sources can be found at ", 0, 176);
drawstring("github.com/jarikomppa/speccy ", 0, 184);
break;
case 12:
drawstring(" [ . . . . . . . . . . .] ", 0, 176);
drawstring(" [. . . . . . . . . . . ] ", 0, 184);
break;
case 13:
drawstring(" [ . . . . . . .] ", 0, 176);
drawstring(" [. . . . . . . ] ", 0, 184);
break;
case 14:
drawstring(" [ . . .] ", 0, 176);
drawstring(" [. . . ] ", 0, 184);
break;
case 15:
drawstring(" ", 0, 176);
drawstring(" ", 0, 184);
break;
}
infoloop++;
if (infoloop == 16)
infoloop = 0;
}
}
}
void player_state_toughy::OnPlayerSpawned(game_PlayerState const * ps)
{
if (m_owner->get_local_player() == ps)
reset_game();
}
/**
* apply_states:
* @sg: #state_group object
*
* Apply all read states to the current game state
*/
void apply_states(state_group *sg)
{
gint i, j, sum, num_tricks;
card *crd;
card_state *cs;
player *pptr;
player_state *pstate;
/* reset current game states */
reset_game();
/* set global game properties */
gskat.stich = sg->gs->num_stich;
gskat.cplayer = sg->gs->cplayer;
gskat.forehand = sg->gs->forehand;
gskat.trump = sg->gs->trump;
gskat.hand = sg->gs->hand;
gskat.null = sg->gs->null;
gskat.re = gskat.players[sg->gs->re_player];
/* set player values */
for (i=0; i<3; ++i)
{
pptr = gskat.players[i];
pstate = &sg->gs->pstates[i];
pptr->re = pstate->re;
pptr->gereizt = pstate->gereizt;
pptr->points = pstate->points;
pptr->sum_points = pstate->sum_points;
}
/* set all card values accordingly */
for (i=0; i<32; ++i)
{
cs = &sg->cs[i];
crd = get_card_ptr(cs->suit, cs->rank);
crd->owner = cs->owner;
crd->status = cs->status;
crd->draw = cs->draw;
crd->draw_face = cs->draw_face;
}
/* populate played cards list */
for (i=0; i<sg->gs->num_played; ++i)
gskat.played = g_list_append(gskat.played, get_card_by_id(sg->pc[i]));
num_tricks = sg->gs->num_played / 3 + (sg->gs->num_played % 3 ? 1 : 0);
/* fill stiche array */
for (i=0; i<num_tricks; ++i)
{
sum = 0;
gskat.stiche[i] = trick_new();
for (j=0; j<3; ++j)
{
if (sg->tricks[i][j])
{
crd = get_card_by_id(sg->tricks[i][j]);
gskat.stiche[i]->cards[j] = crd;
sum += crd->points;
}
}
gskat.stiche[i]->points = sum;
if (sg->tricks[i][3] != -1)
gskat.stiche[i]->winner = gskat.players[sg->tricks[i][3]];
}
/* populate players' cards list */
for (i=0; i<3; ++i)
{
pptr = gskat.players[i];
for (j=0; j<sg->gs->pstates[i].num_cards; ++j)
{
pptr->cards = g_list_append(pptr->cards,
get_card_by_id(sg->pcards[i][j]));
}
}
/* populate skat list */
for (i=0; i<2; ++i)
gskat.skat = g_list_append(gskat.skat, get_card_by_id(sg->gs->skat[i]));
/* populate table cards list */
for (i=0; i<sg->gs->num_table; ++i)
gskat.table = g_list_append(gskat.table, get_card_by_id(sg->table[i]));
/* free states memory */
g_free(sg->gs);
g_free(sg->cs);
if (sg->pc)
g_free(sg->pc);
if (sg->table)
g_free(sg->table);
if (sg->tricks)
{
for (i=0; i<num_tricks; ++i)
{
if (sg->tricks[i])
g_free(sg->tricks[i]);
}
g_free(sg->tricks);
}
for (i=0; i<3; ++i)
{
if (sg->pcards[i])
g_free(sg->pcards[i]);
}
g_free(sg->pcards);
g_free(sg);
}
void platformer_init() {
/* Set the viewport title */
graphics_viewport_set_title("Platformer");
/* Register functions for loading/unloading files with the extension .level */
asset_handler(level, "level", level_load_file, level_delete);
/* Load Assets */
folder_load(P("./tiles/"));
folder_load(P("./backgrounds/"));
folder_load(P("./sounds/"));
folder_load(P("./levels/"));
/* Register some handlers for creating and destroying entity types */
entity_handler(character, character_new, character_delete);
entity_handler(coin, coin_new, coin_delete);
/* Create our main character */
character* main_char = entity_new("main_char", character);
/* Add some UI elements */
ui_button* framerate = ui_elem_new("framerate", ui_button);
ui_button_move(framerate, vec2_new(10,10));
ui_button_resize(framerate, vec2_new(30,25));
ui_button_set_label(framerate, " ");
ui_button_disable(framerate);
ui_button* score = ui_elem_new("score", ui_button);
ui_button_move(score, vec2_new(50, 10));
ui_button_resize(score, vec2_new(120, 25));
ui_button_set_label(score, "Score 000000");
ui_button_disable(score);
ui_button* time = ui_elem_new("time", ui_button);
ui_button_move(time, vec2_new(180, 10));
ui_button_resize(time, vec2_new(110, 25));
ui_button_set_label(time, "Time 000000");
ui_button_disable(time);
ui_button* victory = ui_elem_new("victory", ui_button);
ui_button_move(victory, vec2_new(365, 200));
ui_button_resize(victory, vec2_new(70, 25));
ui_button_set_label(victory, "Victory!");
ui_button_disable(victory);
ui_button* new_game_but = ui_elem_new("new_game", ui_button);
ui_button_move(new_game_but, vec2_new(365, 230));
ui_button_resize(new_game_but, vec2_new(70, 25));
ui_button_set_label(new_game_but, "New Game");
void on_newgame(ui_button* b, void* unused) {
reset_game();
}
ui_button_set_onclick(new_game_but, on_newgame);
/* Reset all the game variables */
reset_game();
}
/* Initialise the game and return the state structure or NULL on failure: */
nbstate *init(int argc, char *argv[])
{
GR_PROP *prop;
nbstate *state;
GR_SCREEN_INFO si;
GR_BITMAP cursor = 0;
GR_WM_PROPERTIES props;
/* Try to connect to the Nano-X server: */
if(GrOpen() < 1) {
fprintf(stderr, "Couldn't connect to Nano-X server\n");
return NULL;
}
/* Check that the server was built with alpha blending support
* (necessary for the alpha blended sprites and special effects): */
GrGetScreenInfo(&si);
if(!si.alphablend) {
fprintf(stderr, "Error: Nano-X server was built without alpha "
"blending support\nSet ALPHABLENDING = 1 in "
"include/device.h, rebuild, and try again.\n");
return NULL;
}
/* Allocate the state structure and initialise it with defaults: */
if(!(state = malloc(sizeof(nbstate)))) return NULL;
setup_default_state(state);
/* Try to parse the command line arguments: */
if(parse_cmd_args(state, argc, argv)) {
free(state);
return NULL;
}
/* Try to load the game file: */
if(load_game_file(state)) {
free(state);
return NULL;
}
/* Load the high score file: */
load_hiscore(state);
/* Calculate the canvas size: */
state->canvaswidth = state->width * state->brickwidth;
state->canvasheight = state->scores.h + state->ball.s->h +
(2 * BALLS_BORDER) +
(state->height * state->brickheight) +
3 * state->brickheight + state->batheight;
/* Place the bat in the centre of the window: */
state->batx = state->canvaswidth / 2;
/* Create various pixmaps and alpha channels: */
state->scores.p = GrNewPixmap(state->canvaswidth, state->scores.h,
NULL);
state->scores.a = GrNewAlpha(state->canvaswidth, state->scores.h);
state->canvas = GrNewPixmap(state->canvaswidth, state->canvasheight,
NULL);
/* The new and old canvasses are only used when screen fading is
* enabled: */
if(state->faderate) {
state->newcanvas = GrNewPixmap(state->canvaswidth,
state->canvasheight, NULL);
state->oldcanvas = GrNewPixmap(state->canvaswidth,
state->canvasheight, NULL);
}
state->brickalpha = GrNewAlpha(state->brickwidth, state->brickheight);
/* Start off with the canvas completely black: */
GrSetGCForeground(state->gc, GR_COLOR_BLACK);
GrFillRect(state->canvas, state->gc, 0, 0, state->canvaswidth,
state->canvasheight);
/* If there is a window manager running, place the window off the
* screen and let the window manager move it where it wants (avoids
* flicker if we were to draw the window on screen before the window
* manager moved it somewhere else): */
if(GrGetWindowProperty(GR_ROOT_WINDOW_ID, "WINDOW_MANAGER", &prop)) {
free(prop);
state->winx = GR_OFF_SCREEN;
}
/* Create the output window: */
state->wid = GrNewWindow(GR_ROOT_WINDOW_ID, state->winx, 0,
state->canvaswidth, state->canvasheight, 0, 0, 0);
/* Set the window title: */
props.flags = GR_WM_FLAGS_TITLE;
props.title = "NanoBreaker";
GrSetWMProperties(state->wid, &props);
/* Make the cursor over the output window be invisible: */
GrSetCursor(state->wid, 1, 1, 1, 1, 0, 0, &cursor, &cursor);
/* Select the events we want to receive for the output window: */
GrSelectEvents(state->wid, GR_EVENT_MASK_CLOSE_REQ |
GR_EVENT_MASK_EXPOSURE |
GR_EVENT_MASK_BUTTON_DOWN |
GR_EVENT_MASK_KEY_DOWN |
GR_EVENT_MASK_KEY_UP |
GR_EVENT_MASK_UPDATE |
GR_EVENT_MASK_TIMER);
/* Select for mouse position events on the root window so we can move
* the bat even when the pointer strays outside the window (which it
* often does because the cursor is invisible you don't know exactly
* where it is): */
GrSelectEvents(GR_ROOT_WINDOW_ID, GR_EVENT_MASK_MOUSE_POSITION);
/* Map the output window (make it visible): */
GrMapWindow(state->wid);
/* Create the one second periodic timer that is used to decrement the
* power-up and power-down timers: */
state->tid = GrCreateTimer(state->wid, 1000, GR_TRUE);
/* Reset the game: */
reset_game(state);
return state; /* Return the newly allocated state structure. */
}
int main(int argc, char **argv) {
int status, scene, next_scene;
char errmsg[128];
long elapsed_msec, wait_msec;
struct timespec wait_time, left_time;
struct timeval frame_start_time, frame_end_time;
WINDOW *window;
struct invaders_game game;
struct logger error_logger;
UNUSED(argc);
UNUSED(argv);
/* Initialize for ncurses library */
reset_logger(&error_logger, ERRORLOG_FILEPATH);
status = 1;
window = initscr();
if (ERR == wresize(window, CANVAS_SIZE_X, CANVAS_SIZE_Y)) {
emit_log(&error_logger,
"Failed to change the ncurses setting for window size");
goto cleanup;
}
if (ERR == keypad(window, true)) {
emit_log(&error_logger,
"Failed to change the ncurses setting for key input receiving");
goto cleanup;
}
if (ERR == noecho()) {
emit_log(&error_logger,
"Failed to change the ncurses setting for echoing setting");
goto cleanup;
}
curs_set(0);
timeout(0);
if (has_colors() && can_change_color()) {
if (ERR == start_color()) {
emit_log(&error_logger,
"Failed to change the ncurses setting to set up coloring");
goto cleanup;
}
if ((ERR == init_pair(PLAYER_JET_COLOR_PAIR, PLAYER_JET_COLOR, COLOR_BLACK))
|| (ERR == init_pair(PLAYER_BULLET_COLOR_PAIR, PLAYER_BULLET_COLOR,
COLOR_BLACK))
|| (ERR == init_pair(TOCHCA_COLOR_PAIR, TOCHCA_COLOR, COLOR_BLACK))
|| (ERR == init_pair(COMMANDER_INVADER_COLOR_PAIR, COMMANDER_INVADER_COLOR,
COLOR_BLACK))
|| (ERR == init_pair(SENIOR_INVADER_COLOR_PAIR, SENIOR_INVADER_COLOR,
COLOR_BLACK))
|| (ERR == init_pair(YOUNG_INVADER_COLOR_PAIR, YOUNG_INVADER_COLOR,
COLOR_BLACK))
|| (ERR == init_pair(LOOKIE_INVADER_COLOR_PAIR, LOOKIE_INVADER_COLOR,
COLOR_BLACK))
|| (ERR == init_pair(INVADER_BULLET_COLOR_PAIR, INVADER_BULLET_COLOR,
COLOR_BLACK))
|| (ERR == init_pair(TITLE_COLOR_PAIR, TITLE_COLOR, COLOR_BLACK))
|| (ERR == init_pair(EVENT_CAPTION_COLOR_PAIR, EVENT_CAPTION_COLOR,
COLOR_BLACK))
|| (ERR == init_pair(SCORE_COLOR_PAIR, SCORE_COLOR, COLOR_BLACK))
|| (ERR == init_pair(CREDIT_COLOR_PAIR, CREDIT_COLOR, COLOR_BLACK))
|| (ERR
== init_pair(CANVAS_FRAME_COLOR_PAIR, CANVAS_FRAME_COLOR, COLOR_BLACK))) {
emit_log(&error_logger,
"Failed to change the ncurses setting to define color pair");
goto cleanup;
}
}
/* Execute game loop */
scene = -1;
next_scene = TITLE_SCENE;
while (1) {
/* Record the frame starting time */
if (0 != gettimeofday(&frame_start_time, NULL)) {
emit_log(&error_logger, "Failed to get time of frame starting");
goto cleanup;
}
/* Change the next scene if needed */
if (scene != next_scene) {
scene = next_scene;
if (INGAME_SCENE == scene) {
reset_game(&game);
}
}
/* Update the objects */
if (TITLE_SCENE == scene) {
update_game_on_title_scene(&next_scene);
} else if (INGAME_SCENE == scene) {
update_game_on_ingame_scene(&game, IDEAL_FRAME_TIME, &next_scene);
}
/* Render the objects */
erase();
if (TITLE_SCENE == scene) {
draw_title_scene();
} else if (INGAME_SCENE == scene) {
draw_ingame_scene(&game);
}
draw_canvas_frame();
refresh();
/* Adjust the frame interval */
if (0 != gettimeofday(&frame_end_time, NULL)) {
emit_log(&error_logger, "Failed to get time of frame finished");
goto cleanup;
}
elapsed_msec = (frame_end_time.tv_sec - frame_start_time.tv_sec) * 1000L
+ (frame_end_time.tv_usec - frame_start_time.tv_usec) / 1000000L;
wait_msec = IDEAL_FRAME_TIME - elapsed_msec;
if (0L < wait_msec) {
wait_time.tv_sec = 0;
wait_time.tv_nsec = wait_msec * 1000000L;
while (-1 == nanosleep(&wait_time, &left_time)) {
if (EINTR == errno) {
memcpy(&wait_time, &left_time, sizeof(struct timespec));
} else {
if (0 == strerror_r(errno, errmsg, sizeof(errmsg))) {
emit_log(
&error_logger,
"Failed to sleep until the end of frame: errmsg=%s, sleeping_msec=%ld",
errmsg, wait_msec);
} else {
emit_log(&error_logger, "Failed to get error message: errno=%d",
errno);
}
goto cleanup;
}
}
}
}
status = 0;
cleanup:
endwin();
close_logger(&error_logger);
return status;
}
void update(int mili) {
Byte c = 0;
if (!queueEmpty(&keys)) {
c = queueGet(&keys);
if (c == ESC_KEY)
exit(0);
}
Bool mouseEvent = parse_mouse_event(mouseQueue, &mouse);
updateHammer(hammer, mili, c, (mouseEvent ? &mouse : NULL));
static Bool shift_flag = false;
char k;
int i, len;
switch (state) {
case PLAYING:
for (i = 0; i < NUM_PCS; i++)
updateCScreen(cscreens[i], hammer, &numPCs, &score->score, mili);
if (numPCs == 0) {
state = END;
hammer->state = GET_HAMMER;
}
updateButton(helpButton, hammer);
if (helpButton->state == CLICKED)
state = HELP;
updateButton(exitButton, hammer);
if (exitButton->state == CLICKED)
exit(0);
break;
case END:
if (hammer->state == HIT) {
state = SCORE;
highScore = isHighScore(highScores, score);
}
updateButton(helpButton, hammer);
if (helpButton->state == CLICKED)
state = HELP;
updateButton(exitButton, hammer);
if (exitButton->state == CLICKED)
exit(0);
break;
case SCORE:
if (highScore) {
if (c != 0) {
if (c == SHIFT_KEY) {
shift_flag = true;
}
if (c == (SHIFT_KEY | RELEASED)) {
shift_flag = false;
break;
}
if (c == BACKSPACE_KEY) {
len = strlen(score->name);
if (len > 0) {
score->name[len - 1] = NULL;
}
break;
}
k = scancodeToAscii(c);
if (k != 0) {
len = strlen(score->name);
if (len < SCORE_NAME_LEN) {
score->name[len] = (shift_flag ? toupper(k) : k);
score->name[len + 1] = NULL;
}
}
}
}
if (hammer->state == HIT && (!highScore || (c != SPACE_KEY && score->name[0] != NULL))) {
if (highScore) {
putScore(highScores, score);
saveHighScores(highScores);
}
reset_game();
state = PLAYING;
}
break;
case HELP:
if (hammer->state == HIT)
state = PLAYING;
break;
default:
break;
}
}
