/* read_config:
* Load settings from the configuration file, providing default values
*/
void read_global_config(const char *config)
{
ALLEGRO_CONFIG *c = al_load_config_file(config);
if (!c) c = al_create_config();
fullscreen = get_config_int(c, "GFX", "fullscreen", fullscreen);
bit_depth = get_config_int(c, "GFX", "bit_depth", bit_depth);
screen_width = get_config_int(c, "GFX", "screen_width", screen_width);
screen_height = get_config_int(c, "GFX", "screen_height", screen_height);
window_width = get_config_int(c, "GFX", "window_width", window_height);
window_height = get_config_int(c, "GFX", "window_height", screen_height);
screen_samples = get_config_int(c, "GFX", "samples", screen_samples);
use_vsync = get_config_int(c, "GFX", "vsync", use_vsync);
logic_framerate =
get_config_int(c, "TIMING", "logic_framerate", logic_framerate);
limit_framerate =
get_config_int(c, "TIMING", "limit_framerate", limit_framerate);
max_frame_skip =
get_config_int(c, "TIMING", "max_frame_skip", max_frame_skip);
display_framerate =
get_config_int(c, "TIMING", "display_framerate", display_framerate);
reduce_cpu_usage =
get_config_int(c, "TIMING", "reduce_cpu_usage", reduce_cpu_usage);
sound_volume = get_config_int(c, "SOUND", "sound_volume", sound_volume);
music_volume = get_config_int(c, "SOUND", "music_volume", music_volume);
set_sound_volume(sound_volume / 10.0);
set_music_volume(music_volume / 10.0);
controller_id = get_config_int(c, "CONTROLS", "controller_id", controller_id);
al_destroy_config(c);
}
bool init_sound()
{
VALIDATE(sample_rate, "must call set_play_params before init_sound!");
LOG_AUDIO << "Initializing audio...\n";
if (SDL_WasInit(SDL_INIT_AUDIO) == 0)
if (SDL_InitSubSystem(SDL_INIT_AUDIO) == -1) {
return false;
}
if (!mix_ok) {
if(Mix_OpenAudio(sample_rate, MIX_DEFAULT_FORMAT, 2, buffer_size) == -1) {
mix_ok = false;
ERR_AUDIO << "Could not initialize audio: " << Mix_GetError() << "\n";
return false;
}
mix_ok = true;
Mix_AllocateChannels(n_of_channels);
Mix_ReserveChannels(n_reserved_channels);
channel_chunks.clear();
channel_chunks.resize(n_of_channels, NULL);
channel_ids.resize(n_of_channels, -1);
Mix_GroupChannel(bell_channel, SOUND_BELL);
Mix_GroupChannel(timer_channel, SOUND_TIMER);
Mix_GroupChannels(source_channel_start, source_channel_last, SOUND_SOURCES);
Mix_GroupChannel(UI_sound_channel, SOUND_UI);
Mix_GroupChannels(n_reserved_channels, n_of_channels - 1, SOUND_FX);
set_sound_volume(preferences::sound_volume());
set_UI_volume(preferences::UI_volume());
set_music_volume(preferences::music_volume());
set_bell_volume(preferences::bell_volume());
Mix_ChannelFinished(channel_finished_hook);
LOG_AUDIO << "Audio initialized.\n";
{
int ii = 0;
// play_music();
}
}
return true;
}
bool init_sound() {
LOG_AUDIO << "Initializing audio...\n";
if(SDL_WasInit(SDL_INIT_AUDIO) == 0)
if(SDL_InitSubSystem(SDL_INIT_AUDIO) == -1)
return false;
if(!mix_ok) {
if(Mix_OpenAudio(preferences::sample_rate(), MIX_DEFAULT_FORMAT, 2, preferences::sound_buffer_size()) == -1) {
mix_ok = false;
ERR_AUDIO << "Could not initialize audio: " << Mix_GetError() << std::endl;
return false;
}
mix_ok = true;
Mix_AllocateChannels(n_of_channels);
Mix_ReserveChannels(n_reserved_channels);
channel_chunks.clear();
channel_chunks.resize(n_of_channels, nullptr);
channel_ids.resize(n_of_channels, -1);
Mix_GroupChannel(bell_channel, SOUND_BELL);
Mix_GroupChannel(timer_channel, SOUND_TIMER);
Mix_GroupChannels(source_channel_start, source_channel_last, SOUND_SOURCES);
Mix_GroupChannels(UI_sound_channel_start, UI_sound_channel_last, SOUND_UI);
Mix_GroupChannels(n_reserved_channels, n_of_channels - 1, SOUND_FX);
set_sound_volume(preferences::sound_volume());
set_UI_volume(preferences::UI_volume());
set_music_volume(preferences::music_volume());
set_bell_volume(preferences::bell_volume());
Mix_ChannelFinished(channel_finished_hook);
LOG_AUDIO << "Audio initialized.\n";
DBG_AUDIO << "Channel layout: " << n_of_channels << " channels (" << n_reserved_channels << " reserved)\n"
<< " " << bell_channel << " - bell\n"
<< " " << timer_channel << " - timer\n"
<< " " << source_channel_start << ".." << source_channel_last << " - sound sources\n"
<< " " << UI_sound_channel_start << ".." << UI_sound_channel_last << " - UI\n"
<< " " << UI_sound_channel_last + 1 << ".." << n_of_channels - 1 << " - sound effects\n";
play_music();
}
return true;
}
void
ConfigManager::apply(const Options& opts)
{
m_opts.merge(opts);
if (m_opts.framebuffer_type.is_set())
set_renderer(m_opts.framebuffer_type.get());
else
set_renderer(SDL_FRAMEBUFFER);
if (opts.master_volume.is_set())
set_master_volume(opts.master_volume.get());
if (opts.sound_volume.is_set())
set_sound_volume(opts.sound_volume.get());
if (opts.music_volume.is_set())
set_music_volume(opts.music_volume.get());
if (opts.fullscreen_resolution.is_set())
set_fullscreen_resolution(opts.fullscreen_resolution.get());
if (opts.fullscreen.is_set())
set_fullscreen(opts.fullscreen.get());
if (opts.resizable.is_set())
set_resizable(opts.resizable.get());
if (opts.mouse_grab.is_set())
set_mouse_grab(opts.mouse_grab.get());
if (opts.print_fps.is_set())
set_print_fps(opts.print_fps.get());
if (opts.software_cursor.is_set())
set_software_cursor(opts.software_cursor.get());
if (opts.auto_scrolling.is_set())
set_auto_scrolling(opts.auto_scrolling.get());
if (opts.language.is_set())
set_language(tinygettext::Language::from_env(opts.language.get()));
}
void racing_loop( scalar_t time_step )
{
int width, height;
player_data_t *plyr = get_player_data( local_player() );
bool_t joy_paddling = False;
bool_t joy_braking = False;
bool_t joy_charging = False;
bool_t airborne;
vector_t dir;
scalar_t speed;
scalar_t terrain_weights[NumTerrains];
int new_terrain = 0;
int slide_volume;
dir = plyr->vel;
speed = normalize_vector(&dir);
airborne = plyr->airborne;
width = getparam_x_resolution();
height = getparam_y_resolution();
check_gl_error();
new_frame_for_fps_calc();
update_audio();
clear_rendering_context();
setup_fog();
/* Update braking */
plyr->control.is_braking = (bool_t) ( braking || joy_braking );
if ( airborne ) {
new_terrain = (1<<NumTerrains);
/*
* Tricks
*/
if ( trick_modifier) {
if (left_turn) {
plyr->control.barrel_roll_left = True;
}
if (right_turn) {
plyr->control.barrel_roll_right = True;
}
if (paddling) {
plyr->control.front_flip = True;
}
if (plyr->control.is_braking) {
plyr->control.back_flip = True;
}
//Par défaut ca fait un front flip
if(!plyr->control.front_flip && !plyr->control.back_flip &&
!plyr->control.barrel_roll_right && !plyr->control.barrel_roll_left )
{
plyr->control.back_flip = True;
}
#ifdef __APPLE__
TRDebugLog("tricks : %d",plyr->tricks);
#endif
}
} else {
get_surface_type(plyr->pos.x, plyr->pos.z, terrain_weights);
if (terrain_weights[Snow] > 0) {
new_terrain |= (1<<Snow);
}
if (terrain_weights[Rock] > 0) {
new_terrain |= (1<<Rock);
}
if (terrain_weights[Ice] > 0) {
new_terrain |= (1<<Ice);
}
}
/*
* Jumping
*/
calc_jump_amt( time_step );
if ( ( charging || joy_charging ) &&
!plyr->control.jump_charging && !plyr->control.jumping )
{
plyr->control.jump_charging = True;
charge_start_time = g_game.time;
}
if ( ( !charging && !joy_charging ) && plyr->control.jump_charging ) {
plyr->control.jump_charging = False;
plyr->control.begin_jump = True;
}
/*
* Turning
*/
scalar_t iPhone_turn_fact=accelerometerTurnFact();
iPhone_turn_fact=accelerometerTurnFact();
/*left_turn and right_turn are informations useful for tricks*/
if (iPhone_turn_fact>TURN_FACTOR_LIMIT) {
left_turn=false;
right_turn=true;
}
else if (iPhone_turn_fact<-TURN_FACTOR_LIMIT) {
left_turn=true;
right_turn=false;
} else left_turn = right_turn = false;
plyr->control.turn_fact = iPhone_turn_fact;
plyr->control.turn_animation = iPhone_turn_fact;
/*
* Paddling
*/
if ( ( paddling || joy_paddling ) && plyr->control.is_paddling == False ) {
plyr->control.is_paddling = True;
plyr->control.paddle_time = g_game.time;
}
/*
* Play flying sound (__APPLE__ : and add Flying time to plyr->control.fly_total_time)
*/
if (new_terrain & (1<<NumTerrains)) {
set_sound_volume("flying_sound", min(128, speed*2));
if (!(last_terrain & (1<<NumTerrains))) {
play_sound( "flying_sound", -1 );
plyr->control.is_flying=true;
plyr->control.fly_start_time = g_game.time;
}
} else {
if (last_terrain & (1<<NumTerrains)) {
plyr->control.is_flying=false;
plyr->control.fly_end_time = g_game.time;
if (plyr->control.fly_end_time-plyr->control.fly_start_time>FLYING_TIME_LIMIT) {
plyr->control.fly_total_time += plyr->control.fly_end_time-plyr->control.fly_start_time;
}
halt_sound( "flying_sound" );
}
}
/*
* Play sliding sound
*/
slide_volume = min( (((pow(plyr->control.turn_fact, 2)*128)) +
(plyr->control.is_braking?128:0) +
(plyr->control.jumping?128:0) +
20) *
(speed/10), 128 );
if (new_terrain & (1<<Snow)) {
set_sound_volume("snow_sound", slide_volume * terrain_weights[Snow]);
if (!(last_terrain & (1<<Snow))) {
play_sound( "snow_sound", -1 );
}
} else {
if (last_terrain & (1<<Snow)) {
halt_sound( "snow_sound" );
}
}
if (new_terrain & (1<<Rock)) {
//set_sound_volume("rock_sound", 128*pow((speed/2), 2) * terrain_weights[Rock]);
int rockvol = slide_volume * 10 * terrain_weights[Rock];
if (rockvol > 400)
rockvol = 400;
set_sound_volume("rock_sound", rockvol);
if (!(last_terrain & (1<<Rock))) {
play_sound( "rock_sound", -1 );
}
} else {
if (last_terrain & (1<<Rock)) {
halt_sound( "rock_sound" );
}
}
if (new_terrain & (1<<Ice)) {
set_sound_volume("ice_sound", slide_volume * terrain_weights[Ice]);
if (!(last_terrain & (1<<Ice))) {
play_sound( "ice_sound", -1 );
}
} else {
if (last_terrain & (1<<Ice)) {
halt_sound( "ice_sound" );
}
}
last_terrain = new_terrain;
/*
* gs
*/
bool roll = plyr->control.barrel_roll_left || plyr->control.barrel_roll_right;
bool flip = plyr->control.front_flip || plyr->control.back_flip;
if(roll && plyr->control.barrel_roll_factor == 0)
{
if(flip)
{
if(plyr->control.barrel_roll_left)
add_new_bonus("Hyper heavy Jump", get_score_for_trick(HYPER_HEAVY_JUMP));
else
add_new_bonus("Ray star hybrid Jump", get_score_for_trick(RAY_STAR_HYBRID_JUMP));
}
else
{
if(plyr->control.barrel_roll_left)
add_new_bonus("Roll Left", get_score_for_trick(ROLL_LEFT));
else
add_new_bonus("Roll Right", get_score_for_trick(ROLL_RIGHT));
}
}
if(flip && plyr->control.flip_factor == 0)
{
if(roll)
{
if(plyr->control.back_flip)
add_new_bonus("Saturn ice Fever", get_score_for_trick(SATURN_ICE_FEVER));
else
add_new_bonus("Wild pinguin Show", get_score_for_trick(WILD_PINGUIN_SHOW));
}
else
{
if(plyr->control.back_flip)
add_new_bonus("Back Flip", get_score_for_trick(BACK_FLIP));
else
add_new_bonus("Barlow's Wheel", get_score_for_trick(BARLOWS_WHEEL));
}
}
if (roll) {
plyr->tricks+=1;
plyr->control.barrel_roll_factor +=
( plyr->control.barrel_roll_left ? -1 : 1 ) * 0.05 * time_step / 0.05;
if ( (plyr->control.barrel_roll_factor > 1) ||
(plyr->control.barrel_roll_factor < -1) ) {
plyr->control.barrel_roll_factor = 0;
plyr->control.barrel_roll_left = plyr->control.barrel_roll_right = False;
}
}
if (flip) {
plyr->tricks+=1;
plyr->control.flip_factor +=
( plyr->control.back_flip ? -1 : 1 ) * 0.05 * time_step / 0.05;
if ( (plyr->control.flip_factor > 1) ||
(plyr->control.flip_factor < -1) ) {
plyr->control.flip_factor = 0;
plyr->control.front_flip = plyr->control.back_flip = False;
}
}
update_player_pos( plyr, time_step );
/*
* Track Marks
*/
add_track_mark( plyr );
update_view( plyr, time_step );
setup_view_frustum( plyr, NEAR_CLIP_DIST,
getparam_forward_clip_distance() );
draw_sky(plyr->view.pos);
draw_fog_plane();
set_course_clipping( True );
set_course_eye_point( plyr->view.pos );
setup_course_lighting();
render_course();
draw_trees();
if ( getparam_draw_particles() ) {
update_particles( time_step );
draw_particles( plyr );
}
draw_tux();
draw_tux_shadow();
draw_hud( plyr );
draw_hud_training(plyr);
reshape( width, height );
winsys_swap_buffers();
g_game.time += time_step;
}
void
Racing::loop(float timeStep)
{
int width, height;
bool joy_left_turn = false;
bool joy_right_turn = false;
double joy_turn_fact = 0.0;
bool joy_paddling = false;
bool joy_braking = false;
bool joy_tricks = false;
bool joy_charging = false;
bool airborne;
pp::Vec3d dir;
float speed;
float terrain_weights[NUM_TERRAIN_TYPES];
int new_terrain = 0;
int slide_volume;
unsigned int i;
if (Benchmark::getMode() == Benchmark::AUTO){
m_paddling = true;
}
dir = players[0].vel;
speed = dir.normalize();
//set max_speed
if (speed > players[0].max_speed) players[0].max_speed=int(speed);
airborne = (bool) ( players[0].pos.y > ( find_y_coord(players[0].pos.x,
players[0].pos.z) +
JUMP_MAX_START_HEIGHT ) );
width = getparam_x_resolution();
height = getparam_y_resolution();
fpsCounter.update();
update_audio();
clear_rendering_context();
fogPlane.setup();
// Joystick
if ( is_joystick_active() ) {
float joy_x;
float joy_y;
update_joystick();
joy_x = get_joystick_x_axis();
joy_y = get_joystick_y_axis();
if ( joy_x > 0.1 ) {
joy_right_turn = true;
joy_turn_fact = joy_x;
} else if ( joy_x < -0.1 ) {
joy_left_turn = true;
joy_turn_fact = joy_x;
}
if ( getparam_joystick_brake_button() >= 0 ) {
joy_braking =
is_joystick_button_down( getparam_joystick_brake_button() );
}
if ( !joy_braking ) {
joy_braking = (bool) ( joy_y > 0.5 );
}
if ( getparam_joystick_paddle_button() >= 0 ) {
joy_paddling =
is_joystick_button_down( getparam_joystick_paddle_button() );
}
if ( !joy_paddling ) {
joy_paddling = (bool) ( joy_y < -0.5 );
}
if ( getparam_joystick_jump_button() >= 0 ) {
joy_charging =
is_joystick_button_down( getparam_joystick_jump_button() );
}
if ( getparam_joystick_trick_button() >= 0 ) {
joy_tricks =
is_joystick_button_down( getparam_joystick_trick_button() );
}
}
// Update braking
players[0].control.is_braking = (bool) ( m_braking || joy_braking );
if ( airborne ) {
new_terrain = (1<<4);
// Tricks
if ( m_trickModifier || joy_tricks ) {
if ( m_leftTurn || joy_left_turn ) {
players[0].control.barrel_roll_left = true;
}
if ( m_rightTurn || joy_right_turn ) {
players[0].control.barrel_roll_right = true;
}
if ( m_paddling || joy_paddling ) {
players[0].control.front_flip = true;
}
if ( players[0].control.is_braking ) {
players[0].control.back_flip = true;
}
}
for(i=0;i<num_terrains;i++){
if ( !terrain_texture[i].sound.empty() && terrain_texture[i].soundactive==true) {
halt_sound( terrain_texture[i].sound.c_str() );
terrain_texture[i].soundactive=false;
}
}
} else {
get_surface_type(players[0].pos.x, players[0].pos.z, terrain_weights);
//Play sliding sound
slide_volume = int(MIN( (((pow(players[0].control.turn_fact, 2)*128)) +
(players[0].control.is_braking?128:0) +
(players[0].control.jumping?128:0) +
20) *
(speed/10), 128 ));
for(i=0;i<num_terrains;i++){
if ( !terrain_texture[i].sound.empty() ) {
if (terrain_weights[i] > 0 ){
set_sound_volume(terrain_texture[i].sound.c_str(), int(slide_volume * terrain_weights[i]));
if (terrain_texture[i].soundactive==false){
play_sound(terrain_texture[i].sound.c_str() , -1 );
terrain_texture[i].soundactive=true;
}
} else if (terrain_texture[i].soundactive==true){
halt_sound( terrain_texture[i].sound.c_str() );
terrain_texture[i].soundactive=false;
}
}
}
}
// Jumping
calcJumpAmt( timeStep );
if ( ( m_charging || joy_charging ) &&
!players[0].control.jump_charging && !players[0].control.jumping )
{
players[0].control.jump_charging = true;
m_chargeStartTime = gameMgr->time;
}
if ( ( !m_charging && !joy_charging ) && players[0].control.jump_charging ) {
players[0].control.jump_charging = false;
players[0].control.begin_jump = true;
}
// Turning
if ( ( m_leftTurn || joy_left_turn ) ^ (m_rightTurn || joy_right_turn ) ) {
bool turning_left = (bool) ( m_leftTurn || joy_left_turn );
if ( joy_left_turn || joy_right_turn ) {
players[0].control.turn_fact = joy_turn_fact;
} else {
players[0].control.turn_fact = (turning_left?-1:1);
}
players[0].control.turn_animation += (turning_left?-1:1) *
0.15 * timeStep / 0.05;
players[0].control.turn_animation =
MIN(1.0, MAX(-1.0, players[0].control.turn_animation));
} else {
players[0].control.turn_fact = 0;
// Decay turn animation
if ( timeStep < ROLL_DECAY_TIME_CONSTANT ) {
players[0].control.turn_animation *=
1.0 - timeStep/ROLL_DECAY_TIME_CONSTANT;
} else {
players[0].control.turn_animation = 0.0;
}
}
//Paddling
if ( ( m_paddling || joy_paddling ) && players[0].control.is_paddling == false ) {
players[0].control.is_paddling = true;
players[0].control.paddle_time = gameMgr->time;
}
//Play flying sound
if (new_terrain & (1<<4)) {
set_sound_volume("flying_sound", int(MIN(128, speed*2)));
if (!(m_lastTerrain & (1<<4))) {
play_sound( "flying_sound", -1 );
}
} else {
if (m_lastTerrain & (1<<4)) {
halt_sound( "flying_sound" );
}
}
m_lastTerrain = new_terrain;
//Tricks
if ( players[0].control.barrel_roll_left || players[0].control.barrel_roll_right ) {
players[0].control.barrel_roll_factor +=
( players[0].control.barrel_roll_left ? -1 : 1 ) * 0.15 * timeStep / 0.05;
if ( (players[0].control.barrel_roll_factor > 1) ||
(players[0].control.barrel_roll_factor < -1) ) {
players[0].control.barrel_roll_factor = 0;
players[0].control.barrel_roll_left = players[0].control.barrel_roll_right = false;
}
}
if ( players[0].control.front_flip || players[0].control.back_flip ) {
players[0].control.flip_factor +=
( players[0].control.back_flip ? -1 : 1 ) * 0.15 * timeStep / 0.05;
if ( (players[0].control.flip_factor > 1) ||
(players[0].control.flip_factor < -1) ) {
players[0].control.flip_factor = 0;
players[0].control.front_flip = players[0].control.back_flip = false;
}
}
update_player_pos( players[0], timeStep );
//Track Marks
add_track_mark( players[0] );
update_view( players[0], timeStep );
setup_view_frustum( players[0], NEAR_CLIP_DIST,
getparam_forward_clip_distance() );
draw_sky(players[0].view.pos);
draw_fog_plane();
set_course_clipping( true );
set_course_eye_point( players[0].view.pos );
setup_course_lighting();
render_course();
//Draw snow
update_snow( timeStep, false, players[0].view.pos );
draw_snow(players[0].view.pos);
draw_trees();
if ( getparam_draw_particles() ) {
update_particles( timeStep );
draw_particles( players[0] );
}
ModelHndl->draw_tux();
draw_tux_shadow();
HUD1.draw(players[0]);
reshape( width, height );
winsys_swap_buffers();
gameMgr->time += timeStep;
if (airborne) gameMgr->airbornetime += timeStep;
if(Benchmark::getMode() == Benchmark::PAUSED){
set_game_mode(PAUSED);
}
}
void main()
{
int i;
char *ptr;
vdp_set_address(0x8004); // mode 4, disable hbl irq
vdp_set_address(0x8160); // screen on, enable vbl irq
vdp_set_address(0x820e); // name table @ $3800
vdp_set_address(0x85ff); // sprite table @ $3f00
vdp_set_address(0x8700); // backdrop is color 0
vdp_set_address(0x8800); // scrollx is 0
vdp_set_address(0x8900); // scrolly is 0
vdp_set_address(0xc000);
ptr = pal;
for (i=0; i<32; i++) {
vdp_write(*ptr++);
}
// turn off sprites
vdp_set_address(0x3f00);
vdp_write(0xd0);
//Sound off - if resetted from a prior game
set_sound_volume(0,0);
set_sound_volume(1,0);
set_sound_volume(2,0);
set_sound_volume(3,0);
while (1) {
console_init();
console_clear();
console_gotoxy(3,0);
console_puts("MASTER SYSTEM ROM LOADER\n");
console_gotoxy(3,1);
console_puts("------------------------\n");
//console_gotoxy(3,3);
i = 0;
if (!sd_init()) {
console_puts("Error initializing SD/MMC card\n");
} else {
#ifdef DEBUG2
console_puts("SD card initialized\n");
#endif
if (!fat_init()) {
//console_puts("could not initialize FAT system\n"); //qq
} else {
#ifdef DEBUG2
console_puts("FAT system initialized\n");
#endif
i = 1;
}
}
choose_mode(i);
}
}
void racing_loop( scalar_t time_step )
{
int width, height;
player_data_t *plyr = get_player_data( local_player() );
bool_t joy_left_turn = False;
bool_t joy_right_turn = False;
scalar_t joy_turn_fact = 0.0;
bool_t joy_paddling = False;
bool_t joy_braking = False;
bool_t joy_tricks = False;
bool_t joy_charging = False;
bool_t airborne;
vector_t dir;
scalar_t speed;
scalar_t terrain_weights[NumTerrains];
int new_terrain = 0;
int slide_volume;
dir = plyr->vel;
speed = normalize_vector(&dir);
airborne = (bool_t) ( plyr->pos.y > ( find_y_coord(plyr->pos.x,
plyr->pos.z) +
JUMP_MAX_START_HEIGHT ) );
width = getparam_x_resolution();
height = getparam_y_resolution();
check_gl_error();
new_frame_for_fps_calc();
update_audio();
clear_rendering_context();
setup_fog();
/*
* Joystick
*/
if ( is_joystick_active() ) {
scalar_t joy_x;
scalar_t joy_y;
update_joystick();
joy_x = get_joystick_x_axis();
joy_y = get_joystick_y_axis();
if ( joy_x > 0.1 ) {
joy_right_turn = True;
joy_turn_fact = joy_x;
} else if ( joy_x < -0.1 ) {
joy_left_turn = True;
joy_turn_fact = joy_x;
}
if ( getparam_joystick_brake_button() >= 0 ) {
joy_braking =
is_joystick_button_down( getparam_joystick_brake_button() );
}
if ( !joy_braking ) {
joy_braking = (bool_t) ( joy_y > 0.5 );
}
if ( getparam_joystick_paddle_button() >= 0 ) {
joy_paddling =
is_joystick_button_down( getparam_joystick_paddle_button() );
}
if ( !joy_paddling ) {
joy_paddling = (bool_t) ( joy_y < -0.5 );
}
if ( getparam_joystick_jump_button() >= 0 ) {
joy_charging =
is_joystick_button_down( getparam_joystick_jump_button() );
}
if ( getparam_joystick_trick_button() >= 0 ) {
joy_tricks =
is_joystick_button_down( getparam_joystick_trick_button() );
}
}
/* Update braking */
plyr->control.is_braking = (bool_t) ( braking || joy_braking );
if ( airborne ) {
new_terrain = (1<<NumTerrains);
/*
* Tricks
*/
if ( trick_modifier || joy_tricks ) {
if ( left_turn || joy_left_turn ) {
plyr->control.barrel_roll_left = True;
}
if ( right_turn || joy_right_turn ) {
plyr->control.barrel_roll_right = True;
}
if ( paddling || joy_paddling ) {
plyr->control.front_flip = True;
}
if ( plyr->control.is_braking ) {
plyr->control.back_flip = True;
}
}
} else {
get_surface_type(plyr->pos.x, plyr->pos.z, terrain_weights);
if (terrain_weights[Snow] > 0) {
new_terrain |= (1<<Snow);
}
if (terrain_weights[Rock] > 0) {
new_terrain |= (1<<Rock);
}
if (terrain_weights[Ice] > 0) {
new_terrain |= (1<<Ice);
}
}
/*
* Jumping
*/
calc_jump_amt( time_step );
if ( ( charging || joy_charging ) &&
!plyr->control.jump_charging && !plyr->control.jumping )
{
plyr->control.jump_charging = True;
charge_start_time = g_game.time;
}
if ( ( !charging && !joy_charging ) && plyr->control.jump_charging ) {
plyr->control.jump_charging = False;
plyr->control.begin_jump = True;
}
/*
* Turning
*/
if ( ( left_turn || joy_left_turn ) ^ (right_turn || joy_right_turn ) ) {
bool_t turning_left = (bool_t) ( left_turn || joy_left_turn );
if ( joy_left_turn || joy_right_turn ) {
plyr->control.turn_fact = joy_turn_fact;
} else {
plyr->control.turn_fact = (turning_left?-1:1);
}
plyr->control.turn_animation += (turning_left?-1:1) *
0.15 * time_step / 0.05;
plyr->control.turn_animation =
min(1.0, max(-1.0, plyr->control.turn_animation));
} else {
plyr->control.turn_fact = 0;
/* Decay turn animation */
if ( time_step < ROLL_DECAY_TIME_CONSTANT ) {
plyr->control.turn_animation *=
1.0 - time_step/ROLL_DECAY_TIME_CONSTANT;
} else {
plyr->control.turn_animation = 0.0;
}
}
/*
* Paddling
*/
if ( ( paddling || joy_paddling ) && plyr->control.is_paddling == False ) {
plyr->control.is_paddling = True;
plyr->control.paddle_time = g_game.time;
}
/*
* Play flying sound
*/
if (new_terrain & (1<<NumTerrains)) {
set_sound_volume("flying_sound", min(128, speed*2));
if (!(last_terrain & (1<<NumTerrains))) {
play_sound( "flying_sound", -1 );
}
} else {
if (last_terrain & (1<<NumTerrains)) {
halt_sound( "flying_sound" );
}
}
/*
* Play sliding sound
*/
slide_volume = min( (((pow(plyr->control.turn_fact, 2)*128)) +
(plyr->control.is_braking?128:0) +
(plyr->control.jumping?128:0) +
20) *
(speed/10), 128 );
if (new_terrain & (1<<Snow)) {
set_sound_volume("snow_sound", slide_volume * terrain_weights[Snow]);
if (!(last_terrain & (1<<Snow))) {
play_sound( "snow_sound", -1 );
}
} else {
if (last_terrain & (1<<Snow)) {
halt_sound( "snow_sound" );
}
}
if (new_terrain & (1<<Rock)) {
set_sound_volume("rock_sound", 128*pow((speed/2), 2) *
terrain_weights[Rock]);
if (!(last_terrain & (1<<Rock))) {
play_sound( "rock_sound", -1 );
}
} else {
if (last_terrain & (1<<Rock)) {
halt_sound( "rock_sound" );
}
}
if (new_terrain & (1<<Ice)) {
set_sound_volume("ice_sound", slide_volume * terrain_weights[Ice]);
if (!(last_terrain & (1<<Ice))) {
play_sound( "ice_sound", -1 );
}
} else {
if (last_terrain & (1<<Ice)) {
halt_sound( "ice_sound" );
}
}
last_terrain = new_terrain;
/*
* Tricks
*/
if ( plyr->control.barrel_roll_left || plyr->control.barrel_roll_right ) {
plyr->control.barrel_roll_factor +=
( plyr->control.barrel_roll_left ? -1 : 1 ) * 0.15 * time_step / 0.05;
if ( (plyr->control.barrel_roll_factor > 1) ||
(plyr->control.barrel_roll_factor < -1) ) {
plyr->control.barrel_roll_factor = 0;
plyr->control.barrel_roll_left = plyr->control.barrel_roll_right = False;
}
}
if ( plyr->control.front_flip || plyr->control.back_flip ) {
plyr->control.flip_factor +=
( plyr->control.back_flip ? -1 : 1 ) * 0.15 * time_step / 0.05;
if ( (plyr->control.flip_factor > 1) ||
(plyr->control.flip_factor < -1) ) {
plyr->control.flip_factor = 0;
plyr->control.front_flip = plyr->control.back_flip = False;
}
}
update_player_pos( plyr, time_step );
/*
* Track Marks
*/
add_track_mark( plyr );
update_view( plyr, time_step );
setup_view_frustum( plyr, NEAR_CLIP_DIST,
getparam_forward_clip_distance() );
draw_sky(plyr->view.pos);
draw_fog_plane();
set_course_clipping( True );
set_course_eye_point( plyr->view.pos );
setup_course_lighting();
render_course();
draw_trees();
if ( getparam_draw_particles() ) {
update_particles( time_step );
draw_particles( plyr );
}
draw_tux();
draw_tux_shadow();
draw_hud( plyr );
reshape( width, height );
winsys_swap_buffers();
g_game.time += time_step;
}
void screen_play_screen_update(int *screen_type, int curr_joypad1, int prev_joypad1)
{
unsigned char check, detectX, detectY, missY, overX;
engine_tile_manager_update_middle();
engine_tile_manager_update_bottom();
engine_gamer_manager_update_target(curr_joypad1);
engine_gamer_manager_update_bullets();
engine_enemy_manager_update_enemies();
if (curr_joypad1 & JOY_FIREA && !(prev_joypad1 & JOY_FIREA))
{
engine_gamer_manager_trigger_bullet();
}
// Bullet vs. enemy collision detection.
if (1 == bulletCheck[0] || 1 == bulletCheck[1] || 1 == bulletCheck[2])
{
screen_play_bullet_collide();
}
// Invincibility.
if (hacker_death)
{
return;
}
// Target vs. enemy collision detection.
overX = 0;
if (1 == enemyCheck[0] || 1 == enemyCheck[1] || 1 == enemyCheck[2])
{
for (check = 0; check < hacker_enemy; ++check)
{
if (1 != enemyCheck[check])
{
continue;
}
enemyCheck[check] = 0;
detectX = targetX + TARGET_BOUND;
detectY = targetY + TARGET_BOUND;
// Enemy collides with target.
if (detectX >= enemyX[check] && detectX <= enemyX[check] + TARGET_WIDTH &&
detectY >= enemyY[check] && detectY <= enemyY[check] + TARGET_WIDTH)
{
overX = 1;
break;
}
else
{
// Target has maximum misses.
engine_sprite_manager_draw_enemies(enemyIndex[check], enemyX[check], enemyY[check], 0);
screen_play_screen_miss++;
// Very short sound.
if (hacker_sound)
{
set_sound_freq(1, 100);
set_sound_volume(1, 0x0F);
}
missY = ((MAX_MISS_NUM + 2 - screen_play_screen_miss) * 2) + screen_play_screen_miss;
engine_font_manager_draw_text("X", 31, missY);
if (screen_play_screen_miss >= MAX_MISS_NUM)
{
overX = 1;
break;
}
}
}
}
// GAME OVER!
if (0 != overX)
{
if (hacker_music)
{
engine_music_manager_pause_module();
}
*screen_type = 6;//screen_type_over;
}
}
