static void
update(struct game_state *gs)
{
update_particles();
update_background();
if (irand(18) == 0)
gen_explosion(10.f*(frand() - .5f), 10.f*(frand() - .5f));
++tics;
}
static void
update(struct game_state *gs)
{
if (inner_state.state != IS_LEVEL_CLEARED &&
inner_state.state != IS_LEVEL_TRANSITION)
update_eye();
update_crosshair();
update_background();
update_water();
update_particles();
update_explosions();
if (ship_is_visible()) {
update_ship();
update_missiles();
update_bombs();
update_lasers();
update_foes();
}
update_powerups();
update_in_game_texts();
if (inner_state.state == IS_IN_GAME) {
update_multiplier();
update_combo();
}
if (inner_state.state == IS_GAME_OVER) {
if (inner_state.tics >= GAME_OVER_FADE_IN_TICS) {
if (!update_stats_table()) {
gc.score += game_over_stats.bonus;
set_inner_state(IS_RANK);
}
}
}
if (inner_state.state == IS_LEVEL_CLEARED) {
if (inner_state.tics >= LEVEL_CLEARED_FADE_IN_TICS) {
if (!update_stats_table()) {
gc.score += game_over_stats.bonus;
set_inner_state(IS_LEVEL_TRANSITION);
}
}
}
update_level_tics();
update_inner_state();
if (serializing)
serialize();
}
ENTRYPOINT void draw_providence(ModeInfo * mi)
{
providencestruct *mp;
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
if(!providence)
return;
mp = &providence[MI_SCREEN(mi)];
MI_IS_DRAWN(mi) = True;
if(!mp->glx_context)
return;
glXMakeCurrent(display, window, *(mp->glx_context));
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix();
/* modify camera */
if(fabs(mp->camera_velocity) > EPSILON) {
mp->camera_z = max(min(mp->camera_z + 0.1*mp->camera_velocity, -4.0), -12.0);
mp->camera_velocity = 0.95*mp->camera_velocity;
}
/* rotate providence */
glTranslatef(0.0, 0.0, mp->camera_z + sin(mp->theta/4.0));
glRotatef(10.0+20.0*sin(mp->theta/2.0), 1.0, 0.0, 0.0);
gltrackball_rotate(mp->trackball);
glRotatef(mp->theta * 180.0 / Pi, 0.0, -1.0, 0.0);
/* draw providence */
draw_providence_strip(mi);
glPopMatrix();
if(MI_IS_FPS(mi)) do_fps (mi);
glFlush();
glXSwapBuffers(display, window);
/* update */
mp->currenttime += 1.0 / FPS;
mp->theta = mp->currenttime / 2.0 * mp->theta_scale;
update_particles(mp);
}
static void updateFast(Layer *layer, GContext *ctx)
{
update_state();
graphics_context_set_compositing_mode(ctx, GCompOpAssign);
graphics_draw_bitmap_in_rect(ctx, s_bmap_bg, GRect(0,0,144, 168));
graphics_context_set_compositing_mode(ctx, GCompOpAssign);
sprite_draw( RESOURCE_ID_IMAGE_ROCKET, layer,ctx );
if( s_enableParticles )
{
graphics_context_set_stroke_color(ctx,GColorWhite); // ugh, fixme.
update_particles(layer,ctx);
}
}
void racing_loop (double time_step){
CControl *ctrl = Players.GetCtrl (g_game.player_id);
double ycoord = Course.FindYCoord (ctrl->cpos.x, ctrl->cpos.z);
bool airborne = (bool) (ctrl->cpos.y > (ycoord + JUMP_MAX_START_HEIGHT));
check_gl_error();
ClearRenderContext ();
Env.SetupFog ();
Music.Update ();
CalcTrickControls (ctrl, time_step, airborne);
if (!g_game.finish) CalcSteeringControls (ctrl, time_step);
else CalcFinishControls (ctrl, time_step, airborne);
PlayTerrainSound (ctrl, airborne);
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
ctrl->UpdatePlayerPos (time_step);
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
if (g_game.finish) IncCameraDistance (time_step);
update_view (ctrl, time_step);
UpdateTrackmarks (ctrl);
SetupViewFrustum (ctrl);
if (sky) Env.DrawSkybox (ctrl->viewpos);
if (fog) Env.DrawFog ();
void SetupLight ();
if (terr) RenderCourse ();
DrawTrackmarks ();
if (trees) DrawTrees ();
if (param.perf_level > 2) {
update_particles (time_step);
draw_particles (ctrl);
}
Char.Draw (g_game.char_id);
UpdateWind (time_step, ctrl);
UpdateSnow (time_step, ctrl);
DrawSnow (ctrl);
DrawHud (ctrl);
Reshape (param.x_resolution, param.y_resolution);
Winsys.SwapBuffers ();
if (g_game.finish == false) g_game.time += time_step;
}
void run_simulation(particle_t* ps, int n, FILE* fsave){
//Create partition and set active
partition* p = alloc_partition(n);
set_active_partition(p);
//Add all particles
for(int i=0; i<n; i++)
add_particle(&ps[i]);
//For each step
for(int step = 0; step < NSTEPS; step++ ){
update_particles();
//=== Save state to file ===
if( fsave && (step%SAVEFREQ) == 0 )
save( fsave, n, particles );
}
}
void update_player()
{
extern int ticks; // FROM GAME.C
update_near_blocks();
update_particles();
update_sprites();
if (current_player.vx >= current_player.max_speed ||
current_player.vx <= -current_player.max_speed){
current_player.state |= (1<<6);
} else {
current_player.state &= ~(1<<6);
}
if (current_player.near_blocks & ((1 << 0))){ //SOLID BLOCK BELLOW
if (current_player.state & (1<<7)){ // if plummeting
if (current_player.vy >= current_player.max_speed){
int w = current_player.sprite->w;
int h = current_player.sprite->h;
int x = current_player.x + w/2;
int y = current_player.y + 3*h/2;
attempt_to_break_block(x,y);
}
current_player.action_timeout--;
current_player.vx *=0.8;
if (!current_player.action_timeout){
current_player.state &= ~(1<<7); //stop plummeting
}
}
current_player.vy = 0;
//current_player.y-=0.01;
} else if (current_player.vy < 5 && ticks % 5 == 0){
current_player.vy+=0.5;
}
if (current_player.near_blocks & (1 << 4)){ //SOLID BLOCK ABOVE
current_player.vy = 0;
current_player.y+=0.2;
}
if (current_player.near_blocks & (1 << 2)){ // SOLID BLOCK ON RIGHT
current_player.vx = -current_player.vx * 0.25;
current_player.x-=0.1;
}
if (current_player.near_blocks & (1 << 6)){ // SOLID BLOCK ON LEFT
current_player.vx = -current_player.vx * 0.25;
current_player.x+=0.1;
}
if (!(current_player.state & (1<<0))){ // NOT DEAD
if (current_player.vx > 0.5 || current_player.vx < -0.5){
} else {
current_player.vx *= 0.9;
}
} else { //IS DEAD
current_player.vx *= 0.8;
}
if (current_player.state & (1<<1)){ // WET
if (current_player.vx > 1 || current_player.vx < -1){
current_player.vx *= 0.9;
}
current_player.vy *= 0.90;
}
current_player.x += current_player.vx;
current_player.y += current_player.vy;
map_draw_offsetx += (current_player.x - map_draw_offsetx - main_screen->w / 2) / (6.0);
map_draw_offsety -= (current_player.y + map_draw_offsety - main_screen->h / 2) / (6.0);
//limit screen from showing outside of the map
if (map_draw_offsetx + main_screen->w > map_buffer->w)
map_draw_offsetx = map_buffer->w - main_screen->w;
if(-map_draw_offsety + main_screen->h > map_buffer->h)
map_draw_offsety = -map_buffer->h + main_screen->h;
if(map_draw_offsetx < 0)
map_draw_offsetx = 0;
if(map_draw_offsety > 0)
map_draw_offsety = 0;
}
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;
}
//UPDATE PART THAT IS COMMON TO ALL GAMES
void game_update(Game* game,int dt){
time_+=dt;
camera_update(game->player,dt);
fake_walk_update(game,dt);
audioplayer_update(game->audio);
double amplitude=audioplayer_getAmplitude(game->audio,dt);
if(amplitude>game->audio_amplitude) game->audio_amplitude = amplitude;
else game->audio_amplitude = game->audio_amplitude*.5 + amplitude*.5;
//=======================================================
//=======================================================
//=======================================================
//======================FIRE UPDATE======================
//=======================================================
//=======================================================
//=======================================================
for(int i=0;i<dt;i++){
if(game->trigger_state || game->FIRST_SHOT==1){
//===CAMERA===
game->player->theta+=.001*game->player->dtheta;
game->player->mFOV+=-.01*(game->player->mFOV-80);
if(game->player->theta>30){
game->player->theta+=-.01*(game->player->theta-29);
}
else if(game->player->theta<-30){
game->player->theta+=-.01*(game->player->theta+29);
}else{
// c->theta+=-.005*(c->theta-0);
}
//============
if(game->trigger_value==0){
game->FIRST_SHOT=1;
}
//augmente jusqu'a trigger_value_MAX
game->trigger_value+=1./trigger_value_MAX[game->weapon];
if(game->trigger_value>1){
// printf("trigger MAX\n");
game->trigger_value=1;
}
}else{
//===CAMERA===
game->player->theta+=.001*game->player->dtheta -.01*game->player->theta;
game->player->mFOV+=-.01*(game->player->mFOV-100);
//============
//diminue jusqu'a 0
//!! VITESSE DIMINUTION PLUS GRANDE
game->trigger_value-=1.5/trigger_value_MAX[game->weapon];
if(game->trigger_value<0){
game->trigger_value=0;
}
}
if(game->fire_value>0){
game->fire_value-=1./fire_value_MAX[game->weapon];
if((game->weapon==1 || game->weapon==4 || game->weapon==5) && game->fire_value<=0){
//set trigger to 0 if using bow
game->trigger_value=0;
}
}
if(game->fire_state && game->trigger_value==1){
game->FIRST_SHOT=0;
if(game->fire_value<=0){
game->fire_value+=1;
if(game->weapon==1){
fire_arrow_with_bow(game);
}else if(game->weapon==2||game->weapon==3){
// fire_arrow_with_bow(game);
fire_arrow_with_sulfateuse(game);
}else if(game->weapon==4){
fire_arrow_with_bow(game);
fire_arrow_with_bow(game);
fire_arrow_with_bow(game);
}else if(game->weapon==5){
fire_arrow_with_bow(game);
fire_arrow_with_bow(game);
fire_arrow_with_bow(game);
fire_arrow_with_bow(game);
fire_arrow_with_bow(game);
}
}
}
//UPDATE ARROWS
update_arrow(game);
update_mechant(game);
update_particles(game);
}
arrow_collision(game);
//=======================================================
//=======================================================
//=======================================================
// if(game->trigger_state==0 && game->trigger_value==game->trigger_value_MAX){
// game->fire(game);
// // MAYBE ???
// // game->trigger_value=0;
// //TODO :
// //TO CHECK
// }
//INTERRACT_MECHANT_PLAYER
update_interraction_mechant_player(game);
game->update(game,dt);
}
void GameUpdate() {
game* g = &g_game;
if (is_key_pressed(KEY_RESET)) {
memset(g->_map, 0, sizeof(g->_map));
g->_entities.free();
g->_player = 0;
g->_cam_pos = vec2(MAP_WIDTH * 0.5f, 8.5f);
g->_target_cam_y = 8.5f;
g->_diff = 1;
g->_diff_dmg = 1;
g->_spawn_time = 800;
g->_spawn_count = 6;
g->_wave_incoming = true;
g->_plr_dmg = 1;
GameInit();
g_title = true;
}
if (g_title) {
set_camera(vec2(), 10.0f);
float ratio = g_WinSize.y / (float)g_WinSize.x;
vec2 orig(-10.0f, -10.0f * ratio);
draw_string(vec2(0.0f, -4.75), 0.15f, TEXT_CENTRE, colour(0.5f, 0.5f, 1.0f, 1.0f), "Tunnel Defense");
float y = -3.25f;
draw_string(vec2(0.0f, y), 0.05f, TEXT_CENTRE, colour(0.3f, 0.3f, 0.6f, 1.0f), "Originally made for LD29 - post competition version"); y += 0.5f;
y += 0.5f;
draw_string(vec2(0.0f, y), 0.05f, TEXT_CENTRE, colour(0.6f, 0.3f, 0.3f, 1.0f), "Dig for your life, the creeps are coming and the"); y += 0.5f;
draw_string(vec2(0.0f, y), 0.05f, TEXT_CENTRE, colour(0.6f, 0.3f, 0.3f, 1.0f), "only safe place is underground! Collect resources"); y += 0.5f;
draw_string(vec2(0.0f, y), 0.05f, TEXT_CENTRE, colour(0.6f, 0.3f, 0.3f, 1.0f), "and build turrets to protect yourself."); y += 0.5f;
y += 0.25f;
float r = 5.0f;
draw_string(vec2(-r, y), 0.05f, TEXT_LEFT, colour(0.6f, 0.6f, 0.6f, 1.0f), "\001\002\003\004");
draw_string(vec2(r, y), 0.05f, TEXT_RIGHT, colour(0.3f, 0.6f, 0.3f, 1.0f), "Move + Aim"); y += 0.5f;
draw_string(vec2(-r, y), 0.05f, TEXT_LEFT, colour(0.6f, 0.6f, 0.6f, 1.0f), "%c", g_LocKeyZ);
draw_string(vec2(r, y), 0.05f, TEXT_RIGHT, colour(0.3f, 0.6f, 0.3f, 1.0f), "Jump"); y += 0.5f;
draw_string(vec2(-r, y), 0.05f, TEXT_LEFT, colour(0.6f, 0.6f, 0.6f, 1.0f), "%c", g_LocKeyX);
draw_string(vec2(r, y), 0.05f, TEXT_RIGHT, colour(0.3f, 0.6f, 0.3f, 1.0f), "Dig block / shoot"); y += 0.5f;
draw_string(vec2(-r, y), 0.05f, TEXT_LEFT, colour(0.6f, 0.6f, 0.6f, 1.0f), "%c", g_LocKeyC);
draw_string(vec2(r, y), 0.05f, TEXT_RIGHT, colour(0.3f, 0.6f, 0.3f, 1.0f), "Build / upgrade turret"); y += 0.5f;
y += 0.25f;
draw_string(vec2(0.0f, y), 0.05f, TEXT_CENTRE, colour(0.15f, 0.3f, 0.15f, 1.0f), "Alternate controls - %c%c%c%c, %c, %c, %c", g_LocKeyW, g_LocKeyA, g_LocKeyS, g_LocKeyD, g_LocKeyI, g_LocKeyO, g_LocKeyP); y += 0.5f;
y += 0.25f;
draw_string(vec2(0.0f, y), 0.05f, TEXT_CENTRE, colour(0.3f, 0.15f, 0.3f, 1.0f), "Building / upgrading a turret costs 3 metal."); y += 0.5f;
draw_string(vec2(0.0f, y), 0.05f, TEXT_CENTRE, colour(0.3f, 0.15f, 0.3f, 1.0f), "Building a turret increases your shot power."); y += 0.5f;
y += 0.25f;
draw_string(vec2(0.0f, y), 0.05f, TEXT_CENTRE, colour(0.5f, 0.5f, 0.5f, 1.0f), "press SPACE to START"); y+= 0.5f;
y += 0.5f;
draw_string(vec2(0.0f, y), 0.035f, TEXT_CENTRE, colour(0.15f, 0.15f, 0.15f, 1.0f), "by Stephen Cakebread @quantumrain");
if (is_key_pressed(KEY_FIRE) || is_key_pressed(KEY_ALT_FIRE)) g_title = false;
return;
}
if (player* p = g->_player) {
vec2 target_cam_pos = vec2(MAP_WIDTH * 0.5f, p->centre().y);
float dy = target_cam_pos.y - g->_target_cam_y;
float hyst = 1.25f;
if (fabsf(dy) > hyst) {
if (dy > 0.0f)
g->_target_cam_y += dy - hyst;
else
g->_target_cam_y += dy + hyst;
}
target_cam_pos.y = g->_target_cam_y;
update_search(g, to_ivec2(p->centre()));
g->_cam_pos = lerp(g->_cam_pos, target_cam_pos, 0.2f);
g->_plr_dmg = 1;
for(uint32_t i = 0; i < g->_entities.size(); i++) {
entity* e = g->_entities[i];
if (!(e->_flags & entity::FLAG_DESTROYED)) {
if (e->_type == ET_TURRET)
g->_plr_dmg++;
}
}
}
set_camera(g->_cam_pos, 15.0f);
if (g->_player) {
if (--g->_spawn_time <= 0) {
if (g->_wave_incoming) {
g->_spawn_count = 4 + 4 * (int)g->_diff;
g->_diff_dmg = (int)(2.5f * (1 + g->_diff)) - 1;
}
g->_wave_incoming = false;
vec2 pos(g_game_rand.frand(1.0f, MAP_WIDTH - 1.0f), 2.0f);
if (bug* e = spawn_entity(&g_game, new bug(), pos)) {
e->_max_damage = g->_diff_dmg;
if (g_game_rand.rand(0, 5) == 0) e->_max_damage += g_game_rand.rand(0, g->_diff_dmg);
if (g_game_rand.rand(0, 15) == 0) e->_max_damage += g_game_rand.rand(0, g->_diff_dmg);
if (g_game_rand.rand(0, 30) == 0) e->_max_damage += g_game_rand.rand(0, g->_diff_dmg);
}
g->_spawn_time = clamp(60 - ((g->_diff * 5) / 4), 10, 60);
if (--g->_spawn_count <= 0){
g->_diff += 1 + (g->_diff / 5);
g->_spawn_time = 600;
g->_wave_incoming = true;
}
}
}
tick_entities(g);
purge_entities(g);
update_particles(g);
colour sky0(0.4f, 0.7f, 1.0f, 1.0f);
colour sky1(0.45f, 0.75f, 1.0f, 1.0f);
colour sky2(0.3f, 0.6f, 0.9f, 1.0f);
colour sky3(0.35f, 0.65f, 0.9f, 1.0f);
sky0 *= colour(0.65f, 0.0f);
sky1 *= colour(0.65f, 0.0f);
sky2 *= colour(0.35f, 1.0f);
sky3 *= colour(0.35f, 1.0f);
float sky_space = 4.5f;
float sky_top = 4.75f;
float sky_y = 10.0f;
float sky_yf = 10.5f;
float sky_yb = 11.0f;
for(int j = 0; j < MAP_HEIGHT; j++) {
colour bk_colour(get_master_colour(j) * colour(0.2f, 1.0f));
for(int i = 0; i < MAP_WIDTH; i++) {
int t = g->get_tile(i, j);
if (t == TT_EMPTY || t == TT_TURRET) {
int hash = ((i * 7) ^ (j * 3)) + (i + j);
hash ^= ((hash >> 3) * 9);
int tile_num = 132 + (hash % 4);
draw_tile(vec2((float)i, (float)j), vec2(i + 1.0f, j + 1.0f), bk_colour, tile_num, 0);
}
}
}
//posun hry o casovy tik
void update_game(float time, int k_up, int k_down, int k_right, int k_left, int k_fire) {
//pozadi pro koncovy screen hry
if (playerdead) {
move_stars(time);
move_enemies(time);
move_bullets(time);
update_particles(time);
move_bonuses(time);
deathtimer-=time;
if ((deathtimer<=0) && k_fire) {
//zacatek nove hry
finish_game();
init_game();
}
}
else {
handle_levels();
//odecteni casu od casovacu bonusu
shieldtimer-=time;
canontimer-=time;
reload+=time;
//ovladani raketky (funkce z main.c)
if (k_left) speedx-=time*1300;
if (k_right) speedx+=time*1300;
if (k_up) speedy+=time*1300;
if (k_down) speedy-=time*1300;
//strelba mozna jen po specifickem casovem intervalu
if (k_fire && ((canontimer>0)?(reload>(0.2/(plevel))):(reload>(0.5/(plevel*0.9))))) {
if (canontimer<=0)
//strelba zavisla na power levelu
add_bullet(posx, posy+50, 0, 200, plevel, 1, 1);
else
//silenej gun po sebrani zeleneho bonusu
add_bullet(posx, posy+50, 0.8*speedx+200*DFRAND*DFRAND*DFRAND, 300+speedy+20*DFRAND, 10*plevel, 1, 1);
reload=0;
}
//aplikace rychlosti raketky na pozici
posx+=speedx*time;
posy+=speedy*time;
//aby raketka brzdila stejne pri ruznem frameratu
speedx*=powf(0.02, time); //powf = exponenciela
speedy*=powf(0.02, time);
//okraje hraciho pole pro raketku
if (posx<-225) {posx=-225; speedx=0;}
if (posx>225) {posx=225; speedx=0;}
if (posy<-335) {posy=-335; speedy=0;}
if (posy>-100) {posy=-100; speedy=0;}
move_stars(time);
move_enemies(time);
move_bullets(time);
update_particles(time);
move_bonuses(time);
}
}
void init_particles(particle* system){
/*
* particles will be placed randomly 4 quadrants of 3d space
* q1: x>0, y>0
* q2: x<0, y>0
* q3: x<0, y<0
* q4: x>0, y<0
*
*/
int i = 0;
srand(time(NULL));
// q1 x>0, y>0
for(; i < NO_OF_PARTICLES/4; i++){
system[i].position = (__vector float){rand()%INIT_BOUNDING_BOX,
rand()%INIT_BOUNDING_BOX,
(rand()%INIT_BOUNDING_BOX*2)-INIT_BOUNDING_BOX, 0};
system[i].velocity = VECZERO;
system[i].acceleration = VECZERO;
}
// q2 x<0, y>0
for(; i < NO_OF_PARTICLES/2; i++){
system[i].position = (__vector float){-rand()%INIT_BOUNDING_BOX,
rand()%INIT_BOUNDING_BOX,
(rand()%INIT_BOUNDING_BOX*2)-INIT_BOUNDING_BOX, 0};
system[i].velocity = VECZERO;
system[i].acceleration = VECZERO;
}
// q3 x<0, y<0
for(; i < 3*NO_OF_PARTICLES/4; i++){
system[i].position = (__vector float){-rand()%INIT_BOUNDING_BOX,
-rand()%INIT_BOUNDING_BOX,
(rand()%INIT_BOUNDING_BOX*2)-INIT_BOUNDING_BOX, 0};
system[i].velocity = VECZERO;
system[i].acceleration = VECZERO;
}
// q4 x>0, y<0
for(; i < NO_OF_PARTICLES; i++){
system[i].position = (__vector float){rand()%INIT_BOUNDING_BOX,
-rand()%INIT_BOUNDING_BOX,
(rand()%INIT_BOUNDING_BOX*2)-INIT_BOUNDING_BOX, 0};
system[i].velocity = VECZERO;
system[i].acceleration = VECZERO;
}
}
void compute_interaction(particle* i , particle* j){
__vector float radius, radius_sqr, s_vector, displ, accel, distSqr,
distSixth, invDistCube;
/*compute acceleration of particle i*/
radius = vec_sub(j->position,i->position);
radius_sqr = vec_madd(radius,radius, VECZERO);
distSqr = vec_add(vec_splat(radius_sqr,0),vec_splat(radius_sqr,1));
distSqr = vec_add(vec_splat(radius_sqr,2),distSqr);
distSqr = vec_add(EPS2_VECTOR,distSqr);
distSixth = vec_madd(distSqr,distSqr,VECZERO);
distSixth = vec_madd(distSixth,distSqr,VEC3ZERO);
invDistCube = vec_rsqrte(distSixth);
s_vector = vec_madd(MASS_VECTOR,invDistCube,VECZERO);
i->acceleration = vec_madd(radius,s_vector,i->acceleration);
/*compute new position & velocity of particle i*/
displ = vec_madd(i->velocity,TIME_STEP_VECTOR,i->position);
accel = vec_madd(VECHALF,i->acceleration, VECZERO);
i->position = vec_madd(accel,TIME_SQUARED, displ);
i->velocity = vec_madd(i->acceleration,TIME_STEP_VECTOR, i->velocity);
}
void update_particles(particle* system){
int i, j;
//Thread 1 ?
for(i = 0;i<NO_OF_PARTICLES/4;i++){
for(j = 0;j<NO_OF_PARTICLES;j++){
compute_interaction(&system[i],&system[j]);
}
}
//Thread 2 ?
for(i = NO_OF_PARTICLES/4;i<NO_OF_PARTICLES/2;i++){
for(j = 0;j<NO_OF_PARTICLES;j++){
compute_interaction(&system[i],&system[j]);
}
}
//Thread 3 ?
for(i = NO_OF_PARTICLES/2;i<3*NO_OF_PARTICLES/4;i++){
for(j = 0;j<NO_OF_PARTICLES;j++){
compute_interaction(&system[i],&system[j]);
}
}
//Thread 4 ?
for(i = 3*NO_OF_PARTICLES/4;i<NO_OF_PARTICLES;i++){
for(j = 0;j<NO_OF_PARTICLES;j++){
compute_interaction(&system[i],&system[j]);
}
}
}
__vector int get_quadrant_count(particle* system){
__vector int quad_count = VECINTZERO;
__vector int quad_mask = VECINTZERO;
int i;
for(i = 0; i < NO_OF_PARTICLES ; i++){
__vector int top2 = (__vector int){1,1,0,0};
__vector int bottom2 = (__vector int){0,0,1,1};
__vector int left2 = (__vector int){0,1,0,1};
__vector int right2 = (__vector int){1,0,1,0};
__vector int mask1, mask2;
__vector float vx = vec_splat(system[i].position,0);
__vector float vy = vec_splat(system[i].position,1);
mask1 = vec_sel(right2, left2, vec_cmpgt(vx,VECZERO));
mask2 = vec_sel(top2, bottom2, vec_cmpgt(vy,VECZERO));
quad_mask = vec_and(mask1,mask2);
quad_count = vec_add(quad_count,quad_mask);
}
return quad_count;
}
void render(particle* system){
int i = 0;
for(; i < NO_OF_PARTICLES; i++){
float *pos = (float*) &system[i].position;
float *vel = (float*) &system[i].velocity;
float *acc = (float*) &system[i].acceleration;
printf("position : %f %f %f ", pos[0], pos[1], pos[2]);
printf("velocity : %f %f %f ", vel[0], vel[1], vel[2]);
printf("acceleration : %f %f %f \n", acc[0], acc[1], acc[2]);
}
}
int main ()
{
/* create particle system --> array of particles */
particle particle_system[NO_OF_PARTICLES] __attribute__((aligned(64)));
/* vector that tracks the no. of particles in each quadrant */
__vector int quad_count;
int * qc;
/* place particles in 4 quadrants */
init_particles(particle_system);
/* run simulation */
float simulationTime = 0.0;
int iterations = COMPUTE_ITERATIONS;
printf("----------------------------------------------");
printf("----------------------------------------------\n");
printf("Running Simulation with %d particles & %d iterations with %f seconds time steps\n",
NO_OF_PARTICLES, COMPUTE_ITERATIONS, TIME_STEP);
printf("----------------------------------------------");
printf("----------------------------------------------\n");
while(iterations > 0){
/* Compute */
update_particles(particle_system);
/* Display */
//render(particle_system);
/* Update Time */
simulationTime = simulationTime + TIME_STEP;
printf("----------------------------------");
printf("Simulation Time: %f |",simulationTime);
quad_count = get_quadrant_count(particle_system);
qc = (int*)&quad_count;
printf(" q1:%d q2:%d q3:%d q4:%d",qc[0], qc[1], qc[2], qc[3]);
printf("----------------------------------\n");
iterations --;
}
return 0;
}
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);
}
}
ENTRYPOINT void draw_providence(ModeInfo * mi)
{
providencestruct *mp;
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
if(!providence)
return;
mp = &providence[MI_SCREEN(mi)];
MI_IS_DRAWN(mi) = True;
if(!mp->glx_context)
return;
glXMakeCurrent(display, window, *(mp->glx_context));
/* setup twoside lighting */
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient2);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT0, GL_POSITION, mp->position0);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_NORMALIZE);
glFrontFace(GL_CCW);
/* glDisable(GL_CULL_FACE); */
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glShadeModel(GL_SMOOTH);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix();
glRotatef(current_device_rotation(), 0, 0, 1);
/* modify camera */
if(fabs(mp->camera_velocity) > EPSILON) {
mp->camera_z = max(min(mp->camera_z + 0.1*mp->camera_velocity, -4.0), -12.0);
mp->camera_velocity = 0.95*mp->camera_velocity;
}
/* rotate providence */
glTranslatef(0.0, 0.0, mp->camera_z + sin(mp->theta/4.0));
glRotatef(10.0+20.0*sin(mp->theta/2.0), 1.0, 0.0, 0.0);
gltrackball_rotate(mp->trackball);
glRotatef(mp->theta * 180.0 / Pi, 0.0, -1.0, 0.0);
# ifdef HAVE_MOBILE /* Keep it the same relative size when rotated. */
{
GLfloat h = MI_HEIGHT(mi) / (GLfloat) MI_WIDTH(mi);
int o = (int) current_device_rotation();
if (o != 0 && o != 180 && o != -180)
glScalef (1/h, 1/h, 1/h);
}
# endif
/* draw providence */
draw_providence_strip(mi);
glPopMatrix();
if(MI_IS_FPS(mi)) do_fps (mi);
glFlush();
glXSwapBuffers(display, window);
/* update */
mp->currenttime += 1.0 / FPS;
mp->theta = mp->currenttime / 2.0 * mp->theta_scale;
update_particles(mp);
}
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 particleHandler::update(){
create_particles();
update_particles();
reap_particles();
}
