-/*
+/*
* Copyright (C) 2003 Robert Kooima
*
* NEVERBALL is free software; you can redistribute it and/or modify
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <time.h>
#ifndef _WIN32
#include <unistd.h>
#endif
-#include "set.h"
#include "demo.h"
#include "game.h"
-#include "level.h"
#include "audio.h"
#include "solid.h"
#include "config.h"
/*---------------------------------------------------------------------------*/
-#define MAGIC 0x4E425250
+#define MAGIC 0x4E425251 /* Replay file magic number (should not change) */
+#define OLD_MAGIC 0x4E425250 /* Replay file magic number for neverball 1.4.0 */
+#define REPLAY_VERSION 1 /* Replay file format version (can change) */
+
+#define DEMO_FPS_CAP 200 /* FPS replay limit, keeps size down on monster systems */
static FILE *demo_fp;
-static char name[MAXDEMO][MAXNAM];
-static char shot[MAXDEMO][PATHMAX];
-static int score[MAXDEMO];
-static int timer[MAXDEMO];
-static int count;
+static struct demo demos[MAXDEMO]; /* Array of scanned demos */
+
+static int count; /* number of scanned demos */
/*---------------------------------------------------------------------------*/
+
+void demo_dump_info(const struct demo *d)
+/* This function dump the info of a demo structure
+ * It's only a function for debugging, no need of I18N */
+{
+ printf("Name: %s\n"
+ "File: %s\n"
+ "NB Version: %s\n"
+ "Time: %d\n"
+ "Coins: %d\n"
+ "Mode: %d\n"
+ "State: %d\n"
+ "Date: %s"
+ "Player: %s\n"
+ "Shot: %s\n"
+ "Level: %s\n"
+ " Back: %s\n"
+ " Grad: %s\n"
+ " Song: %s\n"
+ "Time: %d\n"
+ "Goal: %d\n"
+ "Score: %d\n"
+ "Balls: %d\n"
+ "Total Time: %d\n",
+ d->name, d->filename,
+ d->nb_version,
+ d->timer, d->coins, d->mode, d->state, ctime(&d->date),
+ d->player,
+ d->shot, d->file, d->back, d->grad, d->song,
+ d->time, d->goal, d->score, d->balls, d->times);
+}
+
+FILE *demo_header_read(const char *filename, struct demo *d)
+/* Open a demo file, fill the demo information structure
+ * If success, return the file pointer positioned after the header
+ * If fail, return null
+ */
+{
+ FILE *fp;
+ char *basename;
+ char buf[MAXSTR];
+
+ if ((fp = fopen(filename, FMODE_RB)))
+ {
+ int magic;
+ int version;
+ int t;
+
+ get_index(fp, &magic);
+ get_index(fp, &version);
+
+ /* if time is 0, it means the replay was not finished */
+ get_index(fp, &t);
+
+ if (magic == MAGIC && version == REPLAY_VERSION && t)
+ {
+ d->timer = t;
+ strncpy(d->filename, filename, PATHMAX);
+
+ /* Remove the directory delimiter */
+
+ basename = strrchr(filename, '/');
+#ifdef _WIN32
+ if (!basename)
+ basename = strrchr(filename, '\\');
+ else
+ {
+ char *tmp;
+ if ((tmp = strrchr(basename, '\\')))
+ basename = tmp;
+ }
+#endif
+
+ if (basename != NULL)
+ strncpy(buf, basename + 1, MAXSTR);
+ else
+ strncpy(buf, filename, MAXSTR);
+
+ /* Remove the extension */
+ t = strlen(buf) - strlen(REPLAY_EXT);
+ if ((t > 1) && (strcmp(buf + t, REPLAY_EXT) == 0))
+ buf[t] = '\0';
+ strncpy(d->name, buf, PATHMAX);
+ d->name[PATHMAX - 1] = '\0';
+
+ get_index (fp, &d->coins);
+ get_index (fp, &d->state);
+ get_index (fp, &d->mode);
+ get_index (fp, (int *)&d->date);
+ get_string(fp, d->player, MAXNAM);
+ get_string(fp, d->shot, PATHMAX);
+ get_string(fp, d->file, PATHMAX);
+ get_string(fp, d->back, PATHMAX);
+ get_string(fp, d->grad, PATHMAX);
+ get_string(fp, d->song, PATHMAX);
+ get_index (fp, &d->time);
+ get_index (fp, &d->goal);
+ get_index (fp, &d->score);
+ get_index (fp, &d->balls);
+ get_index (fp, &d->times);
+ get_string(fp, d->nb_version, 20);
+
+ return fp;
+ }
+ fclose(fp);
+ }
+ return NULL;
+}
+
+static FILE *demo_header_write(struct demo *d)
+/* Create a new demo file, write the demo information structure
+ * If success, return the file pointer positioned after the header
+ * If fail, return null
+ * */
+{
+ int magic = MAGIC;
+ int version = REPLAY_VERSION;
+ int zero = 0;
+ FILE *fp;
+
+ if (d->filename && (fp = fopen(d->filename, FMODE_WB)))
+ {
+ put_index (fp, &magic);
+ put_index (fp, &version);
+ put_index (fp, &zero);
+ put_index (fp, &zero);
+ put_index (fp, &zero);
+ put_index (fp, &d->mode);
+ put_index (fp, (int *)&d->date);
+ put_string(fp, d->player);
+ put_string(fp, d->shot);
+ put_string(fp, d->file);
+ put_string(fp, d->back);
+ put_string(fp, d->grad);
+ put_string(fp, d->song);
+ put_index (fp, &d->time);
+ put_index (fp, &d->goal);
+ put_index (fp, &d->score);
+ put_index (fp, &d->balls);
+ put_index (fp, &d->times);
+ put_string(fp, VERSION);
+
+ return fp;
+ }
+ return NULL;
+}
+
+void demo_header_stop(FILE *fp, int coins, int timer, int state)
+/* Update the demo header using the final level state. */
+{
+ long pos = ftell(fp);
+ fseek(fp, 8, SEEK_SET);
+ put_index(fp, &timer);
+ put_index(fp, &coins);
+ put_index(fp, &state);
+ fseek(fp, pos, SEEK_SET);
+}
+
+/*---------------------------------------------------------------------------*/
+
+static void demo_scan_file(const char *filename)
+/* Scan another file (used by demo_scan */
+{
+ FILE *fp;
+ if ((fp = demo_header_read(config_user(filename), &demos[count])))
+ {
+ count++;
+ fclose(fp);
+ }
+}
+
#ifdef _WIN32
int demo_scan(void)
{
WIN32_FIND_DATA d;
HANDLE h;
- FILE *fp;
count = 0;
if ((h = FindFirstFile(config_user("*"), &d)) != INVALID_HANDLE_VALUE)
{
do
- if ((fp = fopen(config_user(d.cFileName), FMODE_RB)))
- {
- int magic;
- int t, c;
-
- /* Note the name and screen shot of each replay file. */
-
- get_index(fp, &magic);
- get_index(fp, &t);
- get_index(fp, &c);
-
- if (magic == MAGIC && t)
- {
- fread(shot[count], 1, PATHMAX, fp);
- timer[count] = t;
- score[count] = c;
- strncpy(name[count], d.cFileName, MAXNAM);
- count++;
- }
- fclose(fp);
- }
+ demo_scan_file(d.cFileName);
while (count < MAXDEMO && FindNextFile(h, &d));
FindClose(h);
int demo_scan(void)
{
struct dirent *ent;
- FILE *fp;
DIR *dp;
count = 0;
if ((dp = opendir(config_user(""))))
{
while (count < MAXDEMO && (ent = readdir(dp)))
- if ((fp = fopen(config_user(ent->d_name), FMODE_RB)))
- {
- int magic;
- int t, c;
-
- /* Note the name and screen shot of each replay file. */
-
- get_index(fp, &magic);
- get_index(fp, &t);
- get_index(fp, &c);
-
- if (magic == MAGIC && t)
- {
- fread(shot[count], 1, PATHMAX, fp);
- timer[count] = t;
- score[count] = c;
- strncpy(name[count], ent->d_name, MAXNAM);
- count++;
- }
- fclose(fp);
- }
+ demo_scan_file(ent->d_name);
closedir(dp);
}
{
int n = demo_scan();
- return (n > 0) ? name[(rand() >> 4) % n] : NULL;
-}
-
-const char *demo_name(int i)
-{
- return (0 <= i && i < count) ? name[i] : NULL;
-}
-
-const char *demo_shot(int i)
-{
- return (0 <= i && i < count) ? shot[i] : NULL;
+ return (n > 0) ? demos[(rand() >> 4) % n].filename : NULL;
}
-int demo_coins(int i)
+const struct demo *get_demo(int i)
{
- return (0 <= i && i < count) ? score[i] : 0;
+ return (0 <= i && i < count) ? &demos[i] : NULL;
}
-int demo_clock(int i)
+const char *date_to_str(time_t i)
{
- return (0 <= i && i < count) ? timer[i] : 0;
+ static char str[MAXSTR];
+ struct tm *tm = localtime(&i);
+ strftime (str, MAXSTR, "%c", tm);
+ return str;
}
/*---------------------------------------------------------------------------*/
int demo_exists(char *name)
{
FILE *fp;
+ char buf[MAXSTR];
- if ((fp = fopen(config_user(name), "r")))
+ strcpy(buf, config_user(name));
+ strcat(buf, REPLAY_EXT);
+ if ((fp = fopen(buf, "r")))
{
fclose(fp);
return 1;
for (i = 1; i < 100; i++)
{
- sprintf(name, "replay%02d", i);
+ sprintf(name, _("replay%02d"), i);
if (!demo_exists(name))
return;
/*---------------------------------------------------------------------------*/
int demo_play_init(const char *name,
- const char *file,
- const char *back,
- const char *grad,
- const char *song,
- const char *shot,
- int t, int g, int s, int c, int b)
+ const struct level *level,
+ const struct level_game *lg)
{
- int magic = MAGIC;
- int zero = 0;
- int st = t;
- int sg = g;
- int ss = s;
- int sc = c;
- int sb = b;
-
- /* Initialize the replay file. Write the header. */
-
- if (name && (demo_fp = fopen(config_user(name), FMODE_WB)))
+ struct demo demo;
+
+ /* file structure */
+ strncpy(demo.name, name, MAXNAM);
+ strncpy(demo.filename, config_user(name), PATHMAX);
+ strcat(demo.filename, REPLAY_EXT);
+ demo.time = demo.coins = demo.state = 0;
+ demo.mode = lg->mode;
+ demo.date = time(NULL);
+ config_get_s(CONFIG_PLAYER, demo.player, MAXNAM);
+ strncpy(demo.shot, level->shot, PATHMAX);
+ strncpy(demo.file, level->file, PATHMAX);
+ strncpy(demo.back, level->back, PATHMAX);
+ strncpy(demo.grad, level->grad, PATHMAX);
+ strncpy(demo.song, level->song, PATHMAX);
+ demo.time = lg->time;
+ demo.goal = lg->goal;
+ demo.score = lg->score;
+ demo.balls = lg->balls;
+ demo.times = lg->times;
+
+ demo_fp = demo_header_write(&demo);
+ if (demo_fp == NULL)
+ return 0;
+ else
{
- put_index(demo_fp, &magic);
- put_index(demo_fp, &zero);
- put_index(demo_fp, &zero);
-
- fwrite(shot, 1, PATHMAX, demo_fp);
- fwrite(file, 1, PATHMAX, demo_fp);
- fwrite(back, 1, PATHMAX, demo_fp);
- fwrite(grad, 1, PATHMAX, demo_fp);
- fwrite(song, 1, PATHMAX, demo_fp);
-
- put_index(demo_fp, &st);
- put_index(demo_fp, &sg);
- put_index(demo_fp, &ss);
- put_index(demo_fp, &sc);
- put_index(demo_fp, &sb);
-
- audio_music_fade_to(2.0f, song);
-
- return game_init(file, back, grad, t, (g == 0));
+ audio_music_fade_to(2.0f, level->song);
+ return game_init(level, lg->time, lg->goal);
}
- return 0;
}
void demo_play_step(float dt)
{
+ static float fps_track = 0.0f;
+ static float fps_cap = 1.0f / (float) DEMO_FPS_CAP;
+
if (demo_fp)
{
- put_float(demo_fp, &dt);
- put_game_state(demo_fp);
+ fps_track += dt;
+ if (fps_track > fps_cap)
+ {
+ put_float(demo_fp, &fps_track);
+ put_game_state(demo_fp);
+ fps_track = 0.0f;
+ }
}
}
-void demo_play_stat(int coins, int timer)
+void demo_play_stop(const struct level_game *lg)
+/* Update the demo header using the final level state. */
{
- int c = coins;
- int t = timer;
-
if (demo_fp)
{
- /* Update the demo header using the final score and time. */
-
- fseek(demo_fp, 4, SEEK_SET);
-
- put_index(demo_fp, &t);
- put_index(demo_fp, &c);
-
- fseek(demo_fp, 0, SEEK_END);
+ demo_header_stop(demo_fp, lg->coins, lg->timer, lg->state);
+ fclose(demo_fp);
+ demo_fp = NULL;
}
}
-void demo_play_stop(const char *name)
+int demo_play_saved(void)
+{
+ return demo_exists(USER_REPLAY_FILE);
+}
+
+void demo_play_save(const char *name)
{
char src[PATHMAX];
char dst[PATHMAX];
- if (demo_fp)
+ if (name && demo_exists(USER_REPLAY_FILE)
+ && strcmp(name, USER_REPLAY_FILE) != 0)
{
- fclose(demo_fp);
- demo_fp = NULL;
+ strncpy(src, config_user(USER_REPLAY_FILE), PATHMAX);
+ strcat(src, REPLAY_EXT);
+ strncpy(dst, config_user(name), PATHMAX);
+ strcat(dst, REPLAY_EXT);
- /* Rename the temporary replay file to its given name. */
+ rename(src, dst);
+ }
+}
- if (name)
- {
- strncpy(src, config_user(USER_REPLAY_FILE), PATHMAX);
- strncpy(dst, config_user(name), PATHMAX);
+/*---------------------------------------------------------------------------*/
- rename(src, dst);
- }
+static int demo_load_level(const struct demo *demo, struct level *level)
+/* Load the level of the demo and fill the level structure */
+{
+ if (level_load(demo->file, level))
+ {
+ level->time = demo->time;
+ level->goal = demo->goal;
+ return 1;
}
+ else
+ return 0;
}
-/*---------------------------------------------------------------------------*/
+static struct demo demo_replay; /* The current demo */
+static struct level demo_level_replay; /* The current level demo-ed*/
-static char demo_replay_name[MAXSTR];
+const struct demo *curr_demo_replay(void)
+{
+ return &demo_replay;
+}
-int demo_replay_init(const char *name, int *s, int *c, int *b, int *g)
+
+int demo_replay_init(const char *name, struct level_game *lg)
+/* Internally load a replay an fill the lg structure (if not NULL) */
{
- char shot[PATHMAX];
- char file[PATHMAX];
- char back[PATHMAX];
- char grad[PATHMAX];
- char song[PATHMAX];
-
- int magic;
- int zero;
- int st;
- int sg;
- int ss;
- int sc;
- int sb;
-
- if ((demo_fp = fopen(config_user(name), FMODE_RB)))
+ if ((demo_fp = demo_header_read(name, &demo_replay)))
{
- strncpy(demo_replay_name, name, MAXSTR);
-
- get_index(demo_fp, &magic);
+ if (!demo_load_level(&demo_replay, &demo_level_replay))
+ return 0;
- if (magic == MAGIC)
- {
- get_index(demo_fp, &zero);
- get_index(demo_fp, &zero);
-
- fread(shot, 1, PATHMAX, demo_fp);
- fread(file, 1, PATHMAX, demo_fp);
- fread(back, 1, PATHMAX, demo_fp);
- fread(grad, 1, PATHMAX, demo_fp);
- fread(song, 1, PATHMAX, demo_fp);
-
- get_index(demo_fp, &st);
- get_index(demo_fp, &sg);
- get_index(demo_fp, &ss);
- get_index(demo_fp, &sc);
- get_index(demo_fp, &sb);
-
- if (g) *g = (int) sg;
- if (s) *s = (int) ss;
- if (c) *c = (int) sc;
- if (b) *b = (int) sb;
-
- if (g)
- {
- audio_music_fade_to(0.5f, song);
- return game_init(file, back, grad, st, (*g == 0));
- }
- else
- return game_init(file, back, grad, st, 1);
+ if (lg)
+ {
+ lg->mode = demo_replay.mode;
+ lg->score = demo_replay.score;
+ lg->times = demo_replay.times;
+ lg->time = demo_replay.time;
+ lg->goal = demo_replay.goal;
+
+ /* A normal replay demo */
+ audio_music_fade_to(0.5f, demo_replay.song);
+ return game_init(&demo_level_replay, demo_replay.time,
+ demo_replay.goal);
}
- fclose(demo_fp);
+ else /* A title screen demo */
+ return game_init(&demo_level_replay, demo_replay.time, 0);
}
+
return 0;
}
int demo_replay_step(float *dt)
{
const float g[3] = { 0.0f, -9.8f, 0.0f };
+ int sv;
if (demo_fp)
{
{
/* Play out current game state for particles, clock, etc. */
- game_step(g, *dt, 1);
+ game_step(g, *dt, &sv);
/* Load real current game state from file. */
-
+
if (get_game_state(demo_fp))
return 1;
}
fclose(demo_fp);
demo_fp = NULL;
- if (d) unlink(config_user(demo_replay_name));
+ if (d) unlink(demo_replay.filename);
}
}
+void demo_replay_dump_info(void)
+{
+ demo_dump_info(&demo_replay);
+}
+
/*---------------------------------------------------------------------------*/
projects / neverball / blobdiff