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