-/*
+/*
* Copyright (C) 2003 Robert Kooima
*
* NEVERBALL is free software; you can redistribute it and/or modify
#include "glext.h"
#include "config.h"
#include "image.h"
+#include "text.h"
#include "set.h"
#include "game.h"
+#include "common.h"
/*---------------------------------------------------------------------------*/
-static int count; /* number of sets */
+struct set
+{
+ char file[PATHMAX];
+
+ char *id; /* Internal set identifier */
+ char *name; /* Set name */
+ char *desc; /* Set description */
+ char *shot; /* Set screen-shot */
+
+ char user_scores[PATHMAX]; /* User high-score file */
+
+ struct score coin_score; /* Challenge score */
+ struct score time_score; /* Challenge score */
-static struct set set_v[MAXSET]; /* array of sets */
+ /* Level info */
-static struct set *current_set; /* currently selected set */
+ int count; /* Number of levels */
+ char *level_name_v[MAXLVL]; /* List of level file names */
+};
-static struct level level_v[MAXLVL]; /* levels of the current set */
+static int set_state = 0;
+
+static int set;
+static int count;
+
+static struct set set_v[MAXSET];
+static struct level level_v[MAXLVL];
/*---------------------------------------------------------------------------*/
static void put_score(FILE *fp, const struct score *s)
{
int j;
+
for (j = 0; j < NSCORE; j++)
- fprintf(fp, "%d %d %s\n", s->timer[j], s->coins[j], s->player[j]);
+ fprintf(fp, "%d %d %s\n", s->timer[j], s->coins[j], s->player[j]);
}
-static void set_store_hs(const struct set *s)
-/* Store the score of the set */
+void set_store_hs(void)
{
+ const struct set *s = &set_v[set];
FILE *fout;
int i;
- const struct set_level * sl;
+ const struct level *l;
+ char states[MAXLVL + 1];
if ((fout = fopen(config_user(s->user_scores), "w")))
{
- fprintf(fout, "%d\n", s->limit);
-
- put_score(fout, &s->time_score);
- put_score(fout, &s->coin_score);
-
- for (i = 0; i <= s->limit; i++)
- {
- sl = &s->levels[i];
- put_score(fout, &sl->time_score);
- put_score(fout, &sl->goal_score);
- put_score(fout, &sl->coin_score);
- }
-
- fclose(fout);
+ for (i = 0; i < s->count; i++)
+ {
+ if (level_v[i].is_locked)
+ states[i] = 'L';
+ else if (level_v[i].is_completed)
+ states[i] = 'C';
+ else
+ states[i] = 'O';
+ }
+ states[s->count] = '\0';
+ fprintf(fout, "%s\n",states);
+
+ put_score(fout, &s->time_score);
+ put_score(fout, &s->coin_score);
+
+ for (i = 0; i < s->count; i++)
+ {
+ l = &level_v[i];
+
+ put_score(fout, &l->score.best_times);
+ put_score(fout, &l->score.unlock_goal);
+ put_score(fout, &l->score.most_coins);
+ }
+
+ fclose(fout);
}
}
{
int j;
int res = 1;
+
for (j = 0; j < NSCORE && res; j++)
{
- res = (fscanf(fp, "%d %d %s\n",
- &s->timer[j], &s->coins[j], s->player[j])) == 3;
+ res = fscanf(fp, "%d %d %s\n",
+ &s->timer[j],
+ &s->coins[j],
+ s->player[j]) == 3;
}
return res;
}
-static void set_load_hs(struct set *s)
-/* Get the score of the set and set the limit */
+/* Get the score of the set. */
+static void set_load_hs(void)
{
+ struct set *s = &set_v[set];
FILE *fin;
int i;
int res = 0;
- struct set_level * sl;
+ struct level *l;
const char *fn = config_user(s->user_scores);
-
- s->limit = 0;
+ char states[MAXLVL + 1];
if ((fin = fopen(fn, "r")))
{
- res = (fscanf(fin, "%d\n", &s->limit) == 1) &&
- s->limit <= s->count &&
- get_score(fin, &s->time_score) &&
- get_score(fin, &s->coin_score);
-
- for (i = 0; i <= s->limit && res; i++)
- {
- sl = &s->levels[i];
- res = get_score(fin, &sl->time_score) &&
- get_score(fin, &sl->goal_score) &&
- get_score(fin, &sl->coin_score);
- }
-
- fclose(fin);
+ res = fscanf(fin, "%s\n", states) == 1 && strlen(states) == s->count;
+
+ for (i = 0; i < s->count && res; i++)
+ {
+ switch (states[i])
+ {
+ case 'L':
+ level_v[i].is_locked = 1;
+ level_v[i].is_completed = 0;
+ break;
+
+ case 'C':
+ level_v[i].is_locked = 0;
+ level_v[i].is_completed = 1;
+ break;
+
+ case 'O':
+ level_v[i].is_locked = 0;
+ level_v[i].is_completed = 0;
+ break;
+
+ default:
+ res = 0;
+ }
+ }
+
+ res = res &&
+ get_score(fin, &s->time_score) &&
+ get_score(fin, &s->coin_score);
+
+ for (i = 0; i < s->count && res; i++)
+ {
+ l = &level_v[i];
+ res = get_score(fin, &l->score.best_times) &&
+ get_score(fin, &l->score.unlock_goal) &&
+ get_score(fin, &l->score.most_coins);
+ }
+
+ fclose(fin);
}
-
+
if (!res && errno != ENOENT)
{
- fprintf(stderr, _("Error while loading high-score file '%s'"), fn);
- if (errno)
- perror(NULL);
- else
- fprintf(stderr, "\n");
- s->limit = 0;
+ fprintf(stderr,
+ L_("Error while loading user high-score file '%s': %s\n"),
+ fn, errno ? strerror(errno) : L_("Incorrect format"));
}
}
-static const char * numbernames[] = {
- "01", "02", "03", "04", "05",
- "06", "07", "08", "09", "10",
- "11", "12", "13", "14", "15",
- "16", "17", "18", "19", "20",
- N_("B1"), N_("B2"), N_("B3"), N_("B4"), N_("B5")};
-
+/*---------------------------------------------------------------------------*/
-static void set_init_levels(struct set *s)
-/* Count levels */
+static int set_load(struct set *s, const char *filename)
{
FILE *fin;
- char buf[MAXSTR];
- struct set_level * sl;
+ char *scores, *level_name;
- s->count = 0;
+ fin = fopen(config_data(filename), "r");
- /* Load the levels list. */
-
- if ((fin = fopen(config_data(s->init_levels), "r")))
+ if (!fin)
{
- while (count < MAXLVL && fgets(buf, MAXSTR, fin))
- {
- sl = &s->levels[s->count];
- sl->numbername = numbernames[s->count];
- s->count++;
- }
- fclose(fin);
+ fprintf(stderr, L_("Cannot load the set file '%s': %s\n"),
+ filename, strerror(errno));
+ return 0;
}
-}
-static void score_init_hs(struct score *s, int timer, int coins)
-{
- int i;
- strcpy(s->player[0], "Hard");
- strcpy(s->player[1], "Medium");
- strcpy(s->player[2], "Easy");
- for (i = 0; i < NSCORE; i++)
- {
- s->timer[i] = timer;
- s->coins[i] = coins;
- }
-
-}
+ memset(s, 0, sizeof (struct set));
-static void set_init_hs(struct set *s)
-{
- char buf[MAXSTR];
- FILE *fin;
- int i = 0;
- int res;
- struct set_level * sl;
+ /* Set some sane values in case the scores are missing. */
- /* Set some sane values in case the scores file is missing. */
score_init_hs(&s->time_score, 359999, 0);
score_init_hs(&s->coin_score, 359999, 0);
- for (i = 0; i < MAXLVL; i++)
+ strncpy(s->file, filename, PATHMAX - 1);
+
+ if (read_line(&s->name, fin) &&
+ read_line(&s->desc, fin) &&
+ read_line(&s->id, fin) &&
+ read_line(&s->shot, fin) &&
+ read_line(&scores, fin))
{
- sl = &s->levels[i];
- score_init_hs(&sl->time_score, 59999, 0);
- score_init_hs(&sl->goal_score, 59999, 0);
- score_init_hs(&sl->coin_score, 59999, 0);
- }
+ sscanf(scores, "%d %d %d %d %d %d",
+ &s->time_score.timer[0],
+ &s->time_score.timer[1],
+ &s->time_score.timer[2],
+ &s->coin_score.coins[0],
+ &s->coin_score.coins[1],
+ &s->coin_score.coins[2]);
- /* Load the default high scores file. */
+ free(scores);
- if ((fin = fopen(config_data(s->init_scores), "r")))
- {
- res = fgets(buf, MAXSTR, fin) != NULL;
-
- res = res && (sscanf(buf, "%d %d %d %d %d %d",
- &s->time_score.timer[0],
- &s->coin_score.coins[0],
- &s->time_score.timer[1],
- &s->coin_score.coins[1],
- &s->time_score.timer[2],
- &s->coin_score.coins[2]) == 6);
-
- for (i = 0; i < MAXLVL && res && fgets(buf, MAXSTR, fin); i++)
- {
- sl = &s->levels[i];
- /*
- res = sscanf(buf, "%d %d %d %d %d %d %d %d %d",
- &(sl->time_score[0].timer),
- &(sl->goal_score[0].timer),
- &(sl->coin_score[0].coins),
- &(sl->time_score[1].timer),
- &(sl->goal_score[1].timer),
- &(sl->coin_score[1].coins),
- &(sl->time_score[2].timer),
- &(sl->goal_score[2].timer),
- &(sl->coin_score[2].coins)) == 9;*/
- }
-
- fclose(fin);
+ strncpy(s->user_scores, "neverballhs-", PATHMAX - 1);
+ strncat(s->user_scores, s->id, PATHMAX - 1 - strlen("neverballhs-"));
+
+ s->count = 0;
+
+ while (s->count < MAXLVL && read_line(&level_name, fin))
+ {
+ s->level_name_v[s->count] = level_name;
+ s->count++;
+ }
+
+ fclose(fin);
+
+ return 1;
}
-}
-/*---------------------------------------------------------------------------*/
+ free(s->name);
+ free(s->desc);
+ free(s->id);
+ free(s->shot);
-void set_init()
+ fclose(fin);
+
+ return 0;
+}
+
+int set_init()
{
FILE *fin;
- struct set * set;
- int res;
+ char *name;
- current_set = NULL;
-
+ if (set_state)
+ set_free();
+
+ set = 0;
count = 0;
if ((fin = fopen(config_data(SET_FILE), "r")))
{
- res = 1;
- while (count < MAXSET && res)
- {
- set = &(set_v[count]);
-
- /* clean the set data */
- memset(set, 0, sizeof(struct set));
-
- res = fscanf(fin, "%s %s %s %s\n",
- set->init_levels,
- set->init_scores,
- set->user_scores,
- set->shot) == 4 &&
- fgets(set->name, MAXSTR, fin) &&
- fgets(set->desc, MAXSTR, fin);
- if (res)
- {
- char *p = set->name + strlen(set->name) - 1;
- char *q = set->desc + strlen(set->desc) - 1;
- set->number = count;
-
- if (*p == '\n') *p = 0;
- if (*q == '\n') *q = 0;
-
- set_init_levels(set);
- set_init_hs(set);
- set_load_hs(set);
-
- count++;
- }
- }
+ while (count < MAXSET && read_line(&name, fin))
+ {
+ if (set_load(&set_v[count], name))
+ count++;
+ free(name);
+ }
fclose(fin);
- }
-}
-/*---------------------------------------------------------------------------*/
+ set_state = 1;
+ }
-int set_exists(int i)
-{
- return (0 <= i && i < count);
+ return count;
}
-const struct set *get_set(int i)
+void set_free(void)
{
- return set_exists(i) ? &set_v[i] : NULL;
-}
+ int i, j;
-/*---------------------------------------------------------------------------*/
+ for (i = 0; i < count; i++)
+ {
+ free(set_v[i].name);
+ free(set_v[i].desc);
+ free(set_v[i].id);
+ free(set_v[i].shot);
-int set_extra_bonus_opened(const struct set *s)
-/* Are extra bonus openned (ie challenge completed)? */
-{
- return s->limit >= 20;
-}
+ for (j = 0; j < set_v[i].count; j++)
+ free(set_v[i].level_name_v[j]);
+ }
-int set_completed(const struct set *s)
-/* Are all levels (even extra bonus) completed? */
-{
- return s->limit > s->count;
+ set_state = 0;
}
/*---------------------------------------------------------------------------*/
-int set_level_exists(const struct set *s, int i)
-/* Is the level i of the set exists */
+int set_exists(int i)
{
- return (i >= 0) && (i < s->count);
+ return (0 <= i && i < count);
}
-int set_level_opened(const struct set *s, int i)
-/* Is the level i of the set completed? */
+const char *set_id(int i)
{
- return (i >= 0) && (i <= s->limit);
+ return set_exists(i) ? set_v[i].id : NULL;
}
-int set_level_extra_bonus(const struct set *s, int i)
-/* Is the level i of the set a extra-bonus level? */
+const char *set_name(int i)
{
- return (i >= 20) && (i < s->count);
+ return set_exists(i) ? _(set_v[i].name) : NULL;
}
-/*---------------------------------------------------------------------------*/
-
-
-/*---------------------------------------------------------------------------*/
-
-static void set_load_levels(void)
-/* Load more the levels of the current set */
+const char *set_desc(int i)
{
- FILE *fin;
- char buf[MAXSTR];
- char name[MAXSTR];
- struct level * l;
-
- int i=0, res;
-
- if ((fin = fopen(config_data(current_set->init_levels), "r")))
- {
- res = 1;
- for(i=0; i<current_set->count && res; i++)
- {
- l = &level_v[i];
- res = (fgets(buf, MAXSTR, fin) != NULL) &&
- (sscanf(buf, "%s %s %s %s %d %d %s",
- name,
- l->back,
- l->shot,
- l->grad,
- &l->time,
- &l->goal,
- l->song) == 7);
- assert(res);
- level_load(config_data(name), l);
- }
- fclose(fin);
- }
- assert(i == current_set->count);
+ return set_exists(i) ? _(set_v[i].desc) : NULL;
}
-void set_goto(int i)
+const char *set_shot(int i)
{
- assert(set_exists(i));
- current_set = &set_v[i];
- set_load_levels();
+ return set_exists(i) ? set_v[i].shot : NULL;
}
-const struct set *curr_set(void)
+const struct score *set_time_score(int i)
{
- return current_set;
+ return set_exists(i) ? &set_v[i].time_score : NULL;
}
-const struct level *get_level(int i)
+const struct score *set_coin_score(int i)
{
- return (i>=0 && i<current_set->count) ? &level_v[i] : NULL;
+ return set_exists(i) ? &set_v[i].coin_score : NULL;
}
/*---------------------------------------------------------------------------*/
-static int score_time_comp(const struct score *S, int i, int j)
+int set_level_exists(int s, int i)
{
- if (S->timer[i] < S->timer[j])
- return 1;
-
- if (S->timer[i] == S->timer[j] &&
- S->coins[i] > S->coins[j])
- return 1;
-
- return 0;
+ return (i >= 0 && i < set_v[s].count);
}
-static int score_coin_comp(const struct score *S, int i, int j)
+static void set_load_levels(void)
{
- if (S->coins[i] > S->coins[j])
- return 1;
+ struct level *l;
+ int nb = 1, bnb = 1;
- if (S->coins[i] == S->coins[j] &&
- S->timer[i] < S->timer[j])
- return 1;
+ int i;
- return 0;
-}
+ const char *roman[] = {
+ "",
+ "I", "II", "III", "IV", "V",
+ "VI", "VII", "VIII", "IX", "X",
+ "XI", "XII", "XIII", "XIV", "XV",
+ "XVI", "XVII", "XVIII", "XIX", "XX",
+ "XXI", "XXII", "XXIII", "XXIV", "XXV"
+ };
-static void score_swap(struct score *S, int i, int j)
-{
- char player[MAXNAM];
- int tmp;
+ for (i = 0; i < set_v[set].count; i++)
+ {
+ l = &level_v[i];
+
+ level_load(set_v[set].level_name_v[i], l);
- strncpy(player, S->player[i], MAXNAM);
- strncpy(S->player[i], S->player[j], MAXNAM);
- strncpy(S->player[j], player, MAXNAM);
+ l->set = &set_v[set];
+ l->number = i;
- tmp = S->timer[i];
- S->timer[i] = S->timer[j];
- S->timer[j] = tmp;
+ if (l->is_bonus)
+ sprintf(l->name, "%s", roman[bnb++]);
+ else
+ sprintf(l->name, "%02d", nb++);
- tmp = S->coins[i];
- S->coins[i] = S->coins[j];
- S->coins[j] = tmp;
+ l->is_locked = 1;
+ l->is_completed = 0;
+ }
+
+ /* Unlock first level. */
+
+ level_v[0].is_locked = 0;
}
-static int score_time_insert(struct score *s, const char* player, int timer, int coins)
+void set_goto(int i)
{
- int i;
-
- strncpy(s->player[3], player, MAXNAM);
- s->timer[3] = timer;
- s->coins[3] = coins;
-
- for (i = 2; i >= 0 && score_time_comp(s, i + 1, i); i--)
- score_swap(s, i + 1, i);
- return i+1;
+ set = i;
+
+ set_load_levels();
+ set_load_hs();
}
-static int score_coin_insert(struct score *s, const char* player, int timer, int coins)
+int curr_set(void)
{
- int i;
-
- strncpy(s->player[3], player, MAXNAM);
- s->timer[3] = timer;
- s->coins[3] = coins;
-
- for (i = 2; i >= 0 && score_coin_comp(s, i + 1, i); i--)
- score_swap(s, i + 1, i);
- return i+1;
+ return set;
}
-static int level_score_update(struct level_game *lg, const char *player)
-/* Update the level score rank according to coins and timer */
+struct level *get_level(int i)
{
- int timer = lg->timer;
- int coins = lg->coins;
- struct set_level * sl = ¤t_set->levels[lg->level];
-
- lg->time_rank = score_time_insert(&sl->time_score, player, timer, coins);
-
- if (lg->mode == MODE_CHALLENGE || lg->mode == MODE_NORMAL)
- lg->goal_rank = score_time_insert(&sl->goal_score, player, timer, coins);
- else
- lg->goal_rank = 3;
-
- lg->coin_rank = score_coin_insert(&sl->coin_score, player, timer, coins);
-
- return (lg->time_rank < 3 || lg->goal_rank < 3 || lg->coin_rank < 3);
+ return (i >= 0 && i < set_v[set].count) ? &level_v[i] : NULL;
}
-static int set_score_update(struct level_game *lg, const char *player)
-/* Update the set score rank according to score and times */
+/*---------------------------------------------------------------------------*/
+
+int set_score_update(int timer, int coins, int *score_rank, int *times_rank)
{
- int timer = lg->times;
- int coins = lg->score;
- struct set * s = current_set;
+ struct set *s = &set_v[set];
+ char player[MAXSTR] = "";
- lg->score_rank = score_time_insert(&s->time_score, player, timer, coins);
- lg->times_rank = score_time_insert(&s->coin_score, player, timer, coins);
- return (lg->score_rank < 3 || lg->times_rank < 3);
-}
+ config_get_s(CONFIG_PLAYER, player, MAXSTR);
+ if (score_rank)
+ *score_rank = score_coin_insert(&s->coin_score, player, timer, coins);
-void score_change_name(struct level_game *lg, const char *player)
-/* Update the player name for set and level high-score */
-{
-#define UPDATE(i, x) (strncpy((x).player[(i)], player, MAXNAM))
- struct set * s = current_set;
- struct set_level *l = &s->levels[lg->level];
- UPDATE(lg->time_rank, l->time_score);
- UPDATE(lg->goal_rank, l->goal_score);
- UPDATE(lg->coin_rank, l->coin_score);
- UPDATE(lg->score_rank, s->coin_score);
- UPDATE(lg->times_rank, s->time_score);
- set_store_hs(s);
+ if (times_rank)
+ *times_rank = score_time_insert(&s->time_score, player, timer, coins);
+
+ if ((score_rank && *score_rank < 3) || (times_rank && *times_rank < 3))
+ return 1;
+ else
+ return 0;
}
-void set_finish_level(struct level_game *lg, const char *player)
-/* Inform the set that a level is finished.
- * Update next_level and score rank fields */
+void set_rename_player(int score_rank, int times_rank, const char *player)
{
- struct set *s = current_set;
- int level = lg->level;
- int dirty = 0;
-
- /* Update scores */
- dirty = level_score_update(lg, player);
- dirty = set_score_update(lg, player) || dirty;
-
- /* compute the next level */
- if (s == NULL)
- {
- /* if no set, return */
- lg->next_level = -1;
- return;
- }
-
- level++; /* level is the next level */
-
- /* if the next level is not oppened */
- if (s->limit < level)
- if ((lg->mode == MODE_CHALLENGE) ||
- (lg->mode == MODE_NORMAL && (level < 20 || level > 20)))
- {
- s->limit = level;
- dirty = 1;
- }
-
- /* got the next level */
- if (lg->mode == MODE_CHALLENGE && level >= 20)
- lg->next_level = -1; /* End the challenge */
- else if (level < s->count && level <= s->limit)
- lg->next_level = level;
- else
- lg->next_level = -1;
+ struct set *s = &set_v[set];
- /* Update file */
- if (dirty)
- set_store_hs(s);
+ strncpy(s->coin_score.player[score_rank], player, MAXNAM);
+ strncpy(s->time_score.player[times_rank], player, MAXNAM);
}
/*---------------------------------------------------------------------------*/
void level_snap(int i)
{
char filename[MAXSTR];
+ char *ext;
- /* Convert the level name to a BMP filename. */
+ /* Convert the level name to a PNG filename. */
memset(filename, 0, MAXSTR);
- strncpy(filename, level_v[i].file, strcspn(level_v[i].file, "."));
- strcat(filename, ".bmp");
+
+ ext = strrchr(level_v[i].file, '.');
+ strncpy(filename, level_v[i].file,
+ ext ? ext - level_v[i].file : strlen(level_v[i].file));
+ strcat(filename, ".png");
/* Initialize the game for a snapshot. */
- if (game_init(&level_v[i], 0, 0))
+ if (game_init(level_v[i].file, 0, 1))
{
/* Render the level and grab the screen. */
game_set_fly(1.f);
game_kill_fade();
game_draw(1, 0);
- SDL_GL_SwapBuffers();
- image_snap(filename, config_get_d(CONFIG_WIDTH), config_get_d(CONFIG_HEIGHT));
+ image_snap(filename);
+
+ SDL_GL_SwapBuffers();
}
}
void set_cheat(void)
-/* Open each level of the current set */
{
- current_set->limit = current_set->count;
-}
+ int i;
+ for (i = 0; i < set_v[set].count; i++)
+ {
+ level_v[i].is_locked = 0;
+ level_v[i].is_completed = 1;
+ }
+}
/*---------------------------------------------------------------------------*/
-
projects / neverball / blobdiff