2 * Copyright (C) 2003 Robert Kooima
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.
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.
26 /*---------------------------------------------------------------------------*/
28 static int count; /* number of sets */
30 static struct set set_v[MAXSET]; /* array of sets */
32 static struct set *current_set; /* currently selected set */
34 static struct level level_v[MAXLVL]; /* levels of the current set */
36 /*---------------------------------------------------------------------------*/
38 static void put_score(FILE *fp, const struct score *s)
41 for (j = 0; j < NSCORE; j++)
42 fprintf(fp, "%d %d %s\n", s->timer[j], s->coins[j], s->player[j]);
45 static void set_store_hs(void)
46 /* Store the score of the set */
48 const struct set *s = current_set;
51 const struct level *l;
52 char states[MAXLVL + 1];
54 if ((fout = fopen(config_user(s->user_scores), "w")))
56 for (i = 0; i < s->count; i++)
58 if (level_v[i].is_locked)
60 else if (level_v[i].is_completed)
65 states[s->count] = '\0';
66 fprintf(fout, "%s\n",states);
68 put_score(fout, &s->time_score);
69 put_score(fout, &s->coin_score);
71 for (i = 0; i < s->count; i++)
74 put_score(fout, &l->time_score);
75 put_score(fout, &l->goal_score);
76 put_score(fout, &l->coin_score);
83 static int get_score(FILE *fp, struct score *s)
87 for (j = 0; j < NSCORE && res; j++)
89 res = (fscanf(fp, "%d %d %s\n",
90 &s->timer[j], &s->coins[j], s->player[j])) == 3;
95 static void set_load_hs(void)
96 /* Get the score of the set */
98 struct set *s = current_set;
103 const char *fn = config_user(s->user_scores);
104 char states[MAXLVL + 1];
106 if ((fin = fopen(fn, "r")))
108 res = ((fscanf(fin, "%s\n", states) == 1) &&
109 (strlen(states) == s->count));
110 for (i = 0; i < s->count && res; i++)
112 if (states[i] == 'L')
114 level_v[i].is_locked = 1;
115 level_v[i].is_completed = 0;
117 else if (states[i] == 'C')
119 level_v[i].is_locked = 0;
120 level_v[i].is_completed = 1;
122 else if (states[i] == 'O')
124 level_v[i].is_locked = 0;
125 level_v[i].is_completed = 0;
132 get_score(fin, &s->time_score) &&
133 get_score(fin, &s->coin_score);
135 for (i = 0; i < s->count && res; i++)
138 res = get_score(fin, &l->time_score) &&
139 get_score(fin, &l->goal_score) &&
140 get_score(fin, &l->coin_score);
146 if (!res && errno != ENOENT)
148 fprintf(stderr, _("Error while loading user high-score file '%s': "),
153 fprintf(stderr, _("Incorrect format\n"));
157 static char *chomp(char *str)
158 /* Remove trailing \n if any */
160 char *p = str + strlen(str) - 1;
161 if (p >= str && *p == '\n') *p = 0;
165 static int set_load(struct set *s, const char *filename)
172 fin = fopen(config_data(filename), "r");
175 fprintf(stderr, _("Cannot load the set file '%s':"), filename);
180 memset(s, 0, sizeof (struct set));
182 /* Set some sane values in case the scores hs is missing. */
184 score_init_hs(&s->time_score, 359999, 0);
185 score_init_hs(&s->coin_score, 359999, 0);
187 /* Load set metadata. */
189 strcpy(s->file, config_data(filename));
191 if ((res = fgets(buf, MAXSTR, fin) != NULL))
192 strcpy(s->name, chomp(buf));
193 if (res && (res = fgets(buf, MAXSTR, fin) != NULL))
194 strcpy(s->desc, chomp(buf));
195 if (res && (res = fgets(buf, MAXSTR, fin) != NULL))
196 strcpy(s->setname, chomp(buf));
197 if (res && (res = fgets(buf, MAXSTR, fin) != NULL))
198 strcpy(s->shot, chomp(buf));
199 if (res && (res = fgets(buf, MAXSTR, fin) != NULL))
200 sscanf(buf, "%d %d %d %d %d %d",
201 &s->time_score.timer[0],
202 &s->time_score.timer[1],
203 &s->time_score.timer[2],
204 &s->coin_score.coins[0],
205 &s->coin_score.coins[1],
206 &s->coin_score.coins[2]);
208 strcpy(s->user_scores, "neverballhs-");
209 strcat(s->user_scores, s->setname);
215 while (s->count < MAXLVL && (fscanf(fin, "%s", buf) == 1))
220 /* Load the levels states (stored in the user highscore file) */
222 s->locked = s->count;
225 if ((fin = fopen(config_user(s->user_scores), "r")))
227 char states[MAXLVL + 1];
229 if ((fscanf(fin, "%s\n", states) == 1) && (strlen(states) == s->count))
231 for (i = 0; i < s->count; i++)
233 if (states[i] == 'O')
235 else if (states[i] == 'C')
244 if (s->locked == s->count)
245 s->locked = s->count-1;
250 /*---------------------------------------------------------------------------*/
257 char filename[MAXSTR];
264 if ((fin = fopen(config_data(SET_FILE), "r")))
267 while (count < MAXSET && res)
269 set = &(set_v[count]);
270 res = (fgets(filename, MAXSTR, fin) != NULL);
276 res = set_load(set, filename);
289 /*---------------------------------------------------------------------------*/
291 int set_exists(int i)
293 return (0 <= i && i < count);
296 const struct set *get_set(int i)
298 return set_exists(i) ? &set_v[i] : NULL;
301 /*---------------------------------------------------------------------------*/
303 int set_unlocked(const struct set *s)
304 /* Are all levels (even extra bonus) unlocked? */
306 return s->locked == 0;
309 int set_completed(const struct set *s)
310 /* Are all levels (even extra bonus) completed? */
312 return s->completed == s->count;
315 int set_level_exists(const struct set *s, int i)
316 /* Does the level i of the set exist? */
318 return (i >= 0) && (i < s->count);
321 /*---------------------------------------------------------------------------*/
323 static void set_load_levels(void)
334 if ((fin = fopen(current_set->file, "r")))
338 /* Skip the five first lines */
339 for (i = 0; i < 5; i++)
340 fgets(buf, MAXSTR, fin);
342 for (i = 0; i < current_set->count && res; i++)
346 res = (fscanf(fin, "%s", name) == 1);
349 level_load(config_data(name), l);
351 /* Initialize set related info */
352 l->set = current_set;
355 sprintf(l->numbername, _("B%d"), bnb++);
357 sprintf(l->numbername, "%02d", nb++);
361 level_v[0].is_locked = 0; /* unlock the first level */
365 assert(i == current_set->count);
370 current_set = &set_v[i];
375 const struct set *curr_set(void)
380 const struct level *get_level(int i)
382 return (i >= 0 && i < current_set->count) ? &level_v[i] : NULL;
385 /*---------------------------------------------------------------------------*/
387 static int score_time_comp(const struct score *S, int i, int j)
389 if (S->timer[i] < S->timer[j])
392 if (S->timer[i] == S->timer[j] && S->coins[i] > S->coins[j])
398 static int score_coin_comp(const struct score *S, int i, int j)
400 if (S->coins[i] > S->coins[j])
403 if (S->coins[i] == S->coins[j] && S->timer[i] < S->timer[j])
409 static void score_swap(struct score *S, int i, int j)
414 strncpy(player, S->player[i], MAXNAM);
415 strncpy(S->player[i], S->player[j], MAXNAM);
416 strncpy(S->player[j], player, MAXNAM);
419 S->timer[i] = S->timer[j];
423 S->coins[i] = S->coins[j];
427 static int score_time_insert(struct score *s, const char *player, int timer,
432 strncpy(s->player[3], player, MAXNAM);
436 for (i = 2; i >= 0 && score_time_comp(s, i + 1, i); i--)
437 score_swap(s, i + 1, i);
442 static int score_coin_insert(struct score *s, const char *player, int timer,
447 strncpy(s->player[3], player, MAXNAM);
451 for (i = 2; i >= 0 && score_coin_comp(s, i + 1, i); i--)
452 score_swap(s, i + 1, i);
457 static int level_score_update(struct level_game *lg, const char *player)
458 /* Update the level score rank according to coins and timer */
460 int timer = lg->timer;
461 int coins = lg->coins;
462 struct level *l = &level_v[lg->level->number];
464 lg->time_rank = score_time_insert(&l->time_score, player, timer, coins);
466 if (lg->mode == MODE_CHALLENGE || lg->mode == MODE_NORMAL)
467 lg->goal_rank = score_time_insert(&l->goal_score, player, timer, coins);
471 lg->coin_rank = score_coin_insert(&l->coin_score, player, timer, coins);
473 return (lg->time_rank < 3 || lg->goal_rank < 3 || lg->coin_rank < 3);
476 static int set_score_update(struct level_game *lg, const char *player)
477 /* Update the set score rank according to score and times */
479 int timer = lg->times;
480 int coins = lg->score;
481 struct set *s = current_set;
483 lg->score_rank = score_time_insert(&s->time_score, player, timer, coins);
484 lg->times_rank = score_time_insert(&s->coin_score, player, timer, coins);
485 return (lg->score_rank < 3 || lg->times_rank < 3);
489 void score_change_name(struct level_game *lg, const char *player)
490 /* Update the player name for set and level high-score */
492 #define UPDATE(i, x) (strncpy((x).player[(i)], player, MAXNAM))
493 struct set *s = current_set;
494 struct level *l = &level_v[lg->level->number];
495 UPDATE(lg->time_rank, l->time_score);
496 UPDATE(lg->goal_rank, l->goal_score);
497 UPDATE(lg->coin_rank, l->coin_score);
498 UPDATE(lg->score_rank, s->coin_score);
499 UPDATE(lg->times_rank, s->time_score);
503 static struct level *next_level(int i)
505 /* Return the ith level, or NULL */
506 return set_level_exists(current_set, i + 1) ? &level_v[i + 1] : NULL;
509 static struct level *next_normal_level(int i)
510 /* Return the next normal level (starting for i)
511 * Return NULL if there is not a such level */
513 for (i++; i < current_set->count; i++)
514 if (!level_v[i].is_bonus)
519 void set_finish_level(struct level_game *lg, const char *player)
520 /* Inform the set that a level is finished.
521 * Update next_level and score rank fields */
523 struct set *s = current_set;
524 int ln = lg->level->number; /* curent level number */
525 struct level *cl = &level_v[ln]; /* current level */
526 struct level *nl = NULL; /* next level */
527 int dirty = 0; /* HS should be saved? */
529 assert(s == cl->set);
531 /* if no set, no next level */
534 /* if no set, return */
535 lg->next_level = NULL;
539 /* On level completed */
540 if (lg->state == GAME_GOAL)
542 /* Update level scores */
543 dirty = level_score_update(lg, player);
545 /* Complete the level */
546 if (lg->mode == MODE_CHALLENGE || lg->mode == MODE_NORMAL)
548 /* Complete the level */
549 if (!cl->is_completed)
551 cl->is_completed = 1;
558 /* On goal reached */
559 if (lg->state == GAME_GOAL || lg->state == GAME_SPEC)
561 /* Identify the following level */
562 nl = next_level(ln + lg->state_value);
565 /* skip bonuses if unlocked in non challenge mode */
566 if (nl->is_bonus && nl->is_locked && lg->mode != MODE_CHALLENGE)
567 nl = next_normal_level(nl->number);
569 else if (lg->mode == MODE_CHALLENGE)
572 else if (cl->is_bonus || lg->mode != MODE_CHALLENGE)
574 /* On fail, identify the next level (only in bonus for challenge) */
575 nl = next_normal_level(ln);
576 /* Next level may be unavailable */
577 if (!cl->is_bonus && nl != NULL && nl->is_locked)
579 /* Fail a bonus level but win the set! */
580 else if (nl == NULL && lg->mode == MODE_CHALLENGE)
587 /* update set score */
588 set_score_update(lg, player);
589 /* unlock all levels */
594 /* unlock the next level if needed */
595 if (nl != NULL && nl->is_locked)
597 if (lg->mode == MODE_CHALLENGE || lg->mode == MODE_NORMAL)
608 /* got the next level */
616 /*---------------------------------------------------------------------------*/
618 void level_snap(int i)
620 char filename[MAXSTR];
623 /* Convert the level name to a PNG filename. */
625 memset(filename, 0, MAXSTR);
627 ext = strrchr(level_v[i].file, '.');
628 strncpy(filename, level_v[i].file,
629 ext ? ext - level_v[i].file : strlen(level_v[i].file));
630 strcat(filename, ".png");
632 /* Initialize the game for a snapshot. */
634 if (game_init(&level_v[i], 0, 0))
638 if ((shadow = config_get_d(CONFIG_SHADOW)))
639 config_set_d(CONFIG_SHADOW, 0);
641 /* Render the level and grab the screen. */
647 SDL_GL_SwapBuffers();
649 image_snap(filename, config_get_d(CONFIG_WIDTH),
650 config_get_d(CONFIG_HEIGHT));
653 config_set_d(CONFIG_SHADOW, 1);
658 /* Open each level of the current set */
661 current_set->locked = 0;
662 for (i = 0; i < current_set->count; i++)
663 level_v[i].is_locked = 0;
667 /*---------------------------------------------------------------------------*/