game.c

   1
   2 /**
   3  *
   4  * Tennix! SDL Port
   5  * Copyright (C) 2003, 2007, 2008, 2009 Thomas Perl <thp@thpinfo.com>
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2
  10  * of the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  20  * MA  02110-1301, USA.
  21  *
  22  **/
  23
  24 #include <stdio.h>
  25 #include <math.h>
  26
  27 #include "tennix.h"
  28 #include "game.h"
  29 #include "graphics.h"
  30 #include "input.h"
  31 #include "sound.h"
  32
  33
  34 GameState *gamestate_new() {
  35     int x, y, z;
  36     GameState *s;
  37
  38     GameState template = {
  39         { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, false, -1, false },
  40         {
  41             { GAME_X_MIN-RACKET_X_MID*2, GAME_Y_MID, 0, 0, DESIRE_NORMAL, PLAYER_TYPE_HUMAN, GAME_Y_MID, false, 0, {0}, 0, 0, PLAYER_ACCEL_DEFAULT, true },
  42             { GAME_X_MAX+RACKET_X_MID*2, GAME_Y_MID, 0, 0, DESIRE_NORMAL, PLAYER_TYPE_AI, GAME_Y_MID, false, 0, {0}, 0, 0, PLAYER_ACCEL_DEFAULT, true },
  43         },
  44         0,
  45         0,
  46         1,
  47         "welcome to tennix " VERSION,
  48         { 0 },
  49         { 0 },
  50         REFEREE_NORMAL,
  51         0,
  52         WINNER_NONE,
  53         false,
  54         GR_CTT_GRASS,
  55         -1,
  56         { 0 },
  57         0,
  58         false,
  59         { { { 0 } } },
  60         0.0,
  61         SOUND_MAX,
  62         0.0,
  63         0.0,
  64         0,
  65         0,
  66         0,
  67         false,
  68         0,
  69         0,
  70         0,
  71         false,
  72         REFEREE_COUNT,
  73         SCORE_UNDECIDED,
  74         0,
  75     };
  76
  77     s = (GameState*)malloc(sizeof(GameState));
  78     if (s == NULL) abort();
  79
  80     memcpy(s, &template, sizeof(GameState));
  81
  82     game_setup_serve(s);
  83
  84     /* smoothen n-gram */
  85     for( x = 0; x<NGRAM_STEPS; x++) {
  86         for( y = 0; y<NGRAM_STEPS; y++) {
  87             for( z = 0; z<NGRAM_STEPS; z++) {
  88                 s->ngram[x][y][z] = 1;
  89             }
  90         }
  91     }
  92
  93     return s;
  94 }
  95
  96
  97 void gameloop(GameState *s) {
  98     strcpy(s->game_score_str, format_game(s));
  99     strcpy(s->sets_score_str, format_sets(s));
 100     s->text_changed = true;
 101
 102     Uint32 ot = SDL_GetTicks();
 103     Uint32 nt;
 104     Uint32 dt = GAME_TICKS;
 105     Uint32 diff;
 106     Uint32 accumulator = 0;
 107     bool quit = false;
 108
 109 #ifdef ENABLE_FPS_LIMIT
 110     Uint32 ft, frames; /* frame timer and frames */
 111 #endif
 112
 113     if (s->rain > 0) {
 114         play_sample_background(SOUND_RAIN);
 115     }
 116     play_sample_loop(SOUND_AUDIENCE);
 117     /* Reset the court type, so it is redrawn on first display */
 118     s->old_court_type = -1;
 119
 120 #ifdef ENABLE_FPS_LIMIT
 121     frames = 0;
 122     ft = SDL_GetTicks();
 123 #endif
 124     while( !quit) {
 125         nt = SDL_GetTicks();
 126         diff = nt-ot;
 127         if( diff > 2000) {
 128             diff = 0;
 129         }
 130
 131         accumulator += diff;
 132         ot = nt;
 133
 134         while( accumulator >= dt) {
 135             quit = step(s);
 136             s->time += dt;
 137             s->windtime += s->wind*dt;
 138             accumulator -= dt;
 139
 140             if( s->was_stopped) {
 141                 ot = SDL_GetTicks();
 142                 s->was_stopped = false;
 143             }
 144         }
 145         if (s->timelimit != 0 && s->time >= s->timelimit) {
 146             quit = 1;
 147         }
 148
 149 #ifdef ENABLE_FPS_LIMIT
 150         while (frames*1000.0/((float)(SDL_GetTicks()-ft+1))>(float)(DEFAULT_FPS)) {
 151             SDL_Delay(10);
 152         }
 153         frames++;
 154 #endif
 155
 156         render(s);
 157     }
 158
 159     clear_screen();
 160     store_screen();
 161
 162     stop_sample(SOUND_AUDIENCE);
 163     stop_sample(SOUND_RAIN);
 164 }
 165
 166 bool step( GameState* s) {
 167     Uint8 *keys;
 168     SDL_Event e;
 169     bool ground_event = false;
 170     int p;
 171
 172     if (s->ball.z < 0) {
 173         /* ground event */
 174         ground_event = true;
 175
 176         s->referee = REFEREE_NORMAL;
 177         /* FIXME: set referee to correct "position" */
 178
 179         /* bounce from the ground */
 180         if (fabsf(s->ball.move_z) > 0.5) {
 181             s->ball.move_z *= -RESTITUTION;
 182         } else {
 183             s->ball.move_z = 0;
 184         }
 185         s->ball.z = 0;
 186
 187         /* only make the sound if it's visibly bouncing hard */
 188         if (!IS_OFFSCREEN(s->ball.x, s->ball.y) && fabsf(s->ball.move_z) > .5) {
 189             s->play_sound = SOUND_GROUND;
 190         }
 191     }
 192
 193     if (NET_COLLISION_BALL(s->ball)) {
 194         /* the net blocks movement of the ball */
 195         s->ball.move_x = 0;
 196         s->ball.move_y = 0;
 197         /* FIXME: make sure the ball appears OUTSIDE of the net */
 198     }
 199
 200     /* see if we have something to score */
 201     if (s->score_event == SCORE_UNDECIDED) {
 202         if (NET_COLLISION_BALL(s->ball)) {
 203             /* the ball "fell" into the net  */
 204             s->score_event = SCORE_EVENT_NET;
 205             s->play_sound = SOUND_OUT;
 206             s->status = "net!";
 207         } else if (IS_OFFSCREEN(s->ball.x, s->ball.y)) {
 208             /* ball flew offscreen */
 209             s->score_event = SCORE_EVENT_OFFSCREEN;
 210             s->play_sound = SOUND_OUT;
 211             s->status = "out!";
 212         } else if (ground_event) {
 213             /* the ball hit the ground on the screen */
 214             if (IS_OUT(s->ball.x, s->ball.y)) {
 215                 /* the ball bounced in the OUT area */
 216                 s->score_event = SCORE_EVENT_OUT;
 217                 s->play_sound = SOUND_OUT;
 218                 s->status = "out!";
 219             } else if (GROUND_IS_VALID(s->ball.last_hit_by, s->ball.x, s->ball.y)) {
 220                 if (s->ball.ground_hit) {
 221                     s->score_event = SCORE_EVENT_GROUND_VALID;
 222                     s->play_sound = SOUND_OUT;
 223                     s->status = "did not catch the ball!";
 224                 } else {
 225                     /* first ground hit in valid area */
 226                     s->ball.ground_hit = true;
 227                 }
 228             } else {
 229                 /* ball hit somewhere invalid */
 230                 s->score_event = SCORE_EVENT_GROUND_INVALID;
 231                 s->play_sound = SOUND_OUT;
 232                 s->status = "fault!";
 233             }
 234         }
 235     }
 236
 237     if (s->score_event != SCORE_UNDECIDED) {
 238         /* we have some scoring to do */
 239         if (s->score_time == 0) {
 240             /* schedule scoring in the future */
 241             s->score_time = s->time + SCORING_DELAY;
 242         } else if (s->time >= s->score_time) {
 243             /* time has ran out - score now */
 244             score_game(s);
 245             s->score_time = 0;
 246
 247             strcpy(s->game_score_str, format_game(s));
 248             strcpy(s->sets_score_str, format_sets(s));
 249             s->text_changed = true;
 250
 251             /*if (FIXME - get winner) {
 252                 if( PLAYER(s, 1).type == PLAYER_TYPE_HUMAN && PLAYER(s, 2).type == PLAYER_TYPE_AI) {
 253                     s->status = "computer scores";
 254                 } else {
 255                     s->status = "player 2 scores";
 256                 }
 257                 s->referee = REFEREE_PLAYER2;
 258             } else {
 259                 if( PLAYER(s, 1).type == PLAYER_TYPE_HUMAN && PLAYER(s, 2).type == PLAYER_TYPE_AI) {
 260                     s->status = "player scores";
 261                 } else {
 262                     s->status = "player 1 scores";
 263                 }
 264                 s->referee = REFEREE_PLAYER1;
 265             }*/
 266
 267             game_setup_serve(s);
 268             s->play_sound = SOUND_APPLAUSE;
 269             /*FIXME n-gram predictor broken
 270             s->history_size = 0;
 271             s->history_is_locked = 0;
 272             s->ngram_prediction = 0.0;*/
 273         }
 274     } else {
 275         /* score is still undecided - do the racket swing thing */
 276         for (p=1; p<=2; p++) {
 277             if (IS_NEAR_X(PLAYER(s, p).x, s->ball.x) && IS_NEAR_Y(PLAYER(s, p).y, s->ball.y-s->ball.z) && PLAYER(s, p).state && s->ball.last_hit_by != p) {
 278                 /* RACKET HIT */
 279                 if (!s->ball.ground_hit && s->ball.move_x != 0.0) {
 280                     s->status = "volley!";
 281                 } else {
 282                     s->status = format_status(s);
 283                 }
 284                 switch (PLAYER(s, p).desire) {
 285                     case DESIRE_NORMAL:
 286                         /* normal swing */
 287                         s->ball.move_x = 2.7 + 2.0*PLAYER(s, p).state/PLAYER_STATE_MAX;
 288                         s->ball.move_z = 1.2*PLAYER(s, p).state/PLAYER_STATE_MAX;
 289                         break;
 290                     case DESIRE_TOPSPIN:
 291                         /* top spin */
 292                         s->ball.move_x = 1.1 + 2.2*PLAYER(s, p).state/PLAYER_STATE_MAX;
 293                         s->ball.move_z = 2.5*PLAYER(s, p).state/PLAYER_STATE_MAX;
 294                         break;
 295                     case DESIRE_SMASH:
 296                         /* smash */
 297                         s->ball.move_x = 4.0 + 3.0*PLAYER(s, p).state/PLAYER_STATE_MAX;
 298                         s->ball.move_z = 1.1*PLAYER(s, p).state/PLAYER_STATE_MAX;
 299                         break;
 300                 }
 301                 s->ball.move_y = get_move_y( s, p);
 302                 s->play_sound = SOUND_RACKET;
 303                 s->ball.ground_hit = false;
 304                 s->ball.inhibit_gravity = false;
 305                 s->ball.last_hit_by = p;
 306                 if (p==1) {
 307                     pan_sample(SOUND_RACKET, 0.4);
 308                 } else {
 309                     pan_sample(SOUND_RACKET, 0.6);
 310                     s->ball.move_x *= -1;
 311                 }
 312             }
 313         }
 314     }
 315
 316 #if 0
 317     FIXME n-gram predictor broken
 318     if( IS_OUT_X(s->ball.x) || IS_OFFSCREEN_Y(s->ball.y)) {
 319         if( IS_OUT_X(s->ball.x)) {
 320             /*if( !s->history_is_locked && s->referee != REFEREE_OUT) {
 321                 s->history[s->history_size] = (int)(NGRAM_STEPS*s->ball.y/HEIGHT);
 322                 s->history_size++;
 323                 if( s->history_size == 3) {
 324                     s->ngram[s->history[0]][s->history[1]][s->history[2]] += 10;
 325                     s->ngram_prediction = ngram_predictor( s);
 326                     s->history[0] = s->history[1];
 327                     s->history[1] = s->history[2];
 328                     s->history_size--;
 329                 }
 330                 s->history_is_locked = true;
 331             }*/
 332         }
 333     } else {
 334         /*s->history_is_locked = false;*/
 335     }
 336 #endif
 337
 338     SDL_PollEvent(&e);
 339     keys = SDL_GetKeyState(NULL);
 340     switch(e.type) {
 341         case SDL_JOYAXISMOTION:
 342             if (e.jaxis.axis == JOYSTICK_Y_AXIS) {
 343                 s->joystick_y = JOYSTICK_PERCENTIZE(e.jaxis.value);
 344             } else if (e.jaxis.axis == JOYSTICK_X_AXIS) {
 345                 s->joystick_x = JOYSTICK_PERCENTIZE(e.jaxis.value);
 346             }
 347             break;
 348         case SDL_JOYBUTTONUP: case SDL_JOYBUTTONDOWN:
 349             if (e.jbutton.button == JOYSTICK_BUTTON_A) {
 350                 s->joystick_a = (e.jbutton.state == SDL_PRESSED);
 351             }
 352             break;
 353     }
 354
 355     if( s->time%50==0) {
 356         /**
 357          * Maemo keys:
 358          * F7 = "Decrease" key
 359          * F8 = "Increase" key
 360          **/
 361         if (keys['c'] || keys[SDLK_F8]) {
 362             s->court_type++;
 363         } else if (keys[SDLK_F7]) {
 364             s->court_type--;
 365         }
 366         if (keys['r']) {
 367             if (s->rain == 0) {
 368                 play_sample_background(SOUND_RAIN);
 369             }
 370             s->rain += 10;
 371         }
 372         if (keys['t']) {
 373             s->fog++;
 374         }
 375         if (keys['1']) {
 376             s->wind++;
 377         }
 378         if (keys['2']) {
 379             s->wind--;
 380         }
 381         if (keys['n']) {
 382             s->night = 1 - s->night;
 383         }
 384         if( s->court_type > GR_CTT_LAST) {
 385             s->court_type = GR_CTT_FIRST;
 386         } else if (s->court_type < GR_CTT_FIRST) {
 387             s->court_type = GR_CTT_LAST;
 388         }
 389     }
 390
 391     if(!(SDL_GetTicks() < fading_start+FADE_DURATION) && !s->is_over) {
 392         if( PLAYER(s, 1).type == PLAYER_TYPE_HUMAN) {
 393            input_human( &PLAYER(s, 1),
 394                    keys['w'] || keys[SDLK_UP] || s->joystick_y < -JOYSTICK_TRESHOLD,
 395                    keys['s'] || keys[SDLK_DOWN] || s->joystick_y > JOYSTICK_TRESHOLD,
 396                    keys['d'] || keys[SDLK_SPACE] || keys[SDLK_LCTRL] || keys[SDLK_RETURN] || s->joystick_a,
 397                    keys['e'],
 398                    keys['f'],
 399 #ifdef ENABLE_MOUSE
 400                    true,
 401 #else
 402                    false,
 403 #endif
 404                    s);
 405         } else {
 406             input_ai( &PLAYER(s, 1), &s->ball, &PLAYER(s, 2), s);
 407         }
 408
 409         if( PLAYER(s, 2).type == PLAYER_TYPE_HUMAN) {
 410             input_human( &PLAYER(s, 2), keys['o'], keys['l'], keys['k'], keys['i'], keys['j'], false, s);
 411         } else {
 412             input_ai( &PLAYER(s, 2), &s->ball, &PLAYER(s, 1), s);
 413         }
 414     }
 415
 416     /* Maemo: The "F6" button is the "Fullscreen" button */
 417     /*if( keys['f'] || keys[SDLK_F6]) SDL_WM_ToggleFullScreen( screen);*/
 418     if( keys['y']) SDL_SaveBMP( screen, "screenshot.bmp");
 419
 420     /* Maemo: The "F4" button is the "Open menu" button */
 421     if( keys['p'] || keys[SDLK_F4]) {
 422         while( keys['p'] || keys[SDLK_F4]) {
 423             SDL_PollEvent( &e);
 424             keys = SDL_GetKeyState( NULL);
 425             SDL_Delay( 10);
 426         }
 427         while( (keys['p'] || keys[SDLK_F4]) == 0) {
 428             SDL_PollEvent( &e);
 429             keys = SDL_GetKeyState( NULL);
 430             SDL_Delay( 10);
 431         }
 432         while( keys['p'] || keys[SDLK_F4]) {
 433             SDL_PollEvent( &e);
 434             keys = SDL_GetKeyState( NULL);
 435             SDL_Delay( 10);
 436         }
 437         s->was_stopped = true;
 438     }
 439
 440     if( keys[SDLK_ESCAPE] || keys['q']) return true;
 441
 442     limit_value( &PLAYER(s, 1).y, PLAYER_Y_MIN, PLAYER_Y_MAX);
 443     limit_value( &PLAYER(s, 2).y, PLAYER_Y_MIN, PLAYER_Y_MAX);
 444
 445     if (s->ball.move_x > 0 && s->wind > 0) {
 446         s->ball.x += fabsf(s->wind)/2;
 447     } else if (s->ball.move_x < 0 && s->wind < 0) {
 448         s->ball.x -= fabsf(s->wind)/2;
 449     }
 450
 451     s->ball.z += s->ball.move_z;
 452     if (!s->ball.inhibit_gravity) {
 453         s->ball.move_z += GRAVITY;
 454     }
 455
 456     s->ball.x += s->ball.move_x;
 457     s->ball.y += s->ball.move_y;
 458
 459     if(PLAYER(s, 1).state) PLAYER(s, 1).state--;
 460     if(PLAYER(s, 2).state) PLAYER(s, 2).state--;
 461
 462     return false;
 463 }
 464
 465 void render( GameState* s) {
 466     int i, x, y, b;
 467 #ifdef EXTENDED_REFEREE
 468     int t=1000;
 469 #endif
 470     if (s->play_sound != SOUND_MAX) {
 471         play_sample(s->play_sound);
 472         s->play_sound = SOUND_MAX;
 473     }
 474     if( s->winner != WINNER_NONE) {
 475         if( !s->is_over) {
 476             start_fade();
 477             s->is_over = true;
 478         }
 479         clear_screen();
 480         store_screen();
 481         show_sprite( GR_RACKET, 2*(s->winner-1), 4, WIDTH/2 - get_image_width( GR_RACKET)/8, HEIGHT/2 - get_image_height( GR_RACKET), 255);
 482         sprintf( s->game_score_str, "player %d wins the match with %s", s->winner, format_sets( s));
 483         font_draw_string( GR_DKC2_FONT, s->game_score_str, (WIDTH-font_get_string_width( GR_DKC2_FONT, s->game_score_str))/2, HEIGHT/2 + 30, s->time/20, ANIMATION_WAVE | ANIMATION_BUNGEE);
 484         updatescr();
 485         return;
 486     }
 487     if (s->old_court_type != s->court_type || s->text_changed || s->old_referee != s->referee) {
 488         clear_screen();
 489         fill_image(s->court_type, 120, 120, 400, 250);
 490         show_image(GR_COURT, 0, 0, 255);
 491         font_draw_string( GR_DKC2_FONT, s->game_score_str, 14, 14, 0, ANIMATION_NONE);
 492         font_draw_string( GR_DKC2_FONT, s->sets_score_str, (WIDTH-font_get_string_width( GR_DKC2_FONT, s->sets_score_str))-14, 14, 0, ANIMATION_NONE);
 493 #ifdef EXTENDED_REFEREE
 494         switch (s->referee) {
 495             case REFEREE_NORMAL:
 496                 t = 1000;
 497                 break;
 498             case REFEREE_OUT:
 499                 t = 200;
 500                 break;
 501             case REFEREE_PLAYER1:
 502             case REFEREE_PLAYER2:
 503                 t = 400;
 504                 break;
 505         }
 506         t = (s->time/t)%4;
 507         switch (t) {
 508             case 0:
 509                 t=0;
 510                 break;
 511             case 1:
 512                 t=1;
 513                 break;
 514             case 2:
 515                 t=0;
 516                 break;
 517             case 3:
 518                 t=2;
 519                 break;
 520         }
 521         show_sprite( GR_REFEREE, s->referee*3+t, 12, 250, 10, 255);
 522         if (voice_finished_flag == 0) {
 523             show_sprite(GR_TALK, (s->time/150)%2, 2, 280, 45, 255);
 524         }
 525 #else
 526         show_sprite( GR_REFEREE, s->referee, 4, 250, 10, 255);
 527 #endif
 528         s->old_court_type = s->court_type;
 529         s->text_changed = false;
 530         s->old_referee = s->referee;
 531         store_screen();
 532     }
 533
 534     show_sprite( GR_RACKET, (!PLAYER(s, 1).state), 4, PLAYER(s, 1).x-RACKET_X_MID, PLAYER(s, 1).y-RACKET_Y_MID, 255);
 535     show_sprite( GR_RACKET, (!PLAYER(s, 2).state)+2, 4, PLAYER(s, 2).x-RACKET_X_MID, PLAYER(s, 2).y-RACKET_Y_MID, 255);
 536
 537     if( s->ball.move_x > 0) {
 538         b = (s->time/100)%BALL_STATES;
 539     } else if( s->ball.move_x < 0) {
 540         b = BALL_STATES-1-(s->time/100)%BALL_STATES;
 541     } else {
 542         b = 0;
 543     }
 544     show_image(GR_SHADOW,                s->ball.x-BALL_X_MID, s->ball.y-4, 255);
 545     show_sprite(GR_BALL, b, BALL_STATES, s->ball.x-BALL_X_MID, s->ball.y-BALL_Y_MID-s->ball.z, 255);
 546
 547     /* Player 1's mouse rectangle */
 548     if (!(PLAYER(s, 1).mouse_locked)) {
 549         rectangle(PLAYER(s, 1).x-2+5, PLAYER(s, 1).mouse_y-2, 4, 4, 255, 255, 255);
 550         rectangle(PLAYER(s, 1).x-1+5, PLAYER(s, 1).mouse_y-1, 2, 2, 0, 0, 0);
 551     }
 552
 553
 554     font_draw_string( GR_DKC2_FONT, s->status, (WIDTH-font_get_string_width( GR_DKC2_FONT, s->status))/2, HEIGHT-50, s->time/30, ANIMATION_WAVE);
 555
 556     for (i=0; i<s->rain; i++) {
 557         x = rand()%WIDTH;
 558         y = rand()%HEIGHT;
 559         draw_line_faded(x, y, x+10+s->wind*5, y+30, 0, 0, 255, 100, 200, 255);
 560     }
 561     if (s->rain) {
 562         /**
 563          * Cheap-ish update of the whole screen. This can
 564          * probably be optimized.
 565          **/
 566         update_rect(0, 0, WIDTH, HEIGHT);
 567     }
 568
 569 #ifdef DEBUG
 570     line_horiz( PLAYER(s, 1).y, 255, 0, 0);
 571     line_horiz( PLAYER(s, 2).y, 0, 0, 255);
 572     line_horiz( s->ball.y, 0, 255, 0);
 573
 574     line_vert( PLAYER(s, 1).x, 255, 0, 0);
 575     line_vert( PLAYER(s, 2).x, 0, 0, 255);
 576     line_vert( s->ball.x, 0, 255, 0);
 577
 578     line_horiz( GAME_Y_MIN, 100, 100, 100);
 579     line_horiz( GAME_Y_MAX, 100, 100, 100);
 580 #endif
 581     switch (s->fog) {
 582         default:
 583         case 4:
 584             fill_image_offset(GR_FOG2, 0, 0, WIDTH, HEIGHT, -s->time/150-s->windtime/200, 0);
 585         case 3:
 586             fill_image_offset(GR_FOG, 0, 0, WIDTH, HEIGHT, -s->time/100-s->windtime/150, 20);
 587         case 2:
 588             fill_image_offset(GR_FOG2, 0, 0, WIDTH, HEIGHT, -s->time/180-s->windtime/180, 80);
 589         case 1:
 590             fill_image_offset(GR_FOG, 0, 0, WIDTH, HEIGHT, s->time/200-s->windtime/100, 0);
 591         case 0:
 592             break;
 593     }
 594     if (s->night) {
 595         show_image(GR_NIGHT, 0, 0, 255);
 596     }
 597
 598     updatescr();
 599 }
 600
 601 void limit_value( float* value, float min, float max) {
 602     if( *value < min) {
 603         *value = min;
 604     } else if( *value > max) {
 605         *value = max;
 606     }
 607 }
 608
 609 float get_move_y( GameState* s, unsigned char player) {
 610     float pct, dest, x_len, y_len;
 611     float py, by, pa, move_x;
 612
 613     py = (player==1)?(PLAYER(s, 1).y):(PLAYER(s, 2).y);
 614     by = s->ball.y - s->ball.z;
 615     pa = RACKET_Y_MID*2;
 616     move_x = s->ball.move_x;
 617
 618     /* -1.0 .. 1.0 for racket hit position */
 619     pct = (by-py)/(pa/2);
 620     limit_value( &pct, -1.0, 1.0);
 621
 622     /* Y destination for ball */
 623     dest = GAME_Y_MID + pct*(GAME_Y_MAX-GAME_Y_MIN);
 624
 625     /* lengths for the ball's journey */
 626     if( player == 1) {
 627         x_len = fabsf(GAME_X_MAX - s->ball.x);
 628         y_len = dest - by + MOVE_Y_SEED-rand()%MOVE_Y_SEED*2;
 629     } else {
 630         x_len = s->ball.x - GAME_X_MIN;
 631         y_len = by - dest + MOVE_Y_SEED-rand()%MOVE_Y_SEED*2;
 632     }
 633
 634     /* return the should-be value for move_y */
 635     return (y_len*move_x)/(x_len);
 636 }
 637
 638 void input_human( Player* player, bool up, bool down, bool hit, bool topspin, bool smash, bool use_mouse, GameState* s) {
 639     int diff = PLAYER_MOVE_Y;
 640     int mb;
 641
 642     /**
 643      * Only use mouse control if the user isn't pressing any buttons
 644      * this way, keyboard control still works when mouse control is
 645      * enabled.
 646      **/
 647     if (use_mouse && (down || up || hit)) {
 648         /**
 649          * this is here so if the user decides to play
 650          * with keyboard controls, we will lock the
 651          * mouse and disable displaying the mouse cursor
 652          **/
 653         player->mouse_locked = true;
 654     }
 655     if (use_mouse && !down && !up && !hit) {
 656         mb = SDL_GetMouseState(&(player->mouse_x), &(player->mouse_y));
 657         if (mb&SDL_BUTTON(SDL_BUTTON_LEFT)) {
 658             if (player->mouse_y < player->y) {
 659                 down = false;
 660                 up = true;
 661                 diff = (player->y-player->mouse_y<diff)?(player->y-player->mouse_y):(diff);
 662             } else if (player->mouse_y > player->y) {
 663                 up = false;
 664                 down = true;
 665                 diff = (player->mouse_y-player->y<diff)?(player->mouse_y-player->y):(diff);
 666             }
 667             player->mouse_locked = false;
 668         } else if (!player->mouse_locked) {
 669             hit = true;
 670         }
 671     }
 672
 673     if (fabsf(s->joystick_y) > JOYSTICK_TRESHOLD) {
 674         diff = PLAYER_MOVE_Y*fabsf(s->joystick_y)/40.0;
 675         if (diff > PLAYER_MOVE_Y) {
 676             diff = PLAYER_MOVE_Y;
 677         }
 678     }
 679
 680     if (up) {
 681         player->y -= fminf(diff, diff*player->accelerate);
 682         player->accelerate *= PLAYER_ACCEL_INCREASE;
 683     } else if (down) {
 684         player->y += fminf(diff, diff*player->accelerate);
 685         player->accelerate *= PLAYER_ACCEL_INCREASE;
 686     } else {
 687         player->accelerate = PLAYER_ACCEL_DEFAULT;
 688     }
 689
 690     if(hit || topspin || smash) {
 691         player->desire = (topspin)?(DESIRE_TOPSPIN):(DESIRE_NORMAL);
 692         player->desire = (smash)?(DESIRE_SMASH):(player->desire);
 693
 694         if( !player->state && !player->state_locked) {
 695             player->state = PLAYER_STATE_MAX;
 696             player->state_locked = true;
 697         }
 698     } else {
 699         player->state_locked = false;
 700     }
 701 }
 702
 703 void input_ai( Player* player, Ball* ball, Player* opponent, GameState* s) {
 704     float fact = 1.7;
 705     float target;
 706
 707     /* FIXME - this is broken since the new physics model has been introduced */
 708
 709     if( fabsf( player->y - (ball->y-ball->z)) > RACKET_Y_MID*5) {
 710         fact = 3.5;
 711     }
 712
 713     if(1) {
 714         if( player->desire == DESIRE_NORMAL && !IS_NEAR_Y_AI( player->y, (ball->y-ball->z))) {
 715             if( player->y < (ball->y-ball->z)) {
 716                 player->y += fmin( 2*fact, (ball->y-ball->z) - player->y);
 717             } else if( player->y > (ball->y-ball->z)) {
 718                 player->y -= fmin( 2*fact, player->y - (ball->y-ball->z));
 719             }
 720         }
 721
 722         if( (ball->move_x != 0 || IS_NEAR_Y_AI( player->y, (ball->y-ball->z))) && IS_NEAR_X_AI( player->x, ball->x)/* && !player->state*/) {
 723             player->state = PLAYER_STATE_MAX;
 724         }
 725     } else if( s->ngram_prediction > 0.0) {
 726         target = s->ngram_prediction*((float)HEIGHT)/((float)(NGRAM_STEPS));
 727         target = GAME_Y_MID + (target-GAME_Y_MID)*1.5;
 728
 729         if( player->desire == DESIRE_NORMAL && !IS_NEAR_Y_AI( player->y, target)) {
 730             if( player->y < target) {
 731                 player->y += fmin( fact, (target-player->y)/40.0);
 732             } else if( player->y > target) {
 733                 player->y -= fmin( fact, (player->y-target)/40.0);
 734             }
 735         }
 736     }
 737 }
 738
 739 void game_setup_serve( GameState* s) {
 740     s->ball.z = 10.0;
 741     s->ball.y = GAME_Y_MID;
 742     s->ball.move_x = 0.0;
 743     s->ball.move_y = 0.0;
 744     s->ball.move_z = 0.0;
 745     s->ball.last_hit_by = -1;
 746     s->ball.inhibit_gravity = true;
 747
 748     if( s->serving_player == 1) {
 749         s->ball.x = GAME_X_MIN-RACKET_X_MID*1.5;
 750     } else {
 751         s->ball.x = GAME_X_MAX+RACKET_X_MID*1.5;
 752     }
 753 }
 754
 755 float ngram_predictor( GameState* s) {
 756     unsigned int count = 0;
 757     unsigned long sum = 0;
 758     int x, y, z;
 759     float result;
 760
 761     if( s->history_size < 3) {
 762         return 0.0;
 763     }
 764
 765     x = s->history[1];
 766     y = s->history[2];
 767
 768     for( z = 0; z<NGRAM_STEPS; z++) {
 769         count += s->ngram[x][y][z];
 770         sum += z * s->ngram[x][y][z];
 771     }
 772
 773     result = ((float)(sum))/((float)(count));
 774 #ifdef DEBUG
 775     printf( "predicting next = %.2f\n", result);
 776 #endif
 777
 778     return result;
 779 }
 780
 781 void score_game(GameState* s) {
 782     Player *last_hit_by = NULL;
 783     Player *other = NULL;
 784
 785     Player* winner = NULL;
 786     Player* loser = NULL;
 787
 788     /* determine "last hit by" and "other" */
 789     if (s->ball.last_hit_by == 1) {
 790         last_hit_by = &(PLAYER(s, 1));
 791         other = &(PLAYER(s, 2));
 792     } else {
 793         last_hit_by = &(PLAYER(s, 2));
 794         other = &(PLAYER(s, 1));
 795     }
 796
 797     switch (s->score_event) {
 798         case SCORE_EVENT_NET:
 799             winner = other;
 800             break;
 801         case SCORE_EVENT_OUT:
 802         case SCORE_EVENT_GROUND_INVALID:
 803         case SCORE_EVENT_OFFSCREEN:
 804         case SCORE_EVENT_GROUND_VALID:
 805             if (s->ball.ground_hit) {
 806                 winner = last_hit_by;
 807             } else {
 808                 winner = other;
 809             }
 810             break;
 811         default:
 812             break;
 813     }
 814
 815     /* determine loser based on winner */
 816     if (winner == last_hit_by) {
 817         loser = other;
 818     } else {
 819         loser = last_hit_by;
 820     }
 821
 822     if( s->current_set >= SETS_TO_WIN*2-1) {
 823         return;
 824     }
 825
 826     winner->game++;
 827     if( loser->game < winner->game-1) {
 828         if( winner->game >= 4) {
 829             winner->game = loser->game = 0;
 830             winner->sets[s->current_set]++;
 831
 832             /* serving is changed when the "game" is over */
 833             s->serving_player = (s->serving_player==1)?(2):(1);
 834
 835 #ifdef HAVE_VOICE_FILES
 836             /* speak the current score */
 837             voice_say_list(4, VOICE_ZERO_IN + (PLAYER(s, 1).sets[s->current_set])*2, VOICE_TO, VOICE_ZERO_OUT + (PLAYER(s, 2).sets[s->current_set])*2, VOICE_IN_THE_FIRST_SET+s->current_set);
 838 #endif
 839
 840             /* scoring the set.. */
 841             if( (winner->sets[s->current_set] == 6 && loser->sets[s->current_set] < 5) ||
 842                 winner->sets[s->current_set] == 7) {
 843                 s->current_set++;
 844                 s->winner = game_get_winner( s);
 845             }
 846         }
 847     }
 848
 849     /* forget this event - we've handled it */
 850     s->score_event = SCORE_UNDECIDED;
 851 }
 852
 853 char* format_sets( GameState* s) {
 854     static char sets[100];
 855     static char tmp[100];
 856     int i, max = s->current_set;
 857
 858     sets[0] = '\0';
 859
 860     if( s->winner != WINNER_NONE) {
 861         max--;
 862     }
 863     for( i=0; i<=max; i++) {
 864         sprintf( tmp, "%d:%d, ", PLAYER(s, 1).sets[i], PLAYER(s, 2).sets[i]);
 865         strcat( sets, tmp);
 866     }
 867
 868     sets[strlen(sets)-2] = '\0';
 869
 870     return sets;
 871 }
 872
 873 char* format_game( GameState* s) {
 874     static char game[100];
 875     static const int game_scoring[] = { 0, 15, 30, 40 };
 876
 877     if( PLAYER(s, 1).game < 4 && PLAYER(s, 2).game < 4) {
 878 #ifdef HAVE_VOICE_FILES
 879         if (PLAYER(s, 1).game > 0 || PLAYER(s, 2).game > 0) {
 880             if (PLAYER(s, 1).game == PLAYER(s, 2).game) {
 881                 voice_say_list(2, VOICE_LOVE_IN + 2*(PLAYER(s, 1).game), VOICE_ALL);
 882             } else {
 883                 voice_say_list(2, VOICE_LOVE_IN + 2*(PLAYER(s, 1).game), VOICE_LOVE_OUT + 2*(PLAYER(s, 2).game));
 884             }
 885         }
 886 #endif
 887         sprintf( game, "%d - %d", game_scoring[PLAYER(s, 1).game], game_scoring[PLAYER(s, 2).game]);
 888     } else if( PLAYER(s, 1).game > PLAYER(s, 2).game) {
 889 #ifdef HAVE_VOICE_FILES
 890         voice_say_list(1, VOICE_ADVANTAGE_PLAYER_ONE);
 891 #endif
 892         strcpy( game, "advantage player 1");
 893     } else if( PLAYER(s, 1).game < PLAYER(s, 2).game) {
 894 #ifdef HAVE_VOICE_FILES
 895         voice_say_list(1, VOICE_ADVANTAGE_PLAYER_TWO);
 896 #endif
 897         strcpy( game, "advantage player 2");
 898     } else {
 899 #ifdef HAVE_VOICE_FILES
 900         voice_say_list(1, VOICE_DEUCE);
 901 #endif
 902         strcpy( game, "deuce");
 903     }
 904
 905     return game;
 906 }
 907
 908 char* format_status( GameState* s) {
 909     static char status[100];
 910     static const char* set_names[] = { "first", "second", "third", "fourth", "fifth" };
 911
 912     sprintf( status, "%d:%d in %s set", PLAYER(s, 1).sets[s->current_set], PLAYER(s, 2).sets[s->current_set], set_names[s->current_set]);
 913
 914     return status;
 915 }
 916
 917 int game_get_winner( GameState* s) {
 918     int i;
 919     int sets[2] = {0};
 920
 921     for( i=0; i<s->current_set; i++) {
 922         if( PLAYER(s, 1).sets[i] > PLAYER(s, 2).sets[i]) {
 923             sets[0]++;
 924         } else {
 925             sets[1]++;
 926         }
 927     }
 928
 929     if( sets[0] == SETS_TO_WIN) return WINNER_PLAYER1;
 930     if( sets[1] == SETS_TO_WIN) return WINNER_PLAYER2;
 931
 932     return WINNER_NONE;
 933 }
 934