vcs.maemo.org Git - neverball/blob - ball/game.c

   1 /*
   2  * Copyright (C) 2003 Robert Kooima
   3  *
   4  * NEVERBALL is  free software; you can redistribute  it and/or modify
   5  * it under the  terms of the GNU General  Public License as published
   6  * by the Free  Software Foundation; either version 2  of the License,
   7  * or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT  ANY  WARRANTY;  without   even  the  implied  warranty  of
  11  * MERCHANTABILITY or  FITNESS FOR A PARTICULAR PURPOSE.   See the GNU
  12  * General Public License for more details.
  13  */
  14
  15 #include <SDL.h>
  16 #include <math.h>
  17
  18 #include "glext.h"
  19 #include "game.h"
  20 #include "vec3.h"
  21 #include "geom.h"
  22 #include "back.h"
  23 #include "part.h"
  24 #include "image.h"
  25 #include "audio.h"
  26 #include "solid.h"
  27 #include "config.h"
  28 #include "binary.h"
  29
  30 /*---------------------------------------------------------------------------*/
  31
  32 static int game_state = 0;
  33
  34 static struct s_file file;
  35 static struct s_file back;
  36
  37 static float clock      = 0.f;          /* Clock time                        */
  38 static int   clock_down = 1;            /* Clock go up or down?              */
  39
  40 static float game_ix;                   /* Input rotation about X axis       */
  41 static float game_iz;                   /* Input rotation about Z axis       */
  42 static float game_rx;                   /* Floor rotation about X axis       */
  43 static float game_rz;                   /* Floor rotation about Z axis       */
  44
  45 static float view_a;                    /* Ideal view rotation about Y axis  */
  46 static float view_ry;                   /* Angular velocity about Y axis     */
  47 static float view_dc;                   /* Ideal view distance above ball    */
  48 static float view_dp;                   /* Ideal view distance above ball    */
  49 static float view_dz;                   /* Ideal view distance behind ball   */
  50 static float view_fov;                  /* Field of view                     */
  51
  52 static float view_c[3];                 /* Current view center               */
  53 static float view_v[3];                 /* Current view vector               */
  54 static float view_p[3];                 /* Current view position             */
  55 static float view_e[3][3];              /* Current view orientation          */
  56 static float view_k;
  57
  58 static int   coins  = 0;                /* Collected coins                   */
  59 static int   goal_c = 0;                /* Goal coins remaining (0 = open)   */
  60 static float goal_k = 0;                /* Goal animation                    */
  61 static int   swch_e = 1;                /* Switching enabled flag            */
  62 static int   jump_e = 1;                /* Jumping enabled flag              */
  63 static int   jump_b = 0;                /* Jump-in-progress flag             */
  64 static float jump_dt;                   /* Jump duration                     */
  65 static float jump_p[3];                 /* Jump destination                  */
  66 static float fade_k = 0.0;              /* Fade in/out level                 */
  67 static float fade_d = 0.0;              /* Fade in/out direction             */
  68
  69 /*---------------------------------------------------------------------------*/
  70
  71 static void view_init(void)
  72 {
  73     view_a  = 0.f;
  74     view_ry = 0.f;
  75
  76     view_fov = (float) config_get_d(CONFIG_VIEW_FOV);
  77     view_dp  = (float) config_get_d(CONFIG_VIEW_DP) / 100.0f;
  78     view_dc  = (float) config_get_d(CONFIG_VIEW_DC) / 100.0f;
  79     view_dz  = (float) config_get_d(CONFIG_VIEW_DZ) / 100.0f;
  80     view_k   = 1.0f;
  81
  82     view_c[0] = 0.f;
  83     view_c[1] = view_dc;
  84     view_c[2] = 0.f;
  85
  86     view_p[0] =     0.f;
  87     view_p[1] = view_dp;
  88     view_p[2] = view_dz;
  89
  90     view_e[0][0] = 1.f;
  91     view_e[0][1] = 0.f;
  92     view_e[0][2] = 0.f;
  93     view_e[1][0] = 0.f;
  94     view_e[1][1] = 1.f;
  95     view_e[1][2] = 0.f;
  96     view_e[2][0] = 0.f;
  97     view_e[2][1] = 0.f;
  98     view_e[2][2] = 1.f;
  99 }
 100
 101 int game_init(const char *file_name,
 102               const char *back_name,
 103               const char *grad_name, int t, int g)
 104 {
 105     clock      = (float) t / 100.f;
 106     clock_down = (t > 0);
 107     coins      = 0;
 108
 109     if (game_state)
 110         game_free();
 111
 112     game_ix = 0.f;
 113     game_iz = 0.f;
 114     game_rx = 0.f;
 115     game_rz = 0.f;
 116
 117     /* Initialize jump and goal states. */
 118
 119     jump_e = 1;
 120     jump_b = 0;
 121
 122     goal_c = g;
 123     goal_k = (g == 0) ? 1.0f : 0.0f;
 124
 125     /* Initialise the level, background, particles, fade, and view. */
 126
 127     fade_k =  1.0f;
 128     fade_d = -2.0f;
 129
 130     part_reset(GOAL_HEIGHT);
 131     view_init();
 132     back_init(grad_name, config_get_d(CONFIG_GEOMETRY));
 133
 134     if (sol_load(&back, config_data(back_name),
 135                  config_get_d(CONFIG_TEXTURES), 0) &&
 136         sol_load(&file, file_name,
 137                  config_get_d(CONFIG_TEXTURES), config_get_d(CONFIG_SHADOW)))
 138         return (game_state = 1);
 139     else
 140         return (game_state = 0);
 141 }
 142
 143 void game_free(void)
 144 {
 145     if (game_state)
 146     {
 147         sol_free(&file);
 148         sol_free(&back);
 149         back_free();
 150     }
 151     game_state = 0;
 152 }
 153
 154 /*---------------------------------------------------------------------------*/
 155
 156 int curr_clock(void)
 157 {
 158     return (int) (clock * 100.f);
 159 }
 160
 161 int curr_coins(void)
 162 {
 163     return coins;
 164 }
 165
 166 int curr_goal(void)
 167 {
 168     return goal_c;
 169 }
 170
 171 char *curr_intro(void)
 172 {
 173     return (file.ac > 0) ? file.av : NULL;
 174 }
 175
 176 /*---------------------------------------------------------------------------*/
 177
 178 static void game_draw_balls(const struct s_file *fp)
 179 {
 180     float c[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
 181     float M[16];
 182
 183     m_basis(M, fp->uv[0].e[0], fp->uv[0].e[1], fp->uv[0].e[2]);
 184
 185     glPushMatrix();
 186     {
 187         glTranslatef(fp->uv[0].p[0],
 188                      fp->uv[0].p[1] + BALL_FUDGE,
 189                      fp->uv[0].p[2]);
 190         glMultMatrixf(M);
 191         glScalef(fp->uv[0].r,
 192                  fp->uv[0].r,
 193                  fp->uv[0].r);
 194
 195         glColor4fv(c);
 196
 197         ball_draw();
 198     }
 199     glPopMatrix();
 200 }
 201
 202 static void game_draw_coins(const struct s_file *fp)
 203 {
 204     float r = 360.f * SDL_GetTicks() / 1000.f;
 205     int ci;
 206
 207     coin_push();
 208     {
 209         for (ci = 0; ci < fp->cc; ci++)
 210             if (fp->cv[ci].n > 0)
 211             {
 212                 glPushMatrix();
 213                 {
 214                     glTranslatef(fp->cv[ci].p[0],
 215                                  fp->cv[ci].p[1],
 216                                  fp->cv[ci].p[2]);
 217                     glRotatef(r, 0.0f, 1.0f, 0.0f);
 218                     coin_draw(fp->cv[ci].n, r);
 219                 }
 220                 glPopMatrix();
 221             }
 222     }
 223     coin_pull();
 224 }
 225
 226 static void game_draw_goals(const struct s_file *fp, float rx, float ry)
 227 {
 228     int zi;
 229
 230     if (goal_c == 0)
 231         for (zi = 0; zi < fp->zc; zi++)
 232         {
 233             glPushMatrix();
 234             {
 235                 glTranslatef(fp->zv[zi].p[0],
 236                              fp->zv[zi].p[1],
 237                              fp->zv[zi].p[2]);
 238
 239                 part_draw_goal(rx, ry, fp->zv[zi].r, goal_k);
 240
 241                 glScalef(fp->zv[zi].r, goal_k, fp->zv[zi].r);
 242                 goal_draw();
 243             }
 244             glPopMatrix();
 245         }
 246 }
 247
 248 static void game_draw_jumps(const struct s_file *fp)
 249 {
 250     int ji;
 251
 252     for (ji = 0; ji < fp->jc; ji++)
 253     {
 254         glPushMatrix();
 255         {
 256             glTranslatef(fp->jv[ji].p[0],
 257                          fp->jv[ji].p[1],
 258                          fp->jv[ji].p[2]);
 259
 260             glScalef(fp->jv[ji].r, 1.f, fp->jv[ji].r);
 261             jump_draw();
 262         }
 263         glPopMatrix();
 264     }
 265 }
 266
 267 static void game_draw_swchs(const struct s_file *fp)
 268 {
 269     int xi;
 270
 271     for (xi = 0; xi < fp->xc; xi++)
 272     {
 273         glPushMatrix();
 274         {
 275             glTranslatef(fp->xv[xi].p[0],
 276                          fp->xv[xi].p[1],
 277                          fp->xv[xi].p[2]);
 278
 279             glScalef(fp->xv[xi].r, 1.f, fp->xv[xi].r);
 280             swch_draw(fp->xv[xi].f);
 281         }
 282         glPopMatrix();
 283     }
 284 }
 285
 286 /*---------------------------------------------------------------------------*/
 287
 288 static void game_refl_all(int s)
 289 {
 290     const float *ball_p = file.uv->p;
 291
 292     glPushMatrix();
 293     {
 294         /* Rotate the environment about the position of the ball. */
 295
 296         glTranslatef(+ball_p[0], +ball_p[1], +ball_p[2]);
 297         glRotatef(-game_rz, view_e[2][0], view_e[2][1], view_e[2][2]);
 298         glRotatef(-game_rx, view_e[0][0], view_e[0][1], view_e[0][2]);
 299         glTranslatef(-ball_p[0], -ball_p[1], -ball_p[2]);
 300
 301         /* Draw the floor. */
 302
 303         sol_refl(&file);
 304     }
 305     glPopMatrix();
 306 }
 307
 308 /*---------------------------------------------------------------------------*/
 309
 310 static void game_draw_light(void)
 311 {
 312     const float light_p[2][4] = {
 313         { -8.0f, +32.0f, -8.0f, 1.0f },
 314         { +8.0f, +32.0f, +8.0f, 1.0f },
 315     };
 316     const float light_c[2][4] = {
 317         { 1.0f, 0.8f, 0.8f, 1.0f },
 318         { 0.8f, 1.0f, 0.8f, 1.0f },
 319     };
 320
 321     /* Configure the lighting. */
 322
 323     glEnable(GL_LIGHT0);
 324     glLightfv(GL_LIGHT0, GL_POSITION, light_p[0]);
 325     glLightfv(GL_LIGHT0, GL_DIFFUSE,  light_c[0]);
 326     glLightfv(GL_LIGHT0, GL_SPECULAR, light_c[0]);
 327
 328     glEnable(GL_LIGHT1);
 329     glLightfv(GL_LIGHT1, GL_POSITION, light_p[1]);
 330     glLightfv(GL_LIGHT1, GL_DIFFUSE,  light_c[1]);
 331     glLightfv(GL_LIGHT1, GL_SPECULAR, light_c[1]);
 332 }
 333
 334 static void game_draw_back(int pose, int d, const float p[3])
 335 {
 336     float c[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
 337     float t = SDL_GetTicks() / 1000.f + 120.0f;
 338
 339     glPushMatrix();
 340     {
 341         if (d < 0)
 342         {
 343             glRotatef(game_rz * 2, view_e[2][0], view_e[2][1], view_e[2][2]);
 344             glRotatef(game_rx * 2, view_e[0][0], view_e[0][1], view_e[0][2]);
 345         }
 346
 347         glTranslatef(p[0], p[1], p[2]);
 348         glColor4fv(c);
 349
 350         if (config_get_d(CONFIG_BACKGROUND))
 351         {
 352             /* Draw all background layers back to front. */
 353
 354             sol_back(&back, BACK_DIST, FAR_DIST, t);
 355             back_draw(0);
 356             sol_back(&back, 0, BACK_DIST, t);
 357
 358             /* Draw all foreground geometry in the background file. */
 359
 360             sol_draw(&back);
 361         }
 362         else back_draw(0);
 363     }
 364     glPopMatrix();
 365 }
 366
 367 static void game_draw_fore(int pose, float rx, float ry, int d, const float p[3])
 368 {
 369     const float *ball_p = file.uv->p;
 370     const float  ball_r = file.uv->r;
 371
 372     glPushAttrib(GL_LIGHTING_BIT | GL_COLOR_BUFFER_BIT);
 373     {
 374         glPushMatrix();
 375         {
 376             /* Rotate the environment about the position of the ball. */
 377
 378             glTranslatef(+ball_p[0], +ball_p[1] * d, +ball_p[2]);
 379             glRotatef(-game_rz * d, view_e[2][0], view_e[2][1], view_e[2][2]);
 380             glRotatef(-game_rx * d, view_e[0][0], view_e[0][1], view_e[0][2]);
 381             glTranslatef(-ball_p[0], -ball_p[1] * d, -ball_p[2]);
 382
 383             if (d < 0)
 384             {
 385                 GLdouble e[4];
 386
 387                 e[0] = +0;
 388                 e[1] = +1;
 389                 e[2] = +0;
 390                 e[3] = -0.00001;
 391
 392                 glEnable(GL_CLIP_PLANE0);
 393                 glClipPlane(GL_CLIP_PLANE0, e);
 394             }
 395
 396             /* Draw the floor. */
 397
 398             sol_draw(&file);
 399
 400             if (config_get_d(CONFIG_SHADOW))
 401             {
 402                 shad_draw_set(ball_p, ball_r);
 403                 sol_shad(&file);
 404                 shad_draw_clr();
 405             }
 406
 407             /* Draw the game elements. */
 408
 409             glEnable(GL_BLEND);
 410             glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 411
 412             if (pose == 0)
 413             {
 414                 part_draw_coin(-rx * d, -ry);
 415                 game_draw_coins(&file);
 416                 game_draw_balls(&file);
 417             }
 418             game_draw_goals(&file, -rx * d, -ry);
 419             game_draw_jumps(&file);
 420             game_draw_swchs(&file);
 421
 422             glDisable(GL_CLIP_PLANE0);
 423         }
 424         glPopMatrix();
 425     }
 426     glPopAttrib();
 427 }
 428
 429 void game_draw(int pose, float st)
 430 {
 431     float fov = view_fov;
 432
 433     if (jump_b) fov *= 2.f * fabsf(jump_dt - 0.5);
 434
 435     if (game_state)
 436     {
 437         config_push_persp(fov, 0.1f, FAR_DIST);
 438         glPushMatrix();
 439         {
 440             float v[3], rx, ry;
 441             float pup[3];
 442             float pdn[3];
 443
 444             v_cpy(pup, view_p);
 445             v_cpy(pdn, view_p);
 446             pdn[1] = -pdn[1];
 447
 448             /* Compute and apply the view. */
 449
 450             v_sub(v, view_c, view_p);
 451
 452             rx = V_DEG(fatan2f(-v[1], fsqrtf(v[0] * v[0] + v[2] * v[2])));
 453             ry = V_DEG(fatan2f(+v[0], -v[2])) + st;
 454
 455             glTranslatef(0.f, 0.f, -v_len(v));
 456             glRotatef(rx, 1.f, 0.f, 0.f);
 457             glRotatef(ry, 0.f, 1.f, 0.f);
 458             glTranslatef(-view_c[0], -view_c[1], -view_c[2]);
 459
 460             if (config_get_d(CONFIG_REFLECTION))
 461             {
 462                 /* Draw the mirror only into the stencil buffer. */
 463
 464                 glDisable(GL_DEPTH_TEST);
 465                 glEnable(GL_STENCIL_TEST);
 466                 glStencilFunc(GL_ALWAYS, 1, 0xFFFFFFFF);
 467                 glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
 468                 glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
 469
 470                 game_refl_all(0);
 471
 472                 /* Draw the scene reflected into color and depth buffers. */
 473
 474                 glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
 475                 glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
 476                 glStencilFunc(GL_EQUAL, 1, 0xFFFFFFFF);
 477                 glEnable(GL_DEPTH_TEST);
 478
 479                 glFrontFace(GL_CW);
 480                 glPushMatrix();
 481                 {
 482                     glScalef(+1.f, -1.f, +1.f);
 483
 484                     game_draw_light();
 485                     game_draw_back(pose,         -1, pdn);
 486                     game_draw_fore(pose, rx, ry, -1, pdn);
 487                 }
 488                 glPopMatrix();
 489                 glFrontFace(GL_CCW);
 490
 491                 glDisable(GL_STENCIL_TEST);
 492             }
 493
 494             /* Draw the scene normally. */
 495
 496             game_draw_light();
 497             game_refl_all(pose ? 0 : config_get_d(CONFIG_SHADOW));
 498             game_draw_back(pose,         +1, pup);
 499             game_draw_fore(pose, rx, ry, +1, pup);
 500         }
 501         glPopMatrix();
 502         config_pop_matrix();
 503
 504         /* Draw the fade overlay. */
 505
 506         fade_draw(fade_k);
 507     }
 508 }
 509
 510 /*---------------------------------------------------------------------------*/
 511
 512 static void game_update_grav(float h[3], const float g[3])
 513 {
 514     struct s_file *fp = &file;
 515
 516     float x[3];
 517     float y[3] = { 0.f, 1.f, 0.f };
 518     float z[3];
 519     float X[16];
 520     float Z[16];
 521     float M[16];
 522
 523     /* Compute the gravity vector from the given world rotations. */
 524
 525     v_sub(z, view_p, fp->uv->p);
 526     v_crs(x, y, z);
 527     v_crs(z, x, y);
 528     v_nrm(x, x);
 529     v_nrm(z, z);
 530
 531     m_rot (Z, z, V_RAD(game_rz));
 532     m_rot (X, x, V_RAD(game_rx));
 533     m_mult(M, Z, X);
 534     m_vxfm(h, M, g);
 535 }
 536
 537 static void game_update_view(float dt)
 538 {
 539     float dc = view_dc * (jump_b ? 2.0f * fabsf(jump_dt - 0.5f) : 1.0f);
 540     float dx = view_ry * dt * 5.0f;
 541     float k;
 542
 543     view_a += view_ry * dt * 90.f;
 544
 545     /* Center the view about the ball. */
 546
 547     v_cpy(view_c, file.uv->p);
 548     v_inv(view_v, file.uv->v);
 549
 550     switch (config_get_d(CONFIG_CAMERA))
 551     {
 552     case 1: /* Camera 1:  Viewpoint chases the ball position. */
 553
 554         v_sub(view_e[2], view_p, view_c);
 555         break;
 556
 557     case 2: /* Camera 2: View vector is given by view angle. */
 558
 559         view_e[2][0] = fsinf(V_RAD(view_a));
 560         view_e[2][1] = 0.f;
 561         view_e[2][2] = fcosf(V_RAD(view_a));
 562
 563         dx = 0.0f;
 564
 565         break;
 566
 567     default: /* Default: View vector approaches the ball velocity vector. */
 568
 569         k = v_dot(view_v, view_v);
 570
 571         v_sub(view_e[2], view_p, view_c);
 572         v_mad(view_e[2], view_e[2], view_v, k * dt / 4);
 573
 574         break;
 575     }
 576
 577     /* Orthonormalize the basis of the view in its new position. */
 578
 579     v_crs(view_e[0], view_e[1], view_e[2]);
 580     v_crs(view_e[2], view_e[0], view_e[1]);
 581     v_nrm(view_e[0], view_e[0]);
 582     v_nrm(view_e[2], view_e[2]);
 583
 584     /* Compute the new view position. */
 585
 586     k = 1.0f + v_dot(view_e[2], view_v) / 10.0f;
 587
 588     view_k = view_k + (k - view_k) * dt;
 589
 590     if (view_k < 0.5) view_k = 0.5;
 591
 592     v_cpy(view_p, file.uv->p);
 593     v_mad(view_p, view_p, view_e[0], dx      * view_k);
 594     v_mad(view_p, view_p, view_e[1], view_dp * view_k);
 595     v_mad(view_p, view_p, view_e[2], view_dz * view_k);
 596
 597     /* Compute the new view center. */
 598
 599     v_cpy(view_c, file.uv->p);
 600     v_mad(view_c, view_c, view_e[1], dc);
 601
 602     /* Note the current view angle. */
 603
 604     view_a = V_DEG(fatan2f(view_e[2][0], view_e[2][2]));
 605 }
 606
 607 static void game_update_time(float dt, int b)
 608 {
 609     if (goal_c == 0 && goal_k < 1.0f)
 610         goal_k += dt;
 611
 612    /* The ticking clock. */
 613
 614     if (b && clock_down)
 615     {
 616         if (clock < 600.f)
 617             clock -= dt;
 618         if (clock < 0.f)
 619             clock = 0.f;
 620     }
 621     else if (b)
 622     {
 623         clock += dt;
 624     }
 625 }
 626
 627 static int game_update_state(int bt)
 628 {
 629     struct s_file *fp = &file;
 630     float p[3];
 631     float c[3];
 632     int n, e = swch_e;
 633
 634     /* Test for a coin grab. */
 635
 636     if (bt && (n = sol_coin_test(fp, p, COIN_RADIUS)) > 0)
 637     {
 638         coin_color(c, n);
 639         part_burst(p, c);
 640
 641         coins += n;
 642         /* Check for goal open. */
 643         if (goal_c > 0)
 644         {
 645             goal_c = goal_c - n;
 646             if (goal_c <= 0)
 647             {
 648                 audio_play(AUD_SWITCH, 1.f);
 649                 goal_c = 0;
 650             }
 651             else
 652                 audio_play(AUD_COIN, 1.f);
 653         }
 654         else
 655             audio_play(AUD_COIN, 1.f);
 656     }
 657
 658     /* Test for a switch. */
 659
 660     if ((swch_e = sol_swch_test(fp, swch_e, 0)) != e && e)
 661         audio_play(AUD_SWITCH, 1.f);
 662
 663     /* Test for a jump. */
 664
 665     if (jump_e == 1 && jump_b == 0 && sol_jump_test(fp, jump_p, 0) == 1)
 666     {
 667         jump_b  = 1;
 668         jump_e  = 0;
 669         jump_dt = 0.f;
 670
 671         audio_play(AUD_JUMP, 1.f);
 672     }
 673     if (jump_e == 0 && jump_b == 0 && sol_jump_test(fp, jump_p, 0) == 0)
 674         jump_e = 1;
 675
 676     /* Test for a goal. */
 677
 678     if (bt && goal_c == 0 && sol_goal_test(fp, p, 0))
 679     {
 680         audio_play(AUD_GOAL, 1.0f);
 681         return GAME_GOAL;
 682     }
 683
 684     /* Test for time-out. */
 685
 686     if (bt && clock_down && clock <= 0.f)
 687         return GAME_TIME;
 688
 689     /* Test for fall-out. */
 690
 691     if (bt && fp->uv[0].p[1] < fp->vv[0].p[1])
 692         return GAME_FALL;
 693
 694     return GAME_NONE;
 695 }
 696
 697 /*
 698  * On  most  hardware, rendering  requires  much  more  computing power  than
 699  * physics.  Since  physics takes less time  than graphics, it  make sense to
 700  * detach  the physics update  time step  from the  graphics frame  rate.  By
 701  * performing multiple physics updates for  each graphics update, we get away
 702  * with higher quality physics with little impact on overall performance.
 703  *
 704  * Toward this  end, we establish a  baseline maximum physics  time step.  If
 705  * the measured  frame time  exceeds this  maximum, we cut  the time  step in
 706  * half, and  do two updates.  If THIS  time step exceeds the  maximum, we do
 707  * four updates.  And  so on.  In this way, the physics  system is allowed to
 708  * seek an optimal update rate independant of, yet in integral sync with, the
 709  * graphics frame rate.
 710  */
 711
 712 int game_step(const float g[3], float dt, int bt)
 713 {
 714     struct s_file *fp = &file;
 715
 716     float h[3];
 717     float d = 0.f;
 718     float b = 0.f;
 719     float t;
 720     int i, n = 1;
 721
 722     if (game_state)
 723     {
 724         t = dt;
 725
 726         /* Smooth jittery or discontinuous input. */
 727
 728         if (t < RESPONSE)
 729         {
 730             game_rx += (game_ix - game_rx) * t / RESPONSE;
 731             game_rz += (game_iz - game_rz) * t / RESPONSE;
 732         }
 733         else
 734         {
 735             game_rx = game_ix;
 736             game_rz = game_iz;
 737         }
 738
 739         game_update_grav(h, g);
 740         part_step(h, t);
 741
 742         if (jump_b)
 743         {
 744             jump_dt += t;
 745
 746             /* Handle a jump. */
 747
 748             if (0.5 < jump_dt)
 749             {
 750                 fp->uv[0].p[0] = jump_p[0];
 751                 fp->uv[0].p[1] = jump_p[1];
 752                 fp->uv[0].p[2] = jump_p[2];
 753             }
 754             if (1.f < jump_dt)
 755                 jump_b = 0;
 756         }
 757         else
 758         {
 759             /* Run the sim. */
 760
 761             while (t > MAX_DT && n < MAX_DN)
 762             {
 763                 t /= 2;
 764                 n *= 2;
 765             }
 766
 767             for (i = 0; i < n; i++)
 768                 if (b < (d = sol_step(fp, h, t, 0, NULL)))
 769                     b = d;
 770
 771             /* Mix the sound of a ball bounce. */
 772
 773             if (b > 0.5)
 774                 audio_play(AUD_BUMP, (b - 0.5f) * 2.0f);
 775         }
 776
 777         game_step_fade(dt);
 778         game_update_view(dt);
 779         game_update_time(dt, bt);
 780
 781         return game_update_state(bt);
 782     }
 783     return GAME_NONE;
 784 }
 785
 786 /*---------------------------------------------------------------------------*/
 787
 788 void game_no_aa(void)
 789 {
 790     float max = game_ix * game_ix + game_iz * game_iz;
 791     if (max > ANGLE_BOUND * ANGLE_BOUND)
 792     {
 793         max = ANGLE_BOUND / sqrt(max);
 794         game_ix *= max;
 795         game_iz *= max;
 796     }
 797 }
 798
 799 void game_set_x(int k)
 800 {
 801     game_ix = -(ANGLE_BOUND) * k / JOY_MAX;
 802 #if NO_AA
 803     game_no_aa();
 804 #endif
 805 }
 806
 807 void game_set_z(int k)
 808 {
 809     game_iz = +ANGLE_BOUND * k / JOY_MAX;
 810 #if NO_AA
 811     game_no_aa();
 812 #endif
 813 }
 814
 815 void game_set_pos(int x, int y)
 816 {
 817     game_ix += 40.f * y / config_get_d(CONFIG_MOUSE_SENSE);
 818     game_iz += 40.f * x / config_get_d(CONFIG_MOUSE_SENSE);
 819
 820 #if NO_AA
 821     game_no_aa();
 822 #else
 823     if (game_ix > +ANGLE_BOUND) game_ix = +ANGLE_BOUND;
 824     if (game_ix < -ANGLE_BOUND) game_ix = -ANGLE_BOUND;
 825     if (game_iz > +ANGLE_BOUND) game_iz = +ANGLE_BOUND;
 826     if (game_iz < -ANGLE_BOUND) game_iz = -ANGLE_BOUND;
 827 #endif
 828 }
 829
 830 void game_set_rot(float r)
 831 {
 832     view_ry = r;
 833 }
 834
 835 /*---------------------------------------------------------------------------*/
 836
 837 void game_set_fly(float k)
 838 {
 839     struct s_file *fp = &file;
 840
 841     float  x[3] = { 1.f, 0.f, 0.f };
 842     float  y[3] = { 0.f, 1.f, 0.f };
 843     float  z[3] = { 0.f, 0.f, 1.f };
 844     float c0[3] = { 0.f, 0.f, 0.f };
 845     float p0[3] = { 0.f, 0.f, 0.f };
 846     float c1[3] = { 0.f, 0.f, 0.f };
 847     float p1[3] = { 0.f, 0.f, 0.f };
 848     float  v[3];
 849
 850     v_cpy(view_e[0], x);
 851     v_cpy(view_e[1], y);
 852     v_cpy(view_e[2], z);
 853
 854     /* k = 0.0 view is at the ball. */
 855
 856     if (fp->uc > 0)
 857     {
 858         v_cpy(c0, fp->uv[0].p);
 859         v_cpy(p0, fp->uv[0].p);
 860     }
 861
 862     v_mad(p0, p0, y, view_dp);
 863     v_mad(p0, p0, z, view_dz);
 864     v_mad(c0, c0, y, view_dc);
 865
 866     /* k = +1.0 view is s_view 0 */
 867
 868     if (k >= 0 && fp->wc > 0)
 869     {
 870         v_cpy(p1, fp->wv[0].p);
 871         v_cpy(c1, fp->wv[0].q);
 872     }
 873
 874     /* k = -1.0 view is s_view 1 */
 875
 876     if (k <= 0 && fp->wc > 1)
 877     {
 878         v_cpy(p1, fp->wv[1].p);
 879         v_cpy(c1, fp->wv[1].q);
 880     }
 881
 882     /* Interpolate the views. */
 883
 884     v_sub(v, p1, p0);
 885     v_mad(view_p, p0, v, k * k);
 886
 887     v_sub(v, c1, c0);
 888     v_mad(view_c, c0, v, k * k);
 889
 890     /* Orthonormalize the view basis. */
 891
 892     v_sub(view_e[2], view_p, view_c);
 893     v_crs(view_e[0], view_e[1], view_e[2]);
 894     v_crs(view_e[2], view_e[0], view_e[1]);
 895     v_nrm(view_e[0], view_e[0]);
 896     v_nrm(view_e[2], view_e[2]);
 897 }
 898
 899 void game_look(float phi, float theta)
 900 {
 901     view_c[0] = view_p[0] + fsinf(V_RAD(theta)) * fcosf(V_RAD(phi));
 902     view_c[1] = view_p[1] +                       fsinf(V_RAD(phi));
 903     view_c[2] = view_p[2] - fcosf(V_RAD(theta)) * fcosf(V_RAD(phi));
 904 }
 905
 906 /*---------------------------------------------------------------------------*/
 907
 908 void game_kill_fade(void)
 909 {
 910     fade_k = 0.0f;
 911     fade_d = 0.0f;
 912 }
 913
 914 void game_step_fade(float dt)
 915 {
 916     if ((fade_k < 1.0f && fade_d > 0.0f) ||
 917         (fade_k > 0.0f && fade_d < 0.0f))
 918         fade_k += fade_d * dt;
 919
 920     if (fade_k < 0.0f)
 921     {
 922         fade_k = 0.0f;
 923         fade_d = 0.0f;
 924     }
 925     if (fade_k > 1.0f)
 926     {
 927         fade_k = 1.0f;
 928         fade_d = 0.0f;
 929     }
 930 }
 931
 932 void game_fade(float d)
 933 {
 934     fade_d = d;
 935 }
 936
 937 /*---------------------------------------------------------------------------*/
 938
 939 int put_game_state(FILE *fout)
 940 {
 941     if (game_state)
 942     {
 943         /* Write the view and tilt state. */
 944
 945         put_float(fout, &game_rx);
 946         put_float(fout, &game_rz);
 947         put_array(fout,  view_c, 3);
 948         put_array(fout,  view_p, 3);
 949
 950         /* Write the game simulation state. */
 951
 952         put_file_state(fout, &file);
 953
 954         return 1;
 955     }
 956     return 0;
 957 }
 958
 959 int get_game_state(FILE *fin)
 960 {
 961     if (game_state)
 962     {
 963         /* Read the view and tilt state. */
 964
 965         get_float(fin, &game_rx);
 966         get_float(fin, &game_rz);
 967         get_array(fin,  view_c, 3);
 968         get_array(fin,  view_p, 3);
 969
 970         /* Read the game simulation state. */
 971
 972         get_file_state(fin, &file);
 973
 974         return (feof(fin) ? 0 : 1);
 975     }
 976     return 0;
 977 }
 978
 979 /*---------------------------------------------------------------------------*/