vcs.maemo.org Git - neverball/blob - ball/st_demo.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 <string.h>
  16
  17 #include "gui.h"
  18 #include "hud.h"
  19 #include "set.h"
  20 #include "game.h"
  21 #include "demo.h"
  22 #include "levels.h"
  23 #include "audio.h"
  24 #include "solid.h"
  25 #include "config.h"
  26 #include "st_shared.h"
  27 #include "util.h"
  28
  29 #include "st_demo.h"
  30 #include "st_title.h"
  31
  32 extern struct state st_demo_play;
  33 extern struct state st_demo_end;
  34 extern struct state st_demo_del;
  35
  36 /*---------------------------------------------------------------------------*/
  37
  38 #define DEMO_LINE 4
  39 #define DEMO_STEP 8
  40
  41 static int first = 0;
  42 static int total = 0;
  43
  44 static float replay_time;
  45 static float global_time;
  46
  47 /*---------------------------------------------------------------------------*/
  48
  49 static int demo_action(int i)
  50 {
  51     audio_play(AUD_MENU, 1.0f);
  52
  53     switch (i)
  54     {
  55     case GUI_BACK:
  56         return goto_state(&st_title);
  57
  58     case GUI_NEXT:
  59         first += DEMO_STEP;
  60         return goto_state(&st_demo);
  61         break;
  62
  63     case GUI_PREV:
  64         first -= DEMO_STEP;
  65         return goto_state(&st_demo);
  66         break;
  67
  68     default:
  69         if (level_replay(get_demo(i)->filename))
  70             return goto_demo_play(0);
  71     }
  72     return 1;
  73 }
  74
  75 static void demo_replay(int id, int i)
  76 {
  77     int w = config_get_d(CONFIG_WIDTH);
  78     int h = config_get_d(CONFIG_HEIGHT);
  79     int jd;
  80     char nam[MAXNAM + 3];
  81
  82     if ((jd = gui_vstack(id)))
  83     {
  84         gui_space(jd);
  85
  86         gui_image(jd, get_demo(i)->shot, w / 6, h / 6);
  87         nam[MAXNAM - 1] = '\0';
  88         strncpy(nam, get_demo(i)->name, MAXNAM);
  89         if (nam[MAXNAM - 1] != '\0')
  90         {
  91             nam[MAXNAM - 2] = '.';
  92             nam[MAXNAM - 1] = '.';
  93             nam[MAXNAM + 0] = '.';
  94             nam[MAXNAM + 1] = '\0';
  95         }
  96         gui_state(jd, nam, GUI_SML, i, 0);
  97
  98         gui_active(jd, i, 0);
  99     }
 100 }
 101
 102 static int name_id;
 103 static int time_id;
 104 static int coin_id;
 105 static int date_id;
 106 static int level_id;
 107 static int mode_id;
 108 static int state_id;
 109 static int player_id;
 110
 111 static int gui_demo_status(int id, const struct demo *d)
 112 /* Create a layout for some demo info, if d is NULL, try to reserve enough
 113  * space */
 114 {
 115     char noname[MAXNAM];
 116     const char *mode, *state;
 117     int i, j, k;
 118     int jd, kd, ld, md;
 119
 120     if (d == NULL)
 121     {
 122         /* Build a long name */
 123         memset(noname, 'M', MAXNAM - 1);
 124         noname[MAXNAM - 1] = '\0';
 125
 126         /* Get a long mode */
 127         mode = mode_to_str(0);
 128         j = strlen(mode);
 129         for (i = 1; i <= MODE_SINGLE; i++)
 130         {
 131             k = strlen(mode_to_str(i));
 132             if (k > j)
 133             {
 134                 j = k;
 135                 mode = mode_to_str(i);
 136             }
 137         }
 138
 139         /* Get a long state */
 140         state = state_to_str(0);
 141         j = strlen(state);
 142         for (i = 1; i <= GAME_FALL; i++)
 143         {
 144             k = strlen(state_to_str(i));
 145             if (k > j)
 146             {
 147                 j = k;
 148                 state = state_to_str(i);
 149             }
 150         }
 151     }
 152     else
 153     {
 154         mode = mode_to_str(d->mode);
 155         state = state_to_str(d->state);
 156     }
 157
 158     if ((jd = gui_hstack(id)))
 159     {
 160         if ((kd = gui_vstack(jd)))
 161         {
 162             if ((ld = gui_harray(kd)))
 163             {
 164                 if ((md = gui_vstack(ld)))
 165                 {
 166                     player_id =
 167                         gui_label(md, (d ? d->player : noname), GUI_SML,
 168                                   GUI_RGT, 0, 0);
 169                     coin_id =
 170                         gui_count(md, (d ? d->coins : 100), GUI_SML, GUI_RGT);
 171                     state_id =
 172                         gui_label(md, state, GUI_SML, GUI_RGT, gui_red,
 173                                   gui_red);
 174                 }
 175                 if ((md = gui_vstack(ld)))
 176                 {
 177                     gui_label(md, _("Player"), GUI_SML, GUI_LFT, gui_wht,
 178                               gui_wht);
 179                     gui_label(md, _("Coins"), GUI_SML, GUI_LFT, gui_wht,
 180                               gui_wht);
 181                     gui_label(md, _("State"), GUI_SML, GUI_LFT, gui_wht,
 182                               gui_wht);
 183                 }
 184                 if ((md = gui_vstack(ld)))
 185                 {
 186                     name_id =
 187                         gui_label(md, (d ? d->name : noname), GUI_SML, GUI_RGT,
 188                                   0, 0);
 189                     time_id =
 190                         gui_clock(md, (d ? d->timer : 35000), GUI_SML, GUI_RGT);
 191                     mode_id = gui_label(md, mode, GUI_SML, GUI_RGT, 0, 0);
 192                 }
 193             }
 194             level_id =
 195                 gui_label(kd, (d ? d->file : "M"), GUI_SML, GUI_RGT, gui_wht,
 196                           gui_wht);
 197             date_id =
 198                 gui_label(kd, (d ? date_to_str(d->date) : "M"), GUI_SML,
 199                           GUI_RGT, 0, 0);
 200         }
 201         if ((kd = gui_vstack(jd)))
 202         {
 203             gui_label(kd, _("Replay"), GUI_SML, GUI_LFT, gui_wht, gui_wht);
 204             gui_label(kd, _("Time"), GUI_SML, GUI_LFT, gui_wht, gui_wht);
 205             gui_label(kd, _("Mode"), GUI_SML, GUI_LFT, gui_wht, gui_wht);
 206             gui_label(kd, _("Level"), GUI_SML, GUI_LFT, gui_wht, gui_wht);
 207             gui_label(kd, _("Date"), GUI_SML, GUI_LFT, gui_wht, gui_wht);
 208         }
 209         if (d && (d->state == GAME_GOAL || d->state == GAME_SPEC))
 210             gui_set_color(state_id, gui_grn, gui_grn);
 211     }
 212     return jd;
 213 }
 214
 215 static void gui_demo_update_status(int i)
 216 {
 217     const struct demo *d = get_demo(i);
 218
 219     gui_set_label(name_id,   d->name);
 220     gui_set_label(date_id,   date_to_str(d->date));
 221     gui_set_label(level_id,  d->file);
 222     gui_set_label(player_id, d->player);
 223     gui_set_label(mode_id,   mode_to_str(d->mode));
 224
 225     if (d->state == GAME_GOAL || d->state == GAME_SPEC)
 226         gui_set_color(state_id, gui_grn, gui_grn);
 227     else
 228         gui_set_color(state_id, gui_red, gui_red);
 229
 230     gui_set_label(state_id, state_to_str(d->state));
 231     gui_set_count(coin_id, d->coins);
 232     gui_set_clock(time_id, d->timer);
 233 }
 234
 235 static int demo_enter(void)
 236 {
 237     int i, j;
 238     int id, jd, kd, ld;
 239
 240     total = demo_scan();
 241
 242     id = gui_vstack(0);
 243     if (total == 0)
 244     {
 245         gui_label(id, _("No Replays"), GUI_MED, GUI_ALL, 0,0);
 246         gui_filler(id);
 247         gui_multi(id, _("You can save replays of your games.\\"
 248                         "Currently, there are no replays saved."),
 249                   GUI_SML, GUI_ALL, gui_wht, gui_wht);
 250         gui_filler(id);
 251         gui_start(id, _("Back"), GUI_SML, GUI_BACK, 0);
 252         gui_layout(id, 0, 0);
 253     }
 254     else
 255     {
 256         if ((jd = gui_hstack(id)))
 257         {
 258
 259             ld = gui_label(jd, _("Select Replay"), GUI_SML, GUI_ALL, 0,0);
 260             gui_filler(jd);
 261             gui_back_prev_next(jd, first > 0, first + DEMO_STEP < total);
 262         }
 263         if ((jd = gui_varray(id)))
 264             for (i = first; i < first + DEMO_STEP ; i += DEMO_LINE)
 265                 if ((kd = gui_harray(jd)))
 266                 {
 267                     for (j = i + DEMO_LINE - 1; j >= i; j--)
 268                         if (j < total)
 269                             demo_replay(kd, j);
 270                         else
 271                             gui_space(kd);
 272                 }
 273         gui_filler(id);
 274         gui_demo_status(id, NULL);
 275         gui_layout(id, 0, 0);
 276         gui_demo_update_status(0);
 277     }
 278
 279     audio_music_fade_to(0.5f, "bgm/inter.ogg");
 280
 281     return id;
 282 }
 283
 284 static void demo_point(int id, int x, int y, int dx, int dy)
 285 {
 286     int jd = shared_point_basic(id, x, y);
 287     int i  = gui_token(jd);
 288     if (jd && i >= 0)
 289         gui_demo_update_status(i);
 290 }
 291
 292 static void demo_stick(int id, int a, int v)
 293 {
 294     int jd = shared_stick_basic(id, a, v);
 295     int i  = gui_token(jd);
 296     if (jd && i >= 0)
 297         gui_demo_update_status(i);
 298 }
 299
 300 static int demo_buttn(int b, int d)
 301 {
 302     if (d)
 303     {
 304         if (config_tst_d(CONFIG_JOYSTICK_BUTTON_A, b))
 305             return demo_action(gui_token(gui_click()));
 306         if (config_tst_d(CONFIG_JOYSTICK_BUTTON_EXIT, b))
 307             return demo_action(GUI_BACK);
 308     }
 309     return 1;
 310 }
 311
 312 /*---------------------------------------------------------------------------*/
 313
 314 static int simple_play;
 315
 316 int goto_demo_play(int simple)
 317 {
 318     simple_play = simple;
 319     return goto_state(&st_demo_play);
 320 }
 321
 322 static int demo_play_enter(void)
 323 {
 324     int id;
 325
 326     if ((id = gui_vstack(0)))
 327     {
 328         gui_label(id, _("Replay"), GUI_LRG, GUI_ALL, gui_blu, gui_grn);
 329         gui_layout(id, 0, 0);
 330         gui_pulse(id, 1.2f);
 331     }
 332
 333     global_time = -1.f;
 334     replay_time =  0.f;
 335
 336     hud_update(0);
 337
 338     game_set_fly(0.f);
 339
 340     return id;
 341 }
 342
 343 static void demo_play_paint(int id, float st)
 344 {
 345     game_draw(0, st);
 346     hud_paint();
 347
 348     if (time_state() < 1.f)
 349         gui_paint(id);
 350 }
 351
 352 static void demo_play_timer(int id, float dt)
 353 {
 354     float t;
 355
 356     game_step_fade(dt);
 357     gui_timer(id, dt);
 358     audio_timer(dt);
 359
 360     global_time += dt;
 361     hud_timer(dt);
 362
 363     /* Spin or skip depending on how fast the demo wants to run. */
 364
 365     while (replay_time < global_time)
 366         if (demo_replay_step(&t))
 367         {
 368             replay_time += t;
 369         }
 370         else
 371         {
 372             goto_state(&st_demo_end);
 373             break;
 374         }
 375 }
 376
 377 static int demo_play_buttn(int b, int d)
 378 {
 379     if (d)
 380     {
 381         if (config_tst_d(CONFIG_JOYSTICK_BUTTON_EXIT, b))
 382             return goto_state(&st_demo_end);
 383     }
 384     return 1;
 385 }
 386
 387 /*---------------------------------------------------------------------------*/
 388
 389 #define DEMO_KEEP    0
 390 #define DEMO_DEL     1
 391 #define DEMO_QUIT    2
 392 #define DEMO_REPLAY  3
 393
 394 static int demo_end_action(int i)
 395 {
 396     audio_play(AUD_MENU, 1.0f);
 397
 398     switch (i)
 399     {
 400     case DEMO_DEL:
 401         return goto_state(&st_demo_del);
 402     case DEMO_KEEP:
 403         demo_replay_stop(0);
 404         return goto_state(&st_demo);
 405     case DEMO_QUIT:
 406         demo_replay_stop(0);
 407         return 0;
 408     case DEMO_REPLAY:
 409         demo_replay_stop(0);
 410         level_replay(curr_demo_replay()->filename);
 411         return goto_state(&st_demo_play);
 412     }
 413     return 1;
 414 }
 415
 416 static int demo_end_enter(void)
 417 {
 418     int id, jd, kd;
 419
 420     if ((id = gui_vstack(0)))
 421     {
 422         kd = gui_label(id, _("Replay Ends"), GUI_LRG, GUI_ALL, gui_gry, gui_red);
 423
 424         if ((jd = gui_harray(id)))
 425         {
 426             gui_start(jd, _("Replay Again"), GUI_SML, DEMO_REPLAY, 0);
 427             if (simple_play)
 428                 gui_start(jd, _("OK"),       GUI_SML, DEMO_QUIT,   1);
 429             else
 430             {
 431                 gui_start(jd, _("Keep"),     GUI_SML, DEMO_KEEP,   1);
 432                 gui_state(jd, _("Delete"),   GUI_SML, DEMO_DEL,    0);
 433             }
 434         }
 435
 436         gui_filler(id);
 437
 438         if ((jd = gui_hstack(id)))
 439         {
 440             gui_filler(jd);
 441             gui_demo_status(jd, curr_demo_replay());
 442             gui_filler(jd);
 443         }
 444
 445         gui_pulse(kd, 1.2f);
 446         gui_layout(id, 0, 0);
 447     }
 448     audio_music_fade_out(2.0f);
 449
 450     return id;
 451 }
 452
 453 static void demo_end_timer(int id, float dt)
 454 {
 455     float gg[3] = { 0.0f,  9.8f, 0.0f };
 456     float gf[3] = { 0.0f, -9.8f, 0.0f };
 457     int state = curr_demo_replay()->state;
 458
 459     if (time_state() < 2.f && state != GAME_NONE)
 460         game_step((state == GAME_GOAL || state == GAME_SPEC) ? gg : gf, dt, NULL);
 461
 462     gui_timer(id, dt);
 463     audio_timer(dt);
 464 }
 465
 466 static int demo_end_buttn(int b, int d)
 467 {
 468     if (d)
 469     {
 470         if (config_tst_d(CONFIG_JOYSTICK_BUTTON_A, b))
 471             return demo_end_action(gui_token(gui_click()));
 472         if (config_tst_d(CONFIG_JOYSTICK_BUTTON_EXIT, b))
 473             return demo_end_action(simple_play ? DEMO_QUIT : DEMO_KEEP);
 474     }
 475     return 1;
 476 }
 477
 478 /*---------------------------------------------------------------------------*/
 479
 480 static int demo_del_action(int i)
 481 {
 482     audio_play(AUD_MENU, 1.0f);
 483
 484     demo_replay_stop(i == DEMO_DEL);
 485     return goto_state(&st_demo);
 486 }
 487
 488 static int demo_del_enter(void)
 489 {
 490     int id, jd, kd;
 491
 492     if ((id = gui_vstack(0)))
 493     {
 494         kd = gui_label(id, _("Delete Replay?"), GUI_MED, GUI_ALL, gui_red, gui_red);
 495
 496         if ((jd = gui_harray(id)))
 497         {
 498             gui_start(jd, _("No"),  GUI_SML, DEMO_KEEP, 1);
 499             gui_state(jd, _("Yes"), GUI_SML, DEMO_DEL,  0);
 500         }
 501
 502         gui_pulse(kd, 1.2f);
 503         gui_layout(id, 0, 0);
 504     }
 505     audio_music_fade_out(2.0f);
 506
 507     return id;
 508 }
 509
 510 static int demo_del_buttn(int b, int d)
 511 {
 512     if (d)
 513     {
 514         if (config_tst_d(CONFIG_JOYSTICK_BUTTON_A, b))
 515             return demo_del_action(gui_token(gui_click()));
 516         if (config_tst_d(CONFIG_JOYSTICK_BUTTON_EXIT, b))
 517             return demo_del_action(DEMO_KEEP);
 518     }
 519     return 1;
 520 }
 521
 522 /*---------------------------------------------------------------------------*/
 523
 524 struct state st_demo = {
 525     demo_enter,
 526     shared_leave,
 527     shared_paint,
 528     shared_timer,
 529     demo_point,
 530     demo_stick,
 531     shared_click,
 532     NULL,
 533     demo_buttn,
 534     0
 535 };
 536
 537 struct state st_demo_play = {
 538     demo_play_enter,
 539     shared_leave,
 540     demo_play_paint,
 541     demo_play_timer,
 542     NULL,
 543     NULL,
 544     NULL,
 545     NULL,
 546     demo_play_buttn,
 547     0
 548 };
 549
 550 struct state st_demo_end = {
 551     demo_end_enter,
 552     shared_leave,
 553     shared_paint,
 554     demo_end_timer,
 555     shared_point,
 556     shared_stick,
 557     shared_click,
 558     NULL,
 559     demo_end_buttn,
 560     1, 0
 561 };
 562
 563 struct state st_demo_del = {
 564     demo_del_enter,
 565     shared_leave,
 566     shared_paint,
 567     shared_timer,
 568     shared_point,
 569     shared_stick,
 570     shared_click,
 571     NULL,
 572     demo_del_buttn,
 573     1, 0
 574 };