vcs.maemo.org Git - neverball/blob - ball/set.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 <stdio.h>
  16 #include <string.h>
  17 #include <assert.h>
  18 #include <errno.h>
  19
  20 #include "glext.h"
  21 #include "config.h"
  22 #include "image.h"
  23 #include "set.h"
  24 #include "game.h"
  25
  26 /*---------------------------------------------------------------------------*/
  27
  28 static int count;                    /* number of sets */
  29
  30 static struct set set_v[MAXSET];     /* array of sets */
  31
  32 static struct set *current_set;      /* currently selected set */
  33
  34 static struct level level_v[MAXLVL]; /* levels of the current set  */
  35
  36 /*---------------------------------------------------------------------------*/
  37
  38 static void put_score(FILE *fp, const struct score *s)
  39 {
  40     int j;
  41     for (j = 0; j < NSCORE; j++)
  42        fprintf(fp, "%d %d %s\n", s->timer[j], s->coins[j], s->player[j]);
  43 }
  44
  45 static void set_store_hs(void)
  46 /* Store the score of the set */
  47 {
  48     const struct set *s = current_set;
  49     FILE *fout;
  50     int i;
  51     const struct level *l;
  52     char states[MAXLVL + 1];
  53
  54     if ((fout = fopen(config_user(s->user_scores), "w")))
  55     {
  56         for (i = 0; i < s->count; i++)
  57         {
  58             if (level_v[i].is_locked)
  59                 states[i] = 'L';
  60             else if (level_v[i].is_completed)
  61                 states[i] = 'C';
  62             else
  63                 states[i] = 'O';
  64         }
  65         states[s->count] = '\0';
  66         fprintf(fout, "%s\n",states);
  67
  68         put_score(fout, &s->time_score);
  69         put_score(fout, &s->coin_score);
  70
  71         for (i = 0; i < s->count; i++)
  72         {
  73             l = &level_v[i];
  74             put_score(fout, &l->score.best_times);
  75             put_score(fout, &l->score.unlock_goal);
  76             put_score(fout, &l->score.most_coins);
  77         }
  78
  79         fclose(fout);
  80     }
  81 }
  82
  83 static int get_score(FILE *fp, struct score *s)
  84 {
  85     int j;
  86     int res = 1;
  87     for (j = 0; j < NSCORE && res; j++)
  88     {
  89        res = (fscanf(fp, "%d %d %s\n",
  90                      &s->timer[j], &s->coins[j], s->player[j])) == 3;
  91     }
  92     return res;
  93 }
  94
  95 static void set_load_hs(void)
  96 /* Get the score of the set */
  97 {
  98     struct set *s = current_set;
  99     FILE *fin;
 100     int i;
 101     int res = 0;
 102     struct level *l;
 103     const char *fn = config_user(s->user_scores);
 104     char states[MAXLVL + 1];
 105
 106     if ((fin = fopen(fn, "r")))
 107     {
 108         res = ((fscanf(fin, "%s\n", states) == 1) &&
 109                (strlen(states) == s->count));
 110         for (i = 0; i < s->count && res; i++)
 111         {
 112             switch (states[i])
 113             {
 114             case 'L':
 115                 level_v[i].is_locked = 1;
 116                 level_v[i].is_completed = 0;
 117                 break;
 118
 119             case 'C':
 120                 level_v[i].is_locked = 0;
 121                 level_v[i].is_completed = 1;
 122                 break;
 123
 124             case 'O':
 125                 level_v[i].is_locked = 0;
 126                 level_v[i].is_completed = 0;
 127                 break;
 128
 129             default:
 130                 res = 0;
 131             }
 132         }
 133
 134         res = res &&
 135             get_score(fin, &s->time_score) &&
 136             get_score(fin, &s->coin_score);
 137
 138         for (i = 0; i < s->count && res; i++)
 139         {
 140             l = &level_v[i];
 141             res = get_score(fin, &l->score.best_times) &&
 142                   get_score(fin, &l->score.unlock_goal) &&
 143                   get_score(fin, &l->score.most_coins);
 144         }
 145
 146         fclose(fin);
 147     }
 148
 149     if (!res && errno != ENOENT)
 150     {
 151         fprintf(stderr,
 152                 _("Error while loading user high-score file '%s': %s\n"),
 153                 fn, errno ? strerror(errno) : _("Incorrect format"));
 154     }
 155 }
 156
 157 static char *strip_eol(char *str)
 158 {
 159     char *c = str + strlen(str) - 1;
 160
 161     while (c >= str && (*c == '\n' || *c =='\r'))
 162         *c-- = '\0';
 163
 164     return str;
 165 }
 166
 167 static int set_load(struct set *s, const char *filename)
 168 {
 169     FILE *fin;
 170     char buf[MAXSTR];
 171     int res;
 172
 173     fin = fopen(config_data(filename), "r");
 174
 175     if (!fin)
 176     {
 177         fprintf(stderr, _("Cannot load the set file '%s': %s\n"),
 178                 filename, strerror(errno));
 179         return 0;
 180     }
 181
 182     memset(s, 0, sizeof (struct set));
 183
 184     /* Set some sane values in case the scores hs is missing. */
 185
 186     score_init_hs(&s->time_score, 359999, 0);
 187     score_init_hs(&s->coin_score, 359999, 0);
 188
 189     /* Load set metadata. */
 190
 191     strcpy(s->file, filename);
 192
 193     if ((res = fgets(buf, MAXSTR, fin) != NULL))
 194         strcpy(s->name, strip_eol(buf));
 195     if (res && (res = fgets(buf, MAXSTR, fin) != NULL))
 196         strcpy(s->desc, strip_eol(buf));
 197     if (res && (res = fgets(buf, MAXSTR, fin) != NULL))
 198         strcpy(s->setname, strip_eol(buf));
 199     if (res && (res = fgets(buf, MAXSTR, fin) != NULL))
 200         strcpy(s->shot, strip_eol(buf));
 201     if (res && (res = fgets(buf, MAXSTR, fin) != NULL))
 202         sscanf(buf, "%d %d %d %d %d %d",
 203                 &s->time_score.timer[0],
 204                 &s->time_score.timer[1],
 205                 &s->time_score.timer[2],
 206                 &s->coin_score.coins[0],
 207                 &s->coin_score.coins[1],
 208                 &s->coin_score.coins[2]);
 209
 210     strcpy(s->user_scores, "neverballhs-");
 211     strcat(s->user_scores, s->setname);
 212
 213     /* Count levels. */
 214
 215     s->count = 0;
 216
 217     while (s->count < MAXLVL && (fscanf(fin, "%s", buf) == 1))
 218         s->count++;
 219
 220     fclose(fin);
 221
 222     /* Load the levels states (stored in the user high score file) */
 223
 224     s->locked = s->count;
 225     s->completed = 0;
 226
 227     if ((fin = fopen(config_user(s->user_scores), "r")))
 228     {
 229         char states[MAXLVL + 1];
 230         int i;
 231         if ((fscanf(fin, "%s\n", states) == 1) && (strlen(states) == s->count))
 232         {
 233             for (i = 0; i < s->count; i++)
 234             {
 235                 if (states[i] == 'O')
 236                     s->locked -= 1;
 237                 else if (states[i] == 'C')
 238                 {
 239                     s->completed += 1;
 240                     s->locked -= 1;
 241                 }
 242             }
 243         }
 244         fclose(fin);
 245     }
 246     if (s->locked == s->count)
 247         s->locked = s->count-1;
 248
 249     return 1;
 250 }
 251
 252 /*---------------------------------------------------------------------------*/
 253
 254 int set_init()
 255 {
 256     FILE *fin;
 257     char  name[MAXSTR];
 258
 259     current_set = NULL;
 260     count       = 0;
 261
 262     if ((fin = fopen(config_data(SET_FILE), "r")))
 263     {
 264         while (count < MAXSET && fgets(name, MAXSTR, fin))
 265             if (set_load(&set_v[count], strip_eol(name)))
 266                 count++;
 267
 268         fclose(fin);
 269     }
 270
 271     return count;
 272 }
 273
 274 /*---------------------------------------------------------------------------*/
 275
 276 int  set_exists(int i)
 277 {
 278     return (0 <= i && i < count);
 279 }
 280
 281 const struct set *get_set(int i)
 282 {
 283     return set_exists(i) ? &set_v[i] : NULL;
 284 }
 285
 286 /*---------------------------------------------------------------------------*/
 287
 288 int  set_unlocked(const struct set *s)
 289 /* Are all levels (even extra bonus) unlocked? */
 290 {
 291     return s->locked == 0;
 292 }
 293
 294 int  set_completed(const struct set *s)
 295 /* Are all levels (even extra bonus) completed? */
 296 {
 297     return s->completed == s->count;
 298 }
 299
 300 int  set_level_exists(const struct set *s, int i)
 301 /* Does the level i of the set exist? */
 302 {
 303     return (i >= 0) && (i < s->count);
 304 }
 305
 306 /*---------------------------------------------------------------------------*/
 307
 308 static void set_load_levels(void)
 309 {
 310     FILE *fin;
 311     struct level *l;
 312
 313     char buf[MAXSTR];
 314     char name[MAXSTR];
 315
 316     int i = 0, res;
 317     int nb = 1, bnb = 1;
 318
 319     if ((fin = fopen(config_data(current_set->file), "r")))
 320     {
 321         res = 1;
 322
 323         /* Skip the five first lines */
 324         for (i = 0; i < 5; i++)
 325             fgets(buf, MAXSTR, fin);
 326
 327         for (i = 0; i < current_set->count && res; i++)
 328         {
 329             l = &level_v[i];
 330
 331             res = (fscanf(fin, "%s", name) == 1);
 332             assert(res);
 333
 334             level_load(name, l);
 335
 336             /* Initialize set related info */
 337             l->set        = current_set;
 338             l->number     = i;
 339             if (l->is_bonus)
 340                 sprintf(l->repr, _("B%d"), bnb++);
 341             else
 342                 sprintf(l->repr, "%02d", nb++);
 343             l->is_locked    = 1;
 344             l->is_completed = 0;
 345         }
 346         level_v[0].is_locked = 0; /* unlock the first level */
 347         fclose(fin);
 348     }
 349
 350     assert(i == current_set->count);
 351 }
 352
 353 void set_goto(int i)
 354 {
 355     current_set = &set_v[i];
 356     set_load_levels();
 357     set_load_hs();
 358 }
 359
 360 const struct set *curr_set(void)
 361 {
 362     return current_set;
 363 }
 364
 365 const struct level *get_level(int i)
 366 {
 367     return (i >= 0 && i < current_set->count) ? &level_v[i] : NULL;
 368 }
 369
 370 /*---------------------------------------------------------------------------*/
 371
 372 static int score_time_comp(const struct score *S, int i, int j)
 373 {
 374     if (S->timer[i] < S->timer[j])
 375         return 1;
 376
 377     if (S->timer[i] == S->timer[j] && S->coins[i] > S->coins[j])
 378         return 1;
 379
 380     return 0;
 381 }
 382
 383 static int score_coin_comp(const struct score *S, int i, int j)
 384 {
 385     if (S->coins[i] > S->coins[j])
 386         return 1;
 387
 388     if (S->coins[i] == S->coins[j] && S->timer[i] < S->timer[j])
 389         return 1;
 390
 391     return 0;
 392 }
 393
 394 static void score_swap(struct score *S, int i, int j)
 395 {
 396     char player[MAXNAM];
 397     int  tmp;
 398
 399     strncpy(player,       S->player[i], MAXNAM);
 400     strncpy(S->player[i], S->player[j], MAXNAM);
 401     strncpy(S->player[j], player,       MAXNAM);
 402
 403     tmp         = S->timer[i];
 404     S->timer[i] = S->timer[j];
 405     S->timer[j] = tmp;
 406
 407     tmp         = S->coins[i];
 408     S->coins[i] = S->coins[j];
 409     S->coins[j] = tmp;
 410 }
 411
 412 static int score_time_insert(struct score *s, const char *player, int timer,
 413                              int coins)
 414 {
 415     int i;
 416
 417     strncpy(s->player[3], player, MAXNAM);
 418     s->timer[3] = timer;
 419     s->coins[3] = coins;
 420
 421     for (i = 2; i >= 0 && score_time_comp(s, i + 1, i); i--)
 422         score_swap(s, i + 1, i);
 423
 424     return i + 1;
 425 }
 426
 427 static int score_coin_insert(struct score *s, const char *player, int timer,
 428                              int coins)
 429 {
 430     int i;
 431
 432     strncpy(s->player[3], player, MAXNAM);
 433     s->timer[3] = timer;
 434     s->coins[3] = coins;
 435
 436     for (i = 2; i >= 0 && score_coin_comp(s, i + 1, i); i--)
 437         score_swap(s, i + 1, i);
 438
 439     return i + 1;
 440 }
 441
 442 static int level_score_update(struct level_game *lg, const char *player)
 443 /* Update the level score rank according to coins and timer */
 444 {
 445     int timer = lg->timer;
 446     int coins = lg->coins;
 447     struct level *l = &level_v[lg->level->number];
 448
 449     lg->time_rank = score_time_insert(&l->score.best_times,
 450                                       player, timer, coins);
 451
 452     if (lg->mode == MODE_CHALLENGE || lg->mode == MODE_NORMAL)
 453         lg->goal_rank = score_time_insert(&l->score.unlock_goal,
 454                                           player, timer, coins);
 455     else
 456         lg->goal_rank = 3;
 457
 458     lg->coin_rank = score_coin_insert(&l->score.most_coins,
 459                                       player, timer, coins);
 460
 461     return (lg->time_rank < 3 || lg->goal_rank < 3 || lg->coin_rank < 3);
 462 }
 463
 464 static int set_score_update(struct level_game *lg, const char *player)
 465 /* Update the set score rank according to score and times */
 466 {
 467     int timer = lg->times;
 468     int coins = lg->score;
 469     struct set *s = current_set;
 470
 471     lg->score_rank = score_time_insert(&s->time_score, player, timer, coins);
 472     lg->times_rank = score_time_insert(&s->coin_score, player, timer, coins);
 473     return (lg->score_rank < 3 || lg->times_rank < 3);
 474 }
 475
 476
 477 void score_change_name(struct level_game *lg, const char *player)
 478 /* Update the player name for set and level high-score */
 479 {
 480 #define UPDATE(i, x) (strncpy((x).player[(i)], player, MAXNAM))
 481     struct set *s = current_set;
 482     struct level *l = &level_v[lg->level->number];
 483     UPDATE(lg->time_rank, l->score.best_times);
 484     UPDATE(lg->goal_rank, l->score.unlock_goal);
 485     UPDATE(lg->coin_rank, l->score.most_coins);
 486     UPDATE(lg->score_rank, s->coin_score);
 487     UPDATE(lg->times_rank, s->time_score);
 488     set_store_hs();
 489 }
 490
 491 static struct level *next_level(int i)
 492 {
 493 /* Return the ith level, or NULL */
 494     return set_level_exists(current_set, i + 1) ? &level_v[i + 1] : NULL;
 495 }
 496
 497 static struct level *next_normal_level(int i)
 498 /* Return the next normal level (starting for i)
 499  * Return NULL if there is not a such level */
 500 {
 501     for (i++; i < current_set->count; i++)
 502         if (!level_v[i].is_bonus)
 503             return &level_v[i];
 504     return NULL;
 505 }
 506
 507 void set_finish_level(struct level_game *lg, const char *player)
 508 /* Inform the set that a level is finished.
 509  * Update next_level and score rank fields */
 510 {
 511     struct set *s = current_set;
 512     int ln = lg->level->number; /* current level number */
 513     struct level *cl = &level_v[ln];    /* current level */
 514     struct level *nl = NULL;    /* next level */
 515     int dirty = 0;              /* HS should be saved? */
 516
 517     assert(s == cl->set);
 518
 519     /* if no set, no next level */
 520     if (s == NULL)
 521     {
 522         /* if no set, return */
 523         lg->next_level = NULL;
 524         return;
 525     }
 526
 527     /* On level completed */
 528     if (lg->state == GAME_GOAL)
 529     {
 530         /* Update level scores */
 531         dirty = level_score_update(lg, player);
 532
 533         /* Complete the level */
 534         if (lg->mode == MODE_CHALLENGE || lg->mode == MODE_NORMAL)
 535         {
 536             /* Complete the level */
 537             if (!cl->is_completed)
 538             {
 539                 cl->is_completed = 1;
 540                 s->completed += 1;
 541                 dirty = 1;
 542             }
 543         }
 544     }
 545
 546     /* On goal reached */
 547     if (lg->state == GAME_GOAL || lg->state == GAME_SPEC)
 548     {
 549         /* Identify the following level */
 550         nl = next_level(ln + lg->state_value);
 551         if (nl != NULL)
 552         {
 553             /* skip bonuses if unlocked in non challenge mode */
 554             if (nl->is_bonus && nl->is_locked && lg->mode != MODE_CHALLENGE)
 555                 nl = next_normal_level(nl->number);
 556         }
 557         else if (lg->mode == MODE_CHALLENGE)
 558             lg->win = 1;
 559     }
 560     else if (cl->is_bonus || lg->mode != MODE_CHALLENGE)
 561     {
 562         /* On fail, identify the next level (only in bonus for challenge) */
 563         nl = next_normal_level(ln);
 564         /* Next level may be unavailable */
 565         if (!cl->is_bonus && nl != NULL && nl->is_locked)
 566             nl = NULL;
 567         /* Fail a bonus level but win the set! */
 568         else if (nl == NULL && lg->mode == MODE_CHALLENGE)
 569             lg->win = 1;
 570     }
 571
 572     /* Win ! */
 573     if (lg->win)
 574     {
 575         /* update set score */
 576         set_score_update(lg, player);
 577         /* unlock all levels */
 578         set_cheat();
 579         dirty = 1;
 580     }
 581
 582     /* unlock the next level if needed */
 583     if (nl != NULL && nl->is_locked)
 584     {
 585         if (lg->mode == MODE_CHALLENGE || lg->mode == MODE_NORMAL)
 586         {
 587             lg->unlock = 1;
 588             nl->is_locked = 0;
 589             s->locked -= 1;
 590             dirty = 1;
 591         }
 592         else
 593             nl = NULL;
 594     }
 595
 596     /* got the next level */
 597     lg->next_level = nl;
 598
 599     /* Update file */
 600     if (dirty)
 601         set_store_hs();
 602 }
 603
 604 /*---------------------------------------------------------------------------*/
 605
 606 void level_snap(int i)
 607 {
 608     char filename[MAXSTR];
 609     char *ext;
 610
 611     /* Convert the level name to a PNG filename. */
 612
 613     memset(filename, 0, MAXSTR);
 614
 615     ext = strrchr(level_v[i].file, '.');
 616     strncpy(filename, level_v[i].file,
 617             ext ? ext - level_v[i].file : strlen(level_v[i].file));
 618     strcat(filename, ".png");
 619
 620     /* Initialize the game for a snapshot. */
 621
 622     if (game_init(&level_v[i], 0, 0))
 623     {
 624         int shadow;
 625
 626         if ((shadow = config_get_d(CONFIG_SHADOW)))
 627             config_set_d(CONFIG_SHADOW, 0);
 628
 629         /* Render the level and grab the screen. */
 630
 631         config_clear();
 632         game_set_fly(1.f);
 633         game_kill_fade();
 634         game_draw(1, 0);
 635         SDL_GL_SwapBuffers();
 636
 637         image_snap(filename);
 638
 639         if (shadow)
 640             config_set_d(CONFIG_SHADOW, 1);
 641     }
 642 }
 643
 644 void set_cheat(void)
 645 /* Open each level of the current set */
 646 {
 647     int i;
 648     current_set->locked = 0;
 649     for (i = 0; i < current_set->count; i++)
 650         level_v[i].is_locked = 0;
 651 }
 652
 653
 654 /*---------------------------------------------------------------------------*/