tennix.c

   1
   2 /**
   3  *
   4  * Tennix! SDL Port
   5  * Copyright (C) 2003, 2007, 2008 Thomas Perl <thp@perli.net>
   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 <time.h>
  26 #include <libgen.h>
  27 #include <string.h>
  28 #include <stdlib.h>
  29
  30 #ifdef WIN32
  31 #include <windows.h>
  32 #endif
  33
  34 #include "tennix.h"
  35 #include "game.h"
  36 #include "graphics.h"
  37 #include "sound.h"
  38 #include "input.h"
  39
  40 SDL_Surface *screen;
  41
  42 #ifdef WIN32
  43
  44 /* IDs from the resource file */
  45 #define START_BUTTON 1
  46 #define CHECKBOX_FULLSCREEN 2
  47 #define QUIT_BUTTON 3
  48
  49 BOOL CALLBACK ConfigDialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
  50 {
  51     static int checkbox_is_checked;
  52
  53     switch (uMsg) {
  54         case WM_CLOSE:
  55             EndDialog(hwndDlg, IDCANCEL);
  56             break;
  57         case WM_COMMAND:
  58             switch (wParam) {
  59                 case START_BUTTON:
  60                     EndDialog(hwndDlg, (checkbox_is_checked)?(IDYES):(IDNO));
  61                     break;
  62                 case QUIT_BUTTON:
  63                     EndDialog(hwndDlg, IDCANCEL);
  64                     break;
  65                 case CHECKBOX_FULLSCREEN:
  66                     checkbox_is_checked ^= 1;
  67                     break;
  68             }
  69             break;
  70         default:
  71             return FALSE;
  72     }
  73     return TRUE;
  74 }
  75 #endif
  76
  77 #ifdef WIN32
  78 int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
  79     LPSTR lpCmdLine, int nCmdShow) {
  80 #else
  81 int main( int argc, char** argv) {
  82 #endif
  83     int i, slide, slide_direction;
  84     int ticks;
  85     int mx, my;
  86     Uint8 *keys;
  87     Uint8 mb;
  88     SDL_Event e;
  89     int sdl_flags = SDL_SWSURFACE;
  90     int btn_hovering = 0, btn_hovering_old = 0;
  91     int slide_start;
  92     bool mouse_pressed = false;
  93     bool quit = false;
  94     bool benchmark = false;
  95     GameState *current_game = NULL, *prepared_game = NULL;
  96
  97     MenuButton btn_back = {
  98         "Back to main menu",
  99         MENU_OPTIONS_BORDER,
 100         HEIGHT-(MENU_OPTIONS_BORDER+MENU_OPTIONS_BUTTON_HEIGHT),
 101         MENU_OPTIONS_BUTTON_WIDTH, MENU_OPTIONS_BUTTON_HEIGHT,
 102         255, 0, 0
 103     };
 104     MenuButton btn_start = {
 105         "Start new game",
 106         WIDTH-(MENU_OPTIONS_BORDER+MENU_OPTIONS_BUTTON_WIDTH),
 107         HEIGHT-(MENU_OPTIONS_BORDER+MENU_OPTIONS_BUTTON_HEIGHT),
 108         MENU_OPTIONS_BUTTON_WIDTH, MENU_OPTIONS_BUTTON_HEIGHT,
 109         0, 255, 0
 110     };
 111     MenuButton btn_court_change = {
 112         "change",
 113         240,
 114         40,
 115         50, MENU_OPTIONS_BUTTON_HEIGHT,
 116         100, 100, 100
 117     };
 118     MenuButton btn_player1 = {
 119         NULL,
 120         380,
 121         180,
 122         MENU_OPTIONS_BUTTON_WIDTH, MENU_OPTIONS_BUTTON_HEIGHT,
 123         50, 50, 255
 124     };
 125     MenuButton btn_player2 = {
 126         NULL,
 127         380,
 128         180+MENU_OPTIONS_BORDER*2+MENU_OPTIONS_BUTTON_HEIGHT,
 129         MENU_OPTIONS_BUTTON_WIDTH, MENU_OPTIONS_BUTTON_HEIGHT,
 130         255, 50, 50
 131     };
 132
 133     int state = MENU_STATE_STARTED;
 134
 135 #ifdef ENABLE_FPS_LIMIT
 136     Uint32 ft, frames; /* frame timer and frames */
 137 #endif
 138
 139 #ifdef MAEMO
 140     sdl_flags |= SDL_FULLSCREEN;
 141 #endif
 142
 143 #ifdef WIN32
 144     int mb_result;
 145     mb_result = DialogBox(hInstance, "CONFIG", 0, (DLGPROC)ConfigDialogProc);
 146
 147     switch (mb_result) {
 148         case IDYES:
 149             sdl_flags |= SDL_FULLSCREEN;
 150             break;
 151         case IDCANCEL:
 152             return 0;
 153             break;
 154         default:
 155             break;
 156     }
 157 #else
 158     fprintf( stderr, "Tennix %s\n%s\n%s\n\n", VERSION, COPYRIGHT, URL);
 159
 160     bool do_help = false;
 161     i = 1;
 162     while (i < argc) {
 163         /* A poor/lazy man's getopt */
 164         #define OPTION_SET(longopt,shortopt) \
 165                 (strcmp(argv[i], longopt)==0 || strcmp(argv[i], shortopt)==0)
 166         #define OPTION_VALUE \
 167                 ((i+1 < argc)?(argv[i+1]):(NULL))
 168         #define OPTION_VALUE_PROCESSED \
 169                 (i++)
 170         if (OPTION_SET("--fullscreen", "-f")) {
 171             sdl_flags |= SDL_FULLSCREEN;
 172         }
 173         else if (OPTION_SET("--help", "-h")) {
 174             do_help = true;
 175         }
 176         else if (OPTION_SET("--list-joysticks", "-J")) {
 177             SDL_Init(SDL_INIT_JOYSTICK);
 178             joystick_list();
 179             return 0;
 180         }
 181         else if (OPTION_SET("--benchmark", "-b")) {
 182             benchmark = true;
 183         }
 184         else if (OPTION_SET("--joystick", "-j")) {
 185             SDL_Init(SDL_INIT_JOYSTICK);
 186             if (OPTION_VALUE == NULL) {
 187                 fprintf(stderr, "Error: You need to specify the name of the joystick as parameter.\n");
 188                 do_help = true;
 189                 break;
 190             }
 191             if (joystick_open(OPTION_VALUE)==0) {
 192                 fprintf(stderr, "Warning: Cannot find joystick \"%s\" - Ignored.\n", OPTION_VALUE);
 193                 break;
 194             }
 195             OPTION_VALUE_PROCESSED;
 196         }
 197         else {
 198             fprintf(stderr, "Ignoring unknown option: %s\n", argv[i]);
 199         }
 200         i++;
 201     }
 202
 203     if (do_help == true) {
 204         fprintf(stderr, "Usage: %s [--fullscreen|-f] [--help|-h] [--list-joysticks|-J] [--joystick|-j] [joystick name]\n", argv[0]);
 205         return 0;
 206     }
 207 #endif
 208
 209     if (benchmark) {
 210         srand(100);
 211     } else {
 212         srand((unsigned)time(NULL));
 213     }
 214
 215     if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK) == -1) {
 216         fprintf( stderr, "Can't init SDL:  %s\n", SDL_GetError());
 217         exit( 1);
 218     }
 219
 220     SDL_VideoInfo* vi = (SDL_VideoInfo*)SDL_GetVideoInfo();
 221     if( (screen = SDL_SetVideoMode( WIDTH, HEIGHT, vi->vfmt->BitsPerPixel, sdl_flags)) == NULL) {
 222         fprintf( stderr, "Can't set video mode: %s\n", SDL_GetError());
 223         exit( 1);
 224     }
 225
 226     SDL_WM_SetCaption( "Tennix " VERSION, "Tennix");
 227     SDL_ShowCursor( SDL_DISABLE);
 228     SDL_EnableKeyRepeat (SDL_DEFAULT_REPEAT_DELAY, 1);
 229
 230     init_graphics();
 231     init_sound();
 232     init_joystick();
 233
 234 #ifdef ENABLE_FPS_LIMIT
 235     frames = 0;
 236     ft = SDL_GetTicks();
 237 #endif
 238
 239     if (benchmark) {
 240         GameState* g = gamestate_new();
 241         g->player1.type = PLAYER_TYPE_AI;
 242         g->player2.type = PLAYER_TYPE_AI;
 243         g->timelimit = BENCHMARK_TIMELIMIT*1000;
 244         gameloop(g);
 245         free(g);
 246         exit(0);
 247     }
 248
 249     i = 0;
 250     /* Sliding initialization */
 251     ticks = SDL_GetTicks();
 252     slide = slide_start = get_image_width(GR_SIDEBAR);
 253     slide_direction = 0;
 254     while(!quit) {
 255         /* State transitions */
 256         switch (state) {
 257             case MENU_STATE_STARTED:
 258                 state = MENU_STATE_SLIDE_TO_MAINMENU;
 259                 break;
 260             case MENU_STATE_SLIDE_TO_MAINMENU:
 261                 slide = slide_start;
 262                 slide_direction = -1;
 263                 state = MENU_STATE_SLIDE_TO_MAINMENU_IN_PROGRESS;
 264                 break;
 265             case MENU_STATE_SLIDE_TO_MAINMENU_IN_PROGRESS:
 266                 if (slide == 0) {
 267                     slide_direction = 0;
 268                     state = MENU_STATE_MAINMENU;
 269                 }
 270                 break;
 271             case MENU_STATE_MAINMENU:
 272                 free(prepared_game);
 273                 prepared_game = NULL;
 274                 break;
 275             case MENU_STATE_SLIDE_TO_OPTIONS:
 276                 slide = 1;
 277                 slide_direction = 3;
 278                 state = MENU_STATE_SLIDE_TO_OPTIONS_IN_PROGRESS;
 279                 break;
 280             case MENU_STATE_SLIDE_TO_OPTIONS_IN_PROGRESS:
 281                 if (slide == slide_start) {
 282                     start_fade();
 283                     state = MENU_STATE_OPTIONS;
 284                 }
 285                 break;
 286             case MENU_STATE_OPTIONS:
 287                 /* Prepare a new game */
 288                 if (prepared_game == NULL) {
 289                     prepared_game = gamestate_new();
 290                     btn_player1.text = "Keyboard (W-S-D)";
 291                     btn_player2.text = "Computer (AI)";
 292                 }
 293                 break;
 294             case MENU_STATE_SLIDE_TO_GAME:
 295                 /*slide = 1;
 296                 slide_direction = 2;
 297                 state = MENU_STATE_SLIDE_TO_GAME_IN_PROGRESS;
 298                 break;
 299             case MENU_STATE_SLIDE_TO_GAME_IN_PROGRESS:
 300                 if (slide == slide_start) {
 301                     state = MENU_STATE_GAME;
 302                 }*/
 303                 state = MENU_STATE_GAME;
 304                 break;
 305             case MENU_STATE_SLIDE_TO_RESUME:
 306                 slide = 1;
 307                 slide_direction = 2;
 308                 state = MENU_STATE_SLIDE_TO_RESUME_IN_PROGRESS;
 309                 break;
 310             case MENU_STATE_SLIDE_TO_RESUME_IN_PROGRESS:
 311                 if (slide == slide_start) {
 312                     state = MENU_STATE_RESUME;
 313                 }
 314                 break;
 315             case MENU_STATE_GAME:
 316                 if (prepared_game == NULL) {
 317                     fprintf(stderr, "Game not yet prepared!\n");
 318                     exit(EXIT_FAILURE);
 319                 }
 320                 /* Cancel a possibly started game */
 321                 free(current_game);
 322                 current_game = prepared_game;
 323                 prepared_game = NULL;
 324                 /* no break - we are continuing with "resume" */
 325             case MENU_STATE_RESUME:
 326                 if (current_game == NULL) {
 327                     fprintf(stderr, "Cannot resume game!\n");
 328                     exit(EXIT_FAILURE);
 329                 }
 330                 start_fade();
 331                 gameloop(current_game);
 332                 SDL_Delay(150);
 333                 while(SDL_PollEvent(&e));
 334 #ifdef ENABLE_FPS_LIMIT
 335                 frames = 0;
 336                 ft = SDL_GetTicks();
 337 #endif
 338                 start_fade();
 339                 state = MENU_STATE_SLIDE_TO_MAINMENU;
 340                 break;
 341             case MENU_STATE_SLIDE_TO_QUIT:
 342                 slide = 1;
 343                 slide_direction = 3;
 344                 state = MENU_STATE_SLIDE_TO_QUIT_IN_PROGRESS;
 345                 break;
 346             case MENU_STATE_SLIDE_TO_QUIT_IN_PROGRESS:
 347                 if (slide == slide_start) {
 348                     state = MENU_STATE_QUIT;
 349                 }
 350                 break;
 351             case MENU_STATE_QUIT:
 352                 quit = true;
 353                 break;
 354             default:
 355                 fprintf(stderr, "State error: %d\n", state);
 356                 exit(EXIT_FAILURE);
 357         }
 358
 359         /* Sliding */
 360         if (SDL_GetTicks() > ticks + 20) {
 361             if (slide >= 1 && slide <= slide_start) {
 362                 slide += slide_direction+(slide_direction*slide/(sqrt(2*slide)));
 363                 slide = MAX(0, MIN(slide_start, slide));
 364             } else if (slide_direction != 0) {
 365                 slide_direction = 0;
 366             }
 367             ticks = SDL_GetTicks();
 368         }
 369
 370         /* Graphics */
 371 #ifdef DEBUG
 372         if (state != MENU_STATE_OPTIONS) {
 373             fill_image_offset(GR_FOG, 0, 0, WIDTH, HEIGHT, -i, 0);
 374         }
 375 #endif
 376         show_image(GR_SIDEBAR, WIDTH-get_image_width(GR_SIDEBAR)+slide, 0, 255);
 377         show_image(GR_TENNIXLOGO, WIDTH-get_image_width(GR_SIDEBAR)-10, 20-slide, 255);
 378         if (state != MENU_STATE_OPTIONS) {
 379             /* Main Menu */
 380             show_image(GR_BTN_PLAY, WIDTH-get_image_width(GR_BTN_PLAY)+slide+(slide/7)+3-(3*(btn_hovering==MENU_START)), 150, 255);
 381             if (current_game != NULL) {
 382                 show_image(GR_BTN_RESUME, WIDTH-get_image_width(GR_BTN_RESUME)+slide+(slide/7)+3-(3*(btn_hovering==MENU_RESUME)), 230, 255);
 383                 font_draw_string(GR_DKC2_FONT, "current match:", 10, 10, 0, 0);
 384                 font_draw_string(GR_DKC2_FONT, current_game->sets_score_str, 10, 40, 0, 0);
 385             }
 386             show_image(GR_BTN_QUIT, WIDTH-get_image_width(GR_BTN_QUIT)+slide+(slide/7)+3-(3*(btn_hovering==MENU_QUIT)), 350, 255);
 387         } else {
 388             /* Options screen */
 389             show_image(GR_TENNIXLOGO, WIDTH-get_image_width(GR_SIDEBAR)-10, 20, 255);
 390             draw_button_object(btn_back, mx, my);
 391             draw_button_object(btn_start, mx, my);
 392             if (prepared_game != NULL) {
 393                 fill_image(prepared_game->court_type, MENU_OPTIONS_BORDER, MENU_OPTIONS_BORDER*2, get_image_width(GR_STADIUM), get_image_height(GR_STADIUM));
 394                 show_image(GR_STADIUM, MENU_OPTIONS_BORDER, MENU_OPTIONS_BORDER*2, 255);
 395                 draw_button_object(btn_court_change, mx, my);
 396                 font_draw_string(GR_DKC2_FONT, "Location", MENU_OPTIONS_BORDER, MENU_OPTIONS_BORDER, 0, 0);
 397                 draw_button_object(btn_player1, mx, my);
 398                 draw_button_object(btn_player2, mx, my);
 399                 font_draw_string(GR_DKC2_FONT, "Player 1", btn_player1.x, btn_player1.y-MENU_OPTIONS_BORDER, 0, 0);
 400                 font_draw_string(GR_DKC2_FONT, "Player 2", btn_player2.x, btn_player2.y-MENU_OPTIONS_BORDER, 0, 0);
 401             }
 402         }
 403
 404         SDL_PollEvent( &e);
 405         if( e.type == SDL_QUIT) {
 406             state = MENU_STATE_SLIDE_TO_QUIT;
 407             /*break;*/
 408         }
 409
 410         keys = SDL_GetKeyState( NULL);
 411         mb = SDL_GetMouseState( &mx, &my);
 412
 413         btn_hovering_old = btn_hovering;
 414         if (state == MENU_STATE_MAINMENU) {
 415             btn_hovering = M_POS_DECODE(mx, my);
 416             if (current_game == NULL) {
 417                 btn_hovering &= ~MENU_RESUME;
 418             }
 419         } else if (state == MENU_STATE_OPTIONS) {
 420             if (M_POS_BUTTON(btn_back, mx, my)) {
 421                 btn_hovering = MENU_QUIT;
 422             } else if (M_POS_BUTTON(btn_start, mx, my)) {
 423                 btn_hovering = MENU_START;
 424             } else if (M_POS_BUTTON(btn_court_change, mx, my)) {
 425                 btn_hovering = MENU_COURT_CHANGE;
 426             } else if (M_POS_BUTTON(btn_player1, mx, my)) {
 427                 btn_hovering = MENU_PLAYER1;
 428             } else if (M_POS_BUTTON(btn_player2, mx, my)) {
 429                 btn_hovering = MENU_PLAYER2;
 430             } else {
 431                 btn_hovering = 0;
 432             }
 433         } else {
 434             /* No menu screen - no hovering. */
 435             btn_hovering = 0;
 436         }
 437 #ifndef MAEMO /* On Maemo, we cannot really "hover" (touchscreen!) */
 438         if (btn_hovering_old != btn_hovering && btn_hovering != 0) {
 439 #ifdef HAVE_VOICE_FILES
 440             if (btn_hovering == MENU_QUIT) {
 441                 play_sample(VOICE_QUIT_IT);
 442             } else if (btn_hovering == MENU_START) {
 443                 play_sample(VOICE_NEW_GAME);
 444             } else {
 445                 play_sample(SOUND_MOUSEOVER);
 446             }
 447 #else
 448             play_sample(SOUND_MOUSEOVER);
 449 #endif
 450         }
 451 #endif
 452
 453         if( keys[SDLK_ESCAPE] || keys['q']) {
 454             /* FIXME: do the state thingie! */
 455             break;
 456         }
 457
 458         if( keys['f']) {
 459             SDL_WM_ToggleFullScreen( screen);
 460         }
 461
 462 #ifndef MAEMO /* No mouse cursor on Maemo (we have a touchscreen) */
 463         if (state == MENU_STATE_MAINMENU || state == MENU_STATE_OPTIONS) {
 464             show_sprite( GR_RACKET, ((mb&SDL_BUTTON( SDL_BUTTON_LEFT))>0)+(((mb&SDL_BUTTON( SDL_BUTTON_RIGHT))>0)*2), 4, mx, my, 255);
 465         }
 466 #endif
 467
 468         /* Draw the "real" mouse coordinates */
 469         /*rectangle(mx-1, my-1, 2, 2, 255, 255, 255);*/
 470
 471         /* Store the screen, because we are fading after this screen update */
 472         /*if (!(mb & SDL_BUTTON(SDL_BUTTON_LEFT)) && btn_hovering != MENU_NONE && mouse_pressed == true) store_screen();*/
 473
 474         updatescr();
 475
 476         if( mb & SDL_BUTTON(SDL_BUTTON_LEFT)) {
 477             mouse_pressed = true;
 478         } else if (mouse_pressed == true) {
 479             /* Mouse button released */
 480             if (state == MENU_STATE_MAINMENU || state == MENU_STATE_OPTIONS) {
 481 #ifdef HAVE_VOICE_FILES
 482                 if (btn_hovering == MENU_START) {
 483                     play_sample(VOICE_LETS_GO);
 484                 } else {
 485                     play_sample(SOUND_MOUSECLICK);
 486                 }
 487 #else
 488                 play_sample(SOUND_MOUSECLICK);
 489 #endif
 490             }
 491             if (state == MENU_STATE_MAINMENU) {
 492                 switch (btn_hovering) {
 493                     case MENU_START:
 494                         state = MENU_STATE_SLIDE_TO_OPTIONS;
 495                         break;
 496                     case MENU_RESUME:
 497                         state = MENU_STATE_SLIDE_TO_RESUME;
 498                         break;
 499                     case MENU_QUIT:
 500                         state = MENU_STATE_SLIDE_TO_QUIT;
 501                         break;
 502                 }
 503             } else if (state == MENU_STATE_OPTIONS) {
 504                 switch (btn_hovering) {
 505                     case MENU_START:
 506                         state = MENU_STATE_SLIDE_TO_GAME;
 507                         break;
 508                     case MENU_QUIT:
 509                         state = MENU_STATE_SLIDE_TO_MAINMENU;
 510                         break;
 511                     case MENU_COURT_CHANGE:
 512                         prepared_game->court_type++;
 513                         if (prepared_game->court_type > GR_CTT_LAST) {
 514                             prepared_game->court_type = GR_CTT_FIRST;
 515                         }
 516                         break;
 517                     case MENU_PLAYER1:
 518                         switch (prepared_game->player1.type) {
 519                             case PLAYER_TYPE_HUMAN:
 520                                 prepared_game->player1.type = PLAYER_TYPE_AI;
 521                                 btn_player1.text = "Computer (AI)";
 522                                 break;
 523                             case PLAYER_TYPE_AI:
 524                                 prepared_game->player1.type = PLAYER_TYPE_HUMAN;
 525                                 btn_player1.text = "Keyboard (W-S-D)";
 526                                 break;
 527                         }
 528                         break;
 529                     case MENU_PLAYER2:
 530                         switch (prepared_game->player2.type) {
 531                             case PLAYER_TYPE_HUMAN:
 532                                 prepared_game->player2.type = PLAYER_TYPE_AI;
 533                                 btn_player2.text = "Computer (AI)";
 534                                 break;
 535                             case PLAYER_TYPE_AI:
 536                                 prepared_game->player2.type = PLAYER_TYPE_HUMAN;
 537                                 btn_player2.text = "Keyboard (O-L-K)";
 538                                 break;
 539                         }
 540                         break;
 541                 }
 542             }
 543             mouse_pressed = false;
 544         }
 545         i++;
 546 #ifdef ENABLE_FPS_LIMIT
 547         while (frames*1000.0/((float)(SDL_GetTicks()-ft+1))>(float)(DEFAULT_FPS)) {
 548             SDL_Delay(10);
 549         }
 550         frames++;
 551 #endif
 552     }
 553
 554     uninit_graphics();
 555     uninit_joystick();
 556
 557     SDL_Quit();
 558     return 0;
 559 }
 560