level_file_info->nr = 0;
level_file_info->type = LEVEL_FILE_TYPE_UNKNOWN;
level_file_info->packed = FALSE;
- level_file_info->basename = NULL;
- level_file_info->filename = NULL;
+
+ setString(&level_file_info->basename, NULL);
+ setString(&level_file_info->filename, NULL);
}
int getMappedElement_SB(int, boolean);
/* overwrite all individual level settings from template level settings */
level = level_template;
+ /* restore level file info */
+ level.file_info = level_backup.file_info;
+
/* restore playfield size */
level.fieldx = level_backup.fieldx;
level.fieldy = level_backup.fieldy;
static char *getLevelFilenameFromBasename(char *basename)
{
- static char *filename[2] = { NULL, NULL };
- int pos = (strEqual(basename, LEVELTEMPLATE_FILENAME) ? 0 : 1);
+ static char *filename = NULL;
- checked_free(filename[pos]);
+ checked_free(filename);
- filename[pos] = getPath2(getCurrentLevelDir(), basename);
+ filename = getPath2(getCurrentLevelDir(), basename);
- return filename[pos];
+ return filename;
}
static int getFileTypeFromBasename(char *basename)
{
lfi->type = type;
lfi->packed = FALSE;
- lfi->basename = getSingleLevelBasename(lfi->nr, lfi->type);
- lfi->filename = getLevelFilenameFromBasename(lfi->basename);
+
+ setString(&lfi->basename, getSingleLevelBasename(lfi->nr, lfi->type));
+ setString(&lfi->filename, getLevelFilenameFromBasename(lfi->basename));
}
#endif
lfi->type = type;
lfi->packed = FALSE;
- lfi->basename = basename;
- lfi->filename = getLevelFilenameFromBasename(lfi->basename);
+
+ setString(&lfi->basename, basename);
+ setString(&lfi->filename, getLevelFilenameFromBasename(lfi->basename));
}
static void setLevelFileInfo_PackedLevelFilename(struct LevelFileInfo *lfi,
{
lfi->type = type;
lfi->packed = TRUE;
- lfi->basename = getPackedLevelBasename(lfi->type);
- lfi->filename = getLevelFilenameFromBasename(lfi->basename);
+
+ setString(&lfi->basename, getPackedLevelBasename(lfi->type));
+ setString(&lfi->filename, getLevelFilenameFromBasename(lfi->basename));
}
static int getFiletypeFromID(char *filetype_id)
getSingleLevelBasename(-1));
/* replace local level template filename with global template filename */
- lfi->filename = getGlobalLevelTemplateFilename();
+ setString(&lfi->filename, getGlobalLevelTemplateFilename());
/* no fallback if template file not existing */
return;
determineLevelFileInfo_Filetype(level_file_info);
}
+static void copyLevelFileInfo(struct LevelFileInfo *lfi_from,
+ struct LevelFileInfo *lfi_to)
+{
+ lfi_to->nr = lfi_from->nr;
+ lfi_to->type = lfi_from->type;
+ lfi_to->packed = lfi_from->packed;
+
+ setString(&lfi_to->basename, lfi_from->basename);
+ setString(&lfi_to->filename, lfi_from->filename);
+}
+
/* ------------------------------------------------------------------------- */
/* functions for loading R'n'D level */
/* ------------------------------------------------------------------------- */
level_file_info.nr = 0; /* unknown level number */
level_file_info.type = LEVEL_FILE_TYPE_RND; /* no others supported yet */
- level_file_info.filename = filename;
+
+ setString(&level_file_info.filename, filename);
LoadLevelFromFileInfo(level, &level_file_info, FALSE);
}
-static void LoadLevel_InitVersion(struct LevelInfo *level, char *filename)
+static void LoadLevel_InitVersion(struct LevelInfo *level)
{
int i, j;
}
}
-static void LoadLevel_InitElements(struct LevelInfo *level, char *filename)
+static void LoadLevel_InitElements(struct LevelInfo *level)
{
LoadLevel_InitStandardElements(level);
InitElementPropertiesGfxElement();
}
-static void LoadLevel_InitPlayfield(struct LevelInfo *level, char *filename)
+static void LoadLevel_InitPlayfield(struct LevelInfo *level)
{
int x, y;
SetBorderElement();
}
-static void LoadLevel_InitNativeEngines(struct LevelInfo *level,char *filename)
+static void LoadLevel_InitNativeEngines(struct LevelInfo *level)
{
struct LevelFileInfo *level_file_info = &level->file_info;
CopyNativeLevel_RND_to_Native(level);
}
-void LoadLevelTemplate(int nr)
+static void LoadLevelTemplate_LoadAndInit()
{
- char *filename;
-
- setLevelFileInfo(&level_template.file_info, nr);
- filename = level_template.file_info.filename;
-
LoadLevelFromFileInfo(&level_template, &level_template.file_info, FALSE);
- LoadLevel_InitVersion(&level_template, filename);
- LoadLevel_InitElements(&level_template, filename);
+ LoadLevel_InitVersion(&level_template);
+ LoadLevel_InitElements(&level_template);
ActivateLevelTemplate();
}
-void LoadLevel(int nr)
+void LoadLevelTemplate(int nr)
{
- char *filename;
+ if (!fileExists(getGlobalLevelTemplateFilename()))
+ {
+ Error(ERR_WARN, "no level template found for this level");
- setLevelFileInfo(&level.file_info, nr);
- filename = level.file_info.filename;
+ return;
+ }
+
+ setLevelFileInfo(&level_template.file_info, nr);
+
+ LoadLevelTemplate_LoadAndInit();
+}
+static void LoadLevelTemplateFromNetwork(struct LevelFileInfo *lfi_network_template)
+{
+ copyLevelFileInfo(lfi_network_template, &level_template.file_info);
+
+ LoadLevelTemplate_LoadAndInit();
+}
+
+static void LoadLevel_LoadAndInit(struct LevelFileInfo *lfi_network_template)
+{
LoadLevelFromFileInfo(&level, &level.file_info, FALSE);
if (level.use_custom_template)
- LoadLevelTemplate(-1);
+ {
+ if (lfi_network_template != NULL)
+ LoadLevelTemplateFromNetwork(lfi_network_template);
+ else
+ LoadLevelTemplate(-1);
+ }
+
+ LoadLevel_InitVersion(&level);
+ LoadLevel_InitElements(&level);
+ LoadLevel_InitPlayfield(&level);
- LoadLevel_InitVersion(&level, filename);
- LoadLevel_InitElements(&level, filename);
- LoadLevel_InitPlayfield(&level, filename);
+ LoadLevel_InitNativeEngines(&level);
+}
+
+void LoadLevel(int nr)
+{
+ setLevelFileInfo(&level.file_info, nr);
- LoadLevel_InitNativeEngines(&level, filename);
+ LoadLevel_LoadAndInit(NULL);
}
void LoadLevelInfoOnly(int nr)
LoadLevelFromFileInfo(&level, &level.file_info, TRUE);
}
+void LoadLevelFromNetwork(struct LevelFileInfo *lfi_network_level,
+ struct LevelFileInfo *lfi_network_template)
+{
+ copyLevelFileInfo(lfi_network_level, &level.file_info);
+
+ LoadLevel_LoadAndInit(lfi_network_template);
+}
+
static int SaveLevel_VERS(FILE *file, struct LevelInfo *level)
{
int chunk_size = 0;
char *filename = getScoreFilename(nr);
FILE *file;
- InitScoreDirectory(leveldir_current->subdir);
+ /* used instead of "leveldir_current->subdir" (for network games) */
+ InitScoreDirectory(levelset.identifier);
if (!(file = fopen(filename, MODE_WRITE)))
{
SETUP_TOKEN_SKIP_LEVELS,
SETUP_TOKEN_INCREMENT_LEVELS,
SETUP_TOKEN_AUTO_PLAY_NEXT_LEVEL,
+ SETUP_TOKEN_SKIP_SCORES_AFTER_GAME,
SETUP_TOKEN_TIME_LIMIT,
SETUP_TOKEN_FULLSCREEN,
SETUP_TOKEN_WINDOW_SCALING_PERCENT,
{ TYPE_SWITCH, &si.skip_levels, "skip_levels" },
{ TYPE_SWITCH, &si.increment_levels, "increment_levels" },
{ TYPE_SWITCH, &si.auto_play_next_level, "auto_play_next_level" },
+ { TYPE_SWITCH, &si.skip_scores_after_game, "skip_scores_after_game" },
{ TYPE_SWITCH, &si.time_limit, "time_limit" },
{ TYPE_SWITCH, &si.fullscreen, "fullscreen" },
{ TYPE_INTEGER,&si.window_scaling_percent, "window_scaling_percent" },
si->skip_levels = TRUE;
si->increment_levels = TRUE;
si->auto_play_next_level = TRUE;
+ si->skip_scores_after_game = FALSE;
si->time_limit = TRUE;
si->fullscreen = FALSE;
si->window_scaling_percent = STD_WINDOW_SCALING_PERCENT;