vcs.maemo.org Git - neverball/blob - ball/st_play_end.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 "set.h"
  19 #include "game.h"
  20 #include "util.h"
  21 #include "levels.h"
  22 #include "audio.h"
  23 #include "config.h"
  24 #include "demo.h"
  25 #include "st_shared.h"
  26
  27 #include "st_play_end.h"
  28 #include "st_save.h"
  29 #include "st_over.h"
  30 #include "st_done.h"
  31 #include "st_start.h"
  32 #include "st_level.h"
  33 #include "st_name.h"
  34
  35 /*---------------------------------------------------------------------------*/
  36
  37 #define PLAY_END_NEXT 2
  38 #define PLAY_END_SAME 3
  39 #define PLAY_END_SAVE 4
  40 #define PLAY_END_BACK 5
  41 #define PLAY_END_DONE 6
  42 #define PLAY_END_NAME 7
  43 #define PLAY_END_OVER 8
  44
  45 static int balls_id;
  46 static int coins_id;
  47 static int score_id;
  48 static int status_id;
  49
  50 extern struct state st_play_end_bis;
  51
  52 static int play_end_action(int i)
  53 {
  54     audio_play(AUD_MENU, 1.0f);
  55
  56     switch (i)
  57     {
  58     case PLAY_END_BACK:
  59     case PLAY_END_OVER:
  60         return goto_end_level();
  61
  62     case PLAY_END_SAVE:
  63         return goto_save(&st_play_end_bis, &st_play_end_bis);
  64
  65     case PLAY_END_NAME:
  66         return goto_name(&st_play_end_bis, &st_play_end_bis);
  67
  68     case PLAY_END_DONE:
  69         return goto_state(&st_done);
  70
  71     case PLAY_END_NEXT:
  72         level_next();
  73         level_play(curr_lg()->level, curr_lg()->mode);
  74         return goto_state(&st_level);
  75
  76     case PLAY_END_SAME:
  77         level_play(curr_lg()->level, curr_lg()->mode);
  78         return goto_state(&st_level);
  79     }
  80
  81     return 1;
  82 }
  83
  84 static void play_end_over(int id)
  85 {
  86     if (id == 0)
  87         return;
  88
  89     switch (gui_token(id))
  90     {
  91         case 0:
  92             break;
  93
  94         case PLAY_END_SAVE:
  95             gui_set_label(status_id, _("Save a replay file"));
  96             break;
  97
  98         case PLAY_END_SAVE | GUI_NULL_MASK:
  99             gui_set_label(status_id, _("Replay file already saved"));
 100             break;
 101
 102         case PLAY_END_NAME:
 103             gui_set_label(status_id, _("Change the player's name"));
 104             break;
 105
 106         case PLAY_END_DONE:
 107             gui_set_label(status_id, _("You complete the set"));
 108             break;
 109
 110         case PLAY_END_NEXT:
 111             gui_set_label(status_id, _("Play the next level"));
 112             break;
 113
 114         case PLAY_END_NEXT | GUI_NULL_MASK:
 115             if (curr_lg()->mode == MODE_PRACTICE)
 116                 gui_set_label(status_id,
 117                         _("Cannot unlock in practice mode"));
 118             else
 119                 gui_set_label(status_id,
 120                         _("Finish this level to unlock the next one"));
 121             break;
 122
 123         case PLAY_END_SAME:
 124             gui_set_label(status_id, _("Replay this level"));
 125             break;
 126
 127         case PLAY_END_SAME | GUI_NULL_MASK:
 128             gui_set_label(status_id, _("You cannot replay in challenge mode"));
 129             break;
 130
 131         default:
 132             gui_set_label(status_id, "");
 133     }
 134 }
 135
 136
 137 static int play_end_init(int *gidp)
 138 {
 139     const struct level_game *lg = curr_lg();
 140     int mode  = lg->mode;
 141     int state = lg->state;
 142     const struct level *l = lg->level;
 143
 144     int id, jd, kd;
 145     int high;
 146
 147     high = (lg->time_rank < 3) || (lg->goal_rank < 3) || (lg->coin_rank < 3);
 148
 149     if ((id = gui_vstack(0)))
 150     {
 151         int gid;
 152
 153         if (state == GAME_FALL)
 154             gid = gui_label(id, _("Fall-out!"), GUI_MED, GUI_ALL,
 155                             gui_gry, gui_red);
 156         else if (state == GAME_TIME)
 157             gid = gui_label(id, _("Time's Up!"), GUI_MED, GUI_ALL,
 158                             gui_gry, gui_red);
 159         else if (high)
 160             gid = gui_label(id, _("New Record"), GUI_MED, GUI_ALL,
 161                             gui_grn, gui_grn);
 162         else
 163             gid = gui_label(id, _("GOAL"), GUI_LRG, GUI_ALL,
 164                             gui_blu, gui_grn);
 165
 166         gui_space(id);
 167
 168         if (mode == MODE_CHALLENGE &&
 169             (lg->state == GAME_GOAL || l->is_bonus))
 170         {
 171             int coins = lg->coins;
 172             int score = lg->score - coins;
 173             int balls = lg->balls - count_extra_balls(score, coins);
 174             if ((jd = gui_hstack(id)))
 175             {
 176                 if ((kd = gui_harray(jd)))
 177                 {
 178                     balls_id = gui_count(kd,  100, GUI_MED, GUI_RGT);
 179                     gui_label(kd, _("Balls"), GUI_SML, GUI_LFT, gui_wht, gui_wht);
 180                 }
 181                 if ((kd = gui_harray(jd)))
 182                 {
 183                     score_id = gui_count(kd, 1000, GUI_MED, GUI_RGT);
 184                     gui_label(kd, _("Score"), GUI_SML, GUI_LFT, gui_wht, gui_wht);
 185                 }
 186                 if ((kd = gui_harray(jd)))
 187                 {
 188                     coins_id = gui_count(kd, 100, GUI_MED, GUI_RGT);
 189                     gui_label(kd, _("Coins"), GUI_SML, GUI_LFT, gui_wht, gui_wht);
 190                 }
 191
 192                 gui_set_count(balls_id, balls);
 193                 gui_set_count(score_id, score);
 194                 gui_set_count(coins_id, coins);
 195             }
 196         }
 197         else
 198         {
 199             balls_id = score_id = coins_id = 0;
 200         }
 201
 202         if (state == GAME_GOAL)
 203         {
 204             gui_space(id);
 205             if ((jd = gui_harray(id)))
 206             {
 207                 gui_most_coins(jd, 1);
 208                 gui_best_times(jd, 1);
 209             }
 210         }
 211
 212         gui_space(id);
 213
 214         if ((jd = gui_harray(id)))
 215         {
 216             int nlid = 0, rlid = 0;
 217             int b = 0;
 218
 219             if (lg->win)
 220                 gui_start(jd, _("Finish"), GUI_SML, PLAY_END_DONE, 0);
 221             else
 222                 nlid = gui_maybe(jd, _("Next Level"),  PLAY_END_NEXT,
 223                                  lg->next_level != NULL);
 224
 225             if (lg->dead)
 226                 gui_start(jd, _("Game Over"), GUI_SML, PLAY_END_OVER, 0);
 227             else
 228             {
 229                 b = mode != MODE_CHALLENGE || ((state == GAME_FALL || state == GAME_TIME) && !lg->dead && !l->is_bonus);
 230                 rlid = gui_maybe(jd, _("Retry Level"), PLAY_END_SAME, b);
 231             }
 232
 233             gui_maybe(jd, _("Save Replay"), PLAY_END_SAVE, demo_play_saved());
 234
 235             /* default is next if the next level is newly unlocked */
 236             if (nlid != 0 && lg->unlock)
 237                  gui_focus(nlid);
 238             else if (b)
 239                  gui_focus(rlid);
 240         }
 241
 242         if (high)
 243             gui_state(id, _("Change Player Name"),  GUI_SML, PLAY_END_NAME, 0);
 244
 245         gui_space(id);
 246         status_id = gui_label(id, "Neverball", GUI_SML, GUI_ALL, 0, 0);
 247
 248         gui_layout(id, 0, 0);
 249         if (gidp) *gidp = gid;
 250     }
 251
 252     if (state == GAME_GOAL)
 253     {
 254         set_most_coins(&l->score.most_coins, lg->coin_rank);
 255         if (mode == MODE_CHALLENGE || mode == MODE_NORMAL)
 256             set_best_times(&l->score.unlock_goal, lg->goal_rank, 1);
 257         else
 258             set_best_times(&l->score.best_times, lg->time_rank, 0);
 259     }
 260
 261     config_clr_grab();
 262
 263     return id;
 264 }
 265
 266 static int play_end_enter(void)
 267 {
 268     int gid;
 269     int r;
 270
 271     r = play_end_init(&gid);
 272
 273     gui_pulse(gid, 1.2f);
 274     audio_music_fade_out(2.0f);
 275     return r;
 276 }
 277
 278 static int play_end_bis_enter(void)
 279 {
 280     level_update_player_name();
 281     return play_end_init(NULL);
 282 }
 283
 284 static void play_end_timer(int id, float dt)
 285 {
 286     static float DT = 0.0f;
 287
 288     float gg[3] = { 0.0f, 9.8f, 0.0f };
 289     float gf[3] = { 0.0f, -9.8f, 0.0f };
 290     int state = curr_lg()->state;
 291
 292     DT += dt;
 293
 294     if (state != GAME_TIME)
 295     {
 296         if (time_state() < 2.f)
 297             game_step(state == GAME_GOAL ? gg : gf, dt, 0);
 298     }
 299
 300     if (time_state() > 1.f && DT > 0.05f && coins_id != 0)
 301     {
 302         int coins = gui_value(coins_id);
 303         if (coins > 0)
 304         {
 305             int score = gui_value(score_id);
 306             int balls = gui_value(balls_id);
 307
 308             gui_set_count(coins_id, coins - 1);
 309             gui_pulse(coins_id, 1.1f);
 310
 311             gui_set_count(score_id, score + 1);
 312             gui_pulse(score_id, 1.1f);
 313
 314             if ((score + 1) % 100 == 0)
 315             {
 316                 gui_set_count(balls_id, balls + 1);
 317                 gui_pulse(balls_id, 2.0f);
 318                 audio_play(AUD_BALL, 1.0f);
 319             }
 320         }
 321
 322         DT = 0.0f;
 323     }
 324
 325     gui_timer(id, dt);
 326     audio_timer(dt);
 327 }
 328
 329 void play_end_stick(int id, int a, int v)
 330 {
 331         play_end_over(shared_stick_basic(id, a, v));
 332 }
 333
 334 void play_end_point(int id, int x, int y, int dx, int dy)
 335 {
 336         play_end_over(shared_point_basic(id, x, y));
 337 }
 338
 339 static int play_end_buttn(int b, int d)
 340 {
 341     if (d)
 342     {
 343         if (config_tst_d(CONFIG_JOYSTICK_BUTTON_A, b))
 344             return play_end_action(gui_token(gui_click()));
 345         if (config_tst_d(CONFIG_JOYSTICK_BUTTON_EXIT, b))
 346             return play_end_action(PLAY_END_BACK);
 347     }
 348     return 1;
 349 }
 350
 351 /*---------------------------------------------------------------------------*/
 352
 353 struct state st_play_end = {
 354     play_end_enter,
 355     shared_leave,
 356     shared_paint,
 357     play_end_timer,
 358     play_end_point,
 359     play_end_stick,
 360     shared_click,
 361     NULL,
 362     play_end_buttn,
 363     1, 0
 364 };
 365
 366 struct state st_play_end_bis = {
 367     play_end_bis_enter,
 368     shared_leave,
 369     shared_paint,
 370     shared_timer,
 371     play_end_point,
 372     play_end_stick,
 373     shared_click,
 374     NULL,
 375     play_end_buttn,
 376     1, 0
 377 };