void set_waveform(struct wave * const wave, enum waveform waveform)
{
wave->settings.waveform = waveform;
// Reset state
reset_wave(wave);
}
static void
reset_level(void)
{
memset(&level_stat_counters, 0, sizeof(level_stat_counters));
if (gc.cur_level == settings.static_settings->start_level)
gc.cur_wave = settings.static_settings->start_wave;
else
gc.cur_wave = 0;
reset_wave();
}
static int do_stream_wave(WAVE_PLAY *p_wave_play)
{
int bytes_read=0;
char is_done=0;
int cur_buffer;
MMRESULT out_write_ret=MMSYSERR_NOERROR;
is_done=fill_wave_buffer(p_wave_play,p_wave_play->cur_buffer,&bytes_read);
p_wave_play->win_data.whdr[p_wave_play->cur_buffer].dwBufferLength=bytes_read;
cur_buffer=p_wave_play->cur_buffer;
p_wave_play->cur_buffer=(p_wave_play->cur_buffer + 1)%2;
out_write_ret=waveOutWrite(p_wave_play->win_data.hwave,&(p_wave_play->win_data.whdr[cur_buffer]), sizeof(WAVEHDR));
if (MMSYSERR_NOERROR==out_write_ret) {
DBG_PRINTF((LOG_DEBUG, "D:" MODULE_TAG "waveOutWrite success in function do_stream_wave...\n"));
}
else {
DBG_PRINTF((LOG_CRIT, "C:" MODULE_TAG "waveOutWrite failed in function do_stream_wave, " \
"with error code: %d: %s. Try increasing wave output buffer...\n",out_write_ret,wave_error_get_name(out_write_ret)));
/*
avoid deadlock in case cbWavePlay above never gets a callback
*/
ReleaseSemaphore(p_wave_play->win_data.hBuffSem,1,NULL);
}
if (is_done) {
return (!(reset_wave(p_wave_play)));
}
return is_done;
}
static void
update_inner_state(void)
{
static int prev_level_tics;
inner_state.tics++;
switch (inner_state.state) {
case IS_WAVE_TITLE:
if (inner_state.tics >= WAVE_TITLE_TICS) {
set_inner_state(IS_IN_GAME);
/* set_inner_state(IS_PRE_WAVE_CLEARED); */
} else {
if (inner_state.tics == WAVE_TITLE_TICS/2) {
if (!ship.is_alive)
spawn_new_ship();
else
reset_ship();
}
}
break;
case IS_IN_GAME:
level_stat_counters.tics++;
game_stat_counters.tics++;
if (gc.tics_remaining <= 0) {
/* boom. */
hit_ship(&ship.pos, 1.f);
trigger_game_over();
} else {
gc.tics_remaining--;
if (!ship.is_alive) {
prev_level_tics = inner_state.tics;
set_inner_state(IS_RESPAWNING_SHIP);
} else if (!gc.foes_left) {
level_stat_counters.waves++;
game_stat_counters.waves++;
if (gc.tics_remaining > TIME_BONUS_MIN_TICS)
gc.score += gc.tics_remaining*TIME_BONUS_PER_TIC;
set_inner_state(IS_PRE_WAVE_CLEARED);
} else {
spawn_new_foes();
}
}
break;
case IS_PRE_WAVE_CLEARED:
if (inner_state.tics >= PRE_WAVE_CLEARED_TICS) {
gen_ship_implosion();
reset_powerups();
reset_missiles();
reset_bombs();
reset_lasers();
vec2_set(&ship.pos, 0.f, 0.f); /* HACK */
play_fx(FX_WAVE_TRANSITION);
set_inner_state(IS_WAVE_CLEARED);
}
break;
case IS_RESPAWNING_SHIP:
if (inner_state.tics >= TICS_UNTIL_RESPAWN) {
if (gc.ships_left) {
spawn_new_ship();
set_inner_state(IS_IN_GAME);
inner_state.tics = prev_level_tics;
} else {
trigger_game_over();
}
}
break;
case IS_GAME_OVER:
break;
case IS_RANK:
if (inner_state.tics >= RANK_TOTAL_TICS) {
stop_music();
if (is_highscore(gc.score)) {
set_inner_state(IS_HIGHSCORE_INPUT);
SDL_ShowCursor(SDL_ENABLE);
start_highscore_input();
} else {
/* loser. */
SDL_ShowCursor(SDL_ENABLE);
start_main_menu();
}
}
break;
case IS_WAVE_CLEARED:
if (gc.cur_wave == levels[gc.cur_level]->num_waves - 1 &&
inner_state.tics >= WAVE_CLEARED_TICS/2) {
initialize_stats_table(&level_stat_counters);
set_inner_state(IS_LEVEL_CLEARED);
} else if (inner_state.tics >= WAVE_CLEARED_TICS) {
gc.cur_wave++;
assert(gc.cur_wave < levels[gc.cur_level]->num_waves);
reset_wave();
set_inner_state(IS_WAVE_TITLE);
}
break;
case IS_HIGHSCORE_INPUT:
break;
case IS_LEVEL_CLEARED:
break;
case IS_LEVEL_TRANSITION:
if (inner_state.tics >= LEVEL_TRANSITION_TOTAL_TICS) {
gc.cur_level = (gc.cur_level + 1)%NUM_LEVELS;
set_inner_state(IS_WAVE_TITLE);
reset_level();
}
break;
default:
assert(0);
}
}
int play_wave_open_os(WAVE_PLAY *p_wave_play)
{
ao_device *device=NULL;
SAMPLE_FORMAT format;
int driver;
int bytes_read=0;
int is_done=0;
#ifndef NO_DYN_LOAD
static long ao_default_driver_id_ptr=(long) &ao_default_driver_id_stubb;
static long ao_open_live_ptr=(long) &ao_open_live_stubb;
static long ao_play_ptr=(long) &ao_play_stubb;
static long ao_close_ptr=(long) &ao_close_stubb;
/*static long ao_driver_id_ptr=(long) &ao_driver_id_stubb;*/
static long ao_driver_info_ptr=(long) &ao_driver_info_stubb;
#else
static long ao_default_driver_id_ptr=(long) &ao_default_driver_id;
static long ao_open_live_ptr=(long) &ao_open_live;
static long ao_play_ptr=(long) &ao_play;
static long ao_close_ptr=(long) &ao_close;
/*static long ao_driver_id_ptr=(long) &ao_driver_id;*/
static long ao_driver_info_ptr=(long) &ao_driver_info;
#endif
memset(&format,0,sizeof(ao_sample_format)); /*adapt to this type. SAMPLE_FORMAT inited below*/
/*
is_init cond/section here, needs a mutex
if more black box than present use
*/
#ifndef NO_DYN_LOAD
if (is_no_aolib)
return 1;
#endif
if (!(is_init)) {
DBG_PRINTF((LOG_CRIT, "C:" MODULE_TAG "Call to play_wave_open_os before waveout_init in play_wave_open_os...\n"));
return 1;
}
/* -- Setup for default driver -- */
if ((driver=((FUNC_2) (get_func_addr(&aolib_handle,"libao.so","ao_default_driver_id",ao_default_driver_id_ptr)))())==-1) {
DBG_PRINTF((LOG_CRIT, "C:" MODULE_TAG "ao_default_driver_id() returned NO DRIVER (%s) in play_wave_open_os...\n",libao_err_name(errno)));
}
else {
ao_info *driver_info=NULL;
if (!(driver_info=((FUNC_8) (get_func_addr(&aolib_handle,"libao.so","ao_driver_info",ao_driver_info_ptr)))(driver)))
DBG_PRINTF((LOG_CRIT, "C:" MODULE_TAG "ao_driver_info returned NULL (%s) in play_wave_open_os...\n",libao_err_name(errno)));
else
DBG_PRINTF((LOG_INFO, "I:" MODULE_TAG "got driver, %s...\n",driver_info->short_name));
format.bits=p_wave_play->bits_per_sample*p_wave_play->output_factor;
format.channels=p_wave_play->channels;
format.rate=p_wave_play->sample_rate;
format.byte_format=AO_FMT_LITTLE;
format.matrix="L,R";
device=((FUNC_3) (get_func_addr(&aolib_handle,"libao.so","ao_open_live",ao_open_live_ptr)))(driver,(ao_sample_format *) &format,NULL);
if (device==NULL) {
DBG_PRINTF((LOG_CRIT, "C:" MODULE_TAG "device NULL (%s) in play_wave_open_os. returning...\n",libao_err_name(errno)));
return 1;
}
while (!(is_done)) {
if ((is_done=fill_wave_buffer(p_wave_play,p_wave_play->cur_buffer,&bytes_read)))
is_done=(!(reset_wave(p_wave_play)));
if (bytes_read==0) {
if (is_done)
break;
}
else {
if (!(((FUNC_4) (get_func_addr(&aolib_handle,"libao.so","ao_play",ao_play_ptr)))(device,p_wave_play->wave_buff[p_wave_play->cur_buffer],bytes_read))) {
DBG_PRINTF((LOG_CRIT, "C:" MODULE_TAG "ao_play failed (%s) in play_wave_open_os...\n",libao_err_name(errno)));
}
}
if (p_wave_play->cb_is_exit(p_wave_play->cbClientData)) {
DBG_PRINTF((LOG_INFO, "I:" MODULE_TAG "Client requested quit. Returning from play_wave_open_os...\n"));
break;
}
}
}
if (device) {
wait_done_playing(p_wave_play);
if (!(((FUNC_5) (get_func_addr(&aolib_handle,"libao.so","ao_close",ao_close_ptr)))(device))) {
DBG_PRINTF((LOG_CRIT, "C:" MODULE_TAG "ao_close failed (%s) in play_wave_open_os...\n",libao_err_name(errno)));
}
}
return 0;
}
