/**************************************************************************
* Original Diku Mud copyright (C) 1990, 1991 by Sebastian Hammer, *
* Michael Seifert, Hans Henrik St{rfeldt, Tom Madsen, and Katja Nyboe. *
* *
* Merc Diku Mud improvements copyright (C) 1992, 1993 by Michael *
* Chastain, Michael Quan, and Mitchell Tse. *
* *
* In order to use any part of this Merc Diku Mud, you must comply with *
* both the original Diku license in 'license.doc' as well the Merc *
* license in 'license.txt'. In particular, you may not remove either of *
* these copyright notices. *
* *
* Much time and thought has gone into this software and you are *
* benefiting. We hope that you share your changes too. What goes *
* around, comes around. *
***************************************************************************
* ROM 2.4 is copyright 1993-1998 Russ Taylor *
* ROM has been brought to you by the ROM consortium *
* Russ Taylor (rtaylor@hypercube.org) *
* Gabrielle Taylor (gtaylor@hypercube.org) *
* Brian Moore (zump@rom.org) *
* By using this code, you have agreed to follow the terms of the *
* ROM license, in the file Rom24/doc/rom.license *
***************************************************************************
* 1stMUD ROM Derivative (c) 2001-2002 by Ryan Jennings *
* http://1stmud.dlmud.com/ <r-jenn@shaw.ca> *
***************************************************************************/
#include <sys/types.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "merc.h"
#include "tables.h"
#include "lookup.h"
#include "interp.h"
#include "olc.h"
#include "recycle.h"
#include "db.h"
struct savetable_type
{
char *field;
int type_field;
void *puntero_field;
const void *argument;
const void *argument2;
};
#define FIELD_STRING 0
#define FIELD_FUNCION_INT_TO_STR 1
#define FIELD_LONG_ARRAY 2
#define FIELD_FLAGSTRING 3
#define FIELD_INT 4
#define FIELD_FLAGVECTOR 5
#define FIELD_BOOL 6
#define FIELD_INT_ARRAY 7
#define FIELD_STRING_ARRAY 8
#define FIELD_INT_FLAGSTRING 9
#define FIELD_BOOL_ARRAY 10
#define FIELD_INUTIL 11
#define FIELD_INT_ALLOC_ARRAY 12
#define FIELD_LONG 13
#define FIELD_STRING_ARRAY_NULL 14
#define FIELD_RANK 15
typedef char *STR_FUNC(void *);
typedef bool STR_READ_FUNC(void *, const char *);
CMD_DATA cmd;
SKILL_DATA sk;
RACE_DATA race;
GROUP_DATA grp;
CLASS_DATA cls;
SOCIAL_DATA soc;
CLAN_DATA clan;
STAT_DATA stat;
BAN_DATA ban;
GQUEST gq;
DEITY_DATA deity;
WPWD_DATA pwd;
MBR_DATA mbr;
const char *do_fun_name(DO_FUN *);
DO_FUN *do_fun_lookup(const char *);
const char *skill_gsn_name(int *);
int *gsn_lookup(const char *);
const char *spell_fun_name(SPELL_FUN *);
SPELL_FUN *spell_lookup(const char *);
const char *do_fun_str(void *temp)
{
DO_FUN **fun = (DO_FUN **) temp;
return do_fun_name(*fun);
}
const char *position_str(void *temp)
{
int *flags = (int *) temp;
return position_table[*flags].name;
}
const char *size_str(void *temp)
{
int *size = (int *) temp;
return size_table[UMAX(0, *size)].name;
}
const char *race_str(void *temp)
{
RACE_DATA **raza = (RACE_DATA **) temp;
RACE_DATA *tmp;
for (tmp = race_first; tmp; tmp = tmp->next)
if (tmp == *raza)
return tmp->name;
return "unique";
}
const char *pgsn_str(void *temp)
{
int **pgsn = (int **) temp;
return skill_gsn_name(*pgsn);
}
const char *spell_fun_str(void *temp)
{
SPELL_FUN **spfun = (SPELL_FUN **) temp;
return spell_fun_name(*spfun);
}
bool do_fun_read(void *temp, char *arg)
{
DO_FUN **fun = (DO_FUN **) temp;
*fun = do_fun_lookup(arg);
return TRUE;
}
bool position_read(void *temp, char *arg)
{
int *posic = (int *) temp;
int ffg = position_lookup(arg);
*posic = UMAX(0, ffg);
if (ffg == -1)
return FALSE;
else
return TRUE;
}
bool size_read(void *temp, char *arg)
{
int *size = (int *) temp;
int ffg = size_lookup(arg);
*size = UMAX(0, ffg);
if (ffg == -1)
return FALSE;
else
return TRUE;
}
bool pgsn_read(void *temp, char *arg)
{
int **pgsn = (int **) temp;
int *blah = gsn_lookup(arg);
*pgsn = blah;
return !str_cmp(arg, "") || blah != NULL;
}
bool spell_fun_read(void *temp, char *arg)
{
SPELL_FUN **spfun = (SPELL_FUN **) temp;
SPELL_FUN *blah = spell_lookup(arg);
*spfun = blah;
return !str_cmp(arg, "") || blah != NULL;
}
const char *clan_str(void *temp)
{
CLAN_DATA **clan = (CLAN_DATA **) temp;
CLAN_DATA *tmp;
for (tmp = clan_first; tmp; tmp = tmp->next)
if (tmp == *clan)
return tmp->name;
return "unknown";
}
bool clan_read(void *temp, char *arg)
{
CLAN_DATA **posic = (CLAN_DATA **) temp;
*posic = clan_lookup(arg);
if (*posic == NULL)
return FALSE;
else
return TRUE;
}
const struct savetable_type cmdsavetable[] = {
{"name", FIELD_STRING, (void *) &cmd.name, NULL, NULL},
{"do_fun", FIELD_FUNCION_INT_TO_STR, (void *) &cmd.do_fun,
(const void *) do_fun_str,
(const void *) do_fun_read},
{"position", FIELD_FUNCION_INT_TO_STR, (void *) &cmd.position,
(const void *) position_str, (const void *) position_read},
{"level", FIELD_INT, (void *) &cmd.level, NULL, NULL},
{"log", FIELD_FLAGSTRING, (void *) &cmd.log, (const void *) log_flags,
NULL},
{"show", FIELD_BOOL, (void *) &cmd.show, NULL, NULL},
{NULL, 0, NULL, NULL, NULL}
};
const struct savetable_type skillsavetable[] = {
{"name", FIELD_STRING, (void *) &sk.name, NULL, NULL},
{"levels", FIELD_INT_ALLOC_ARRAY, (void *) &sk.skill_level,
(const void *) &maxClass, (const void *) (LEVEL_IMMORTAL + 1)},
{"ratings", FIELD_INT_ALLOC_ARRAY, (void *) &sk.rating,
(const void *) &maxClass, (const void *) 0},
{"spell_fun", FIELD_FUNCION_INT_TO_STR, (void *) &sk.spell_fun,
(const void *) spell_fun_str, (const void *) spell_fun_read},
{"target", FIELD_INT_FLAGSTRING, (void *) &sk.target,
(const void *) target_flags, NULL},
{"minimum_position", FIELD_FUNCION_INT_TO_STR,
(void *) &sk.minimum_position, (const void *) position_str,
(const void *) position_read},
{"pgsn", FIELD_FUNCION_INT_TO_STR, (void *) &sk.pgsn,
(const void *) pgsn_str,
(const void *) pgsn_read},
{"min_mana", FIELD_INT, (void *) &sk.min_mana, NULL, NULL},
{"beats", FIELD_INT, (void *) &sk.beats, NULL, NULL},
{"noun_damage", FIELD_STRING, (void *) &sk.noun_damage, NULL, NULL},
{"msg_off", FIELD_STRING, (void *) &sk.msg_off, NULL, NULL},
{"msg_obj", FIELD_STRING, (void *) &sk.msg_obj, NULL, NULL},
{NULL, 0, NULL, NULL, NULL}
};
const struct savetable_type racesavetable[] = {
{"race", FIELD_STRING, (void *) &race.name, NULL, NULL},
{"pc", FIELD_BOOL, (void *) &race.pc_race, NULL, NULL},
{"act", FIELD_FLAGVECTOR, (void *) &race.act, NULL, NULL},
{"aff", FIELD_FLAGVECTOR, (void *) &race.aff, NULL, NULL},
{"off", FIELD_FLAGVECTOR, (void *) &race.off, NULL, NULL},
{"imm", FIELD_FLAGVECTOR, (void *) &race.imm, NULL, NULL},
{"res", FIELD_FLAGVECTOR, (void *) &race.res, NULL, NULL},
{"vuln", FIELD_FLAGVECTOR, (void *) &race.vuln, NULL, NULL},
{"form", FIELD_FLAGVECTOR, (void *) &race.form, NULL, NULL},
{"parts", FIELD_FLAGVECTOR, (void *) &race.parts, NULL, NULL},
{"who", FIELD_STRING, (void *) &race.who_name, NULL, NULL},
{"points", FIELD_INT, (void *) &race.points, NULL, NULL},
{"classx", FIELD_INT_ALLOC_ARRAY, (void *) &race.class_mult,
(const void *) &maxClass, (const void *) 100},
{"skills", FIELD_STRING_ARRAY_NULL, (void *) &race.skills,
(const void *) 5, NULL},
{"stats", FIELD_INT_ARRAY, (void *) &race.stats, (const void *) MAX_STATS,
(const void *) 13},
{"mstats", FIELD_INT_ARRAY, (void *) &race.max_stats,
(const void *) MAX_STATS, (const void *) 25},
{"size", FIELD_FUNCION_INT_TO_STR, (void *) &race.size,
(const void *) size_str,
(const void *) size_read},
{NULL, 0, NULL, NULL, NULL}
};
const struct savetable_type groupsavetable[] = {
{"name", FIELD_STRING, (void *) &grp.name, NULL, NULL},
{"ratings", FIELD_INT_ALLOC_ARRAY, (void *) &grp.rating,
(const void *) &maxClass, (const void *) 0},
{"spells", FIELD_STRING_ARRAY_NULL, (void *) &grp.spells,
(const void *) MAX_IN_GROUP, NULL},
{NULL, 0, NULL, NULL, NULL}
};
const struct savetable_type classsavetable[] = {
{"name", FIELD_STRING, (void *) &cls.name, NULL, NULL},
{"whoname", FIELD_STRING, (void *) &cls.who_name, NULL, NULL},
{"prime", FIELD_INT, (void *) &cls.attr_prime, NULL, NULL},
{"weapon", FIELD_LONG, (void *) &cls.weapon, NULL, NULL},
{"guild", FIELD_LONG_ARRAY, (void *) &cls.guild,
(const void *) MAX_GUILD, NULL},
{"adept", FIELD_INT, (void *) &cls.skill_adept, NULL, NULL},
{"thac0", FIELD_INT, (void *) &cls.thac0_00, NULL, NULL},
{"thac32", FIELD_INT, (void *) &cls.thac0_32, NULL, NULL},
{"minhp", FIELD_INT, (void *) &cls.hp_min, NULL, NULL},
{"maxhp", FIELD_INT, (void *) &cls.hp_max, NULL, NULL},
{"fmana", FIELD_BOOL, (void *) &cls.fMana, NULL, NULL},
{"basegrp", FIELD_STRING, (void *) &cls.base_group, NULL, NULL},
{"defaultgrp", FIELD_STRING, (void *) &cls.default_group, NULL, NULL},
{NULL, 0, NULL, NULL, NULL}
};
const struct savetable_type socialsavetable[] = {
{"name", FIELD_STRING, (void *) &soc.name, NULL, NULL},
{"cnoarg", FIELD_STRING, (void *) &soc.char_no_arg, NULL, NULL},
{"onoarg", FIELD_STRING, (void *) &soc.others_no_arg, NULL, NULL},
{"cfound", FIELD_STRING, (void *) &soc.char_found, NULL, NULL},
{"ofound", FIELD_STRING, (void *) &soc.others_found, NULL, NULL},
{"vfound", FIELD_STRING, (void *) &soc.vict_found, NULL, NULL},
{"cnotfound", FIELD_STRING, (void *) &soc.char_not_found, NULL, NULL},
{"cauto", FIELD_STRING, (void *) &soc.char_auto, NULL, NULL},
{"oauto", FIELD_STRING, (void *) &soc.others_auto, NULL, NULL},
{NULL, 0, NULL, NULL, NULL}
};
const struct savetable_type clansavetable[] = {
{"name", FIELD_STRING, (void *) &clan.name, NULL, NULL},
{"whoname", FIELD_STRING, (void *) &clan.who_name, NULL, NULL},
{"hall", FIELD_LONG, (void *) &clan.hall, NULL, NULL},
{"indep", FIELD_BOOL, (void *) &clan.independent, NULL, NULL},
{"rank", FIELD_RANK, (void *) &clan.rank, (void *) MAX_RANK, NULL},
{NULL, 0, NULL, NULL, NULL}
};
const struct savetable_type statsavetable[] = {
{"name", FIELD_STRING, (void *) &stat.name, NULL, NULL},
{"stats", FIELD_LONG_ARRAY, (void *) &stat.gamestat,
(const void *) MAX_GAMESTAT, (const void *) 0},
{NULL, 0, NULL, NULL, NULL}
};
const struct savetable_type bansavetable[] = {
{"name", FIELD_STRING, (void *) &ban.name, NULL, NULL},
{"level", FIELD_INT, (void *) &ban.level, NULL, NULL},
{"flags", FIELD_FLAGVECTOR, (void *) &ban.ban_flags, NULL, NULL},
{NULL, 0, NULL, NULL, NULL}
};
const struct savetable_type gqsavetable[] = {
{"mobs", FIELD_LONG_ARRAY, (void *) &gq.mobs, (void *) MAX_GQUEST_MOB,
(void *) -1},
{"mcount", FIELD_INT, (void *) &gq.mob_count, NULL, NULL},
{"who", FIELD_STRING, (void *) &gq.who, NULL, NULL},
{"timer", FIELD_INT, (void *) &gq.timer, NULL, NULL},
{"involv", FIELD_INT, (void *) &gq.involved, NULL, NULL},
{"qpoints", FIELD_INT, (void *) &gq.qpoints, NULL, NULL},
{"gold", FIELD_INT, (void *) &gq.gold, NULL, NULL},
{"minlev", FIELD_INT, (void *) &gq.minlevel, NULL, NULL},
{"maxlev", FIELD_INT, (void *) &gq.maxlevel, NULL, NULL},
{"running", FIELD_INT, (void *) &gq.running, NULL, NULL},
{"next", FIELD_INT, (void *) &gq.next, NULL, NULL},
{NULL, 0, NULL, NULL, NULL}
};
const struct savetable_type deitysavetable[] = {
{"name", FIELD_STRING, (void *) &deity.name, NULL, NULL},
{"desc", FIELD_STRING, (void *) &deity.desc, NULL, NULL},
{"skill", FIELD_STRING, (void *) &deity.skillname, NULL, NULL},
{NULL, 0, NULL, NULL, NULL}
};
const struct savetable_type pwdsavetable[] = {
{"name", FIELD_STRING, (void *) &pwd.name, NULL, NULL},
{"pwd", FIELD_STRING, (void *) &pwd.passw, NULL, NULL},
{NULL, 0, NULL, NULL, NULL}
};
const struct savetable_type mbrsavetable[] = {
{"name", FIELD_STRING, (void *) &mbr.name, NULL, NULL},
{"clan", FIELD_FUNCION_INT_TO_STR, (void *) &mbr.clan, (void *) clan_str,
(void *) clan_read},
{"rank", FIELD_INT, (void *) &mbr.rank, NULL, NULL},
{"level", FIELD_INT, (void *) &mbr.level, NULL, NULL},
{NULL, 0, NULL, NULL, NULL}
};
void load_struct(FILE * fp, void *typebase,
const struct savetable_type *table, void *puntero)
{
const char *word;
const struct savetable_type *temp;
flag_t *pentero;
const char **pstring;
const char *string;
int *pint;
int **array;
long *plong;
STR_READ_FUNC *function;
struct flag_type *flagtable;
bool found = FALSE;
bool *pbool;
int cnt = 0, i;
RANK_DATA *rdata;
while (str_cmp((word = fread_word(fp)), "#END"))
{
for (temp = table; !IS_NULLSTR(temp->field); temp++)
{
if (!str_cmp(word, temp->field))
{
switch (temp->type_field)
{
case FIELD_STRING:
pstring =
(const char **) ((int) temp->puntero_field -
(int) typebase + (int) puntero);
*pstring = fread_string(fp);
found = TRUE, cnt++;
break;
case FIELD_INT:
pint =
(int *) ((int) temp->puntero_field - (int) typebase +
(int) puntero);
*pint = fread_number(fp);
found = TRUE, cnt++;
break;
case FIELD_LONG:
plong =
(long *) ((int) temp->puntero_field - (int) typebase +
(int) puntero);
*plong = fread_number(fp);
found = TRUE, cnt++;
break;
case FIELD_FUNCION_INT_TO_STR:
function = (STR_READ_FUNC *) temp->argument2;
string = fread_string(fp);
pint =
(int *) ((int) temp->puntero_field - (int) typebase +
(int) puntero);
if ((*function) (pint, string) == FALSE)
bugf("field %s invalid, string %s",
temp->field, string);
free_string(string);
found = TRUE, cnt++;
break;
case FIELD_FLAGSTRING:
flagtable = (struct flag_type *) temp->argument;
pentero =
(flag_t *) ((int) temp->puntero_field -
(int) typebase + (int) puntero);
string = fread_string(fp);
*pentero = flag_value(flagtable, string);
free_string(string);
found = TRUE, cnt++;
break;
case FIELD_INT_FLAGSTRING:
flagtable = (struct flag_type *) temp->argument;
pint =
(int *) ((int) temp->puntero_field - (int) typebase +
(int) puntero);
string = fread_string(fp);
*pint = flag_value(flagtable, string);
free_string(string);
found = TRUE, cnt++;
break;
case FIELD_FLAGVECTOR:
pentero =
(flag_t *) ((int) temp->puntero_field -
(int) typebase + (int) puntero);
*pentero = fread_flag(fp);
found = TRUE, cnt++;
break;
case FIELD_BOOL:
pbool =
(bool *) ((int) temp->puntero_field - (int) typebase +
(int) puntero);
string = fread_word(fp);
*pbool = str_cmp(string, "FALSE") ? TRUE : FALSE;
found = TRUE, cnt++;
break;
case FIELD_INT_ARRAY:
pint =
(int *) ((int) temp->puntero_field - (int) typebase +
(int) puntero);
i = 0;
while (str_cmp((string = fread_word(fp)), "@"))
{
if (i == (int) temp->argument)
bugf("field_shint_array %s has excess elements",
temp->field);
else
pint[i++] = (int) atoi(string);
}
while (i < (int) temp->argument)
pint[i++] = (int) temp->argument2;
found = TRUE, cnt++;
break;
case FIELD_INT_ALLOC_ARRAY:
array =
(int **) ((int) temp->puntero_field - (int) typebase +
(int) puntero);
i = 0;
alloc_mem(*array, int, *(int *) temp->argument);
while (str_cmp((string = fread_word(fp)), "@"))
{
if (i == *(int *) temp->argument)
bugf("field_shint_array %s has excess elements",
temp->field);
else
(*array)[i++] = (int) atoi(string);
}
while (i < *(int *) temp->argument)
(*array)[i++] = (int) temp->argument2;
found = TRUE, cnt++;
break;
case FIELD_LONG_ARRAY:
plong =
(long *) ((int) temp->puntero_field - (int) typebase +
(int) puntero);
i = 0;
while (str_cmp((string = fread_word(fp)), "@"))
{
if (i == (int) temp->argument)
bugf("field_shint_array %s has excess elements",
temp->field);
else
plong[i++] = (long) atol(string);
}
while (i < (int) temp->argument)
plong[i++] = (long) temp->argument2;
found = TRUE, cnt++;
break;
case FIELD_STRING_ARRAY:
case FIELD_STRING_ARRAY_NULL:
pstring =
(const char **) ((int) temp->puntero_field -
(int) typebase + (int) puntero);
i = 0;
while (str_cmp((string = fread_string(fp)), "@"))
{
if (i == (int) temp->argument)
bugf("field_string_array %s has excess elements.",
temp->field);
else
pstring[i++] = string;
}
while (i < (int) temp->argument)
pstring[i++] = NULL;
found = TRUE, cnt++;
break;
case FIELD_RANK:
rdata =
(RANK_DATA *) ((int) temp->puntero_field -
(int) typebase + (int) puntero);
i = fread_number(fp);
//fread_string(fp);
rdata[i - 1].rankname = fread_string(fp);
found = TRUE, cnt++;
break;
case FIELD_INUTIL:
fread_to_eol(fp);
found = TRUE, cnt++;
break;
case FIELD_BOOL_ARRAY:
pbool =
(bool *) ((int) temp->puntero_field - (int) typebase +
(int) puntero);
i = 0;
while (str_cmp((string = fread_word(fp)), "@"))
{
if ((temp->argument != NULL
&& i == (int) temp->argument)
|| (temp->argument == NULL
&& temp->argument2 != NULL
&& i == *((int *) temp->argument2)))
bugf("field_bool_array %s has excess elements",
temp->field);
else
pbool[i++] = (bool) atoi(string);
}
found = TRUE, cnt++;
break;
} // switch
if (found == TRUE)
break;
} // if
} // for
if (found == FALSE)
{
bugf("word %s not found", word);
fread_to_eol(fp);
}
else
found = FALSE;
} // while
}
void save_struct(FILE * fp, void *typebase,
const struct savetable_type *table, void *puntero)
{
const struct savetable_type *temp;
const char **pstring;
int *pint;
long *plong;
int **array;
STR_FUNC *function;
const char *string;
flag_t *pentero;
bool *pbool;
const struct flag_type *flagtable;
int cnt = 0, i;
RANK_DATA *rdata;
for (temp = table; !IS_NULLSTR(temp->field); temp++)
{
switch (temp->type_field)
{
default:
bugf("type_field %d invalid, field %s",
temp->type_field, temp->field);
break;
case FIELD_STRING:
pstring =
(const char **) ((int) temp->puntero_field - (int) typebase +
(int) puntero);
fprintf(fp, "%s\t\t%s~\n", temp->field,
IS_NULLSTR(*pstring) ? "" : fix_string(*pstring));
break;
case FIELD_INT:
pint =
(int *) ((int) temp->puntero_field - (int) typebase +
(int) puntero);
fprintf(fp, "%s\t\t%d\n", temp->field, *pint);
break;
case FIELD_LONG:
plong =
(long *) ((int) temp->puntero_field - (int) typebase +
(int) puntero);
fprintf(fp, "%s\t\t%ld\n", temp->field, *plong);
break;
case FIELD_FUNCION_INT_TO_STR:
function = (STR_FUNC *) temp->argument;
pint =
(int *) ((int) temp->puntero_field - (int) typebase +
(int) puntero);
string = (*function) ((void *) pint);
fprintf(fp, "%s\t\t%s~\n", temp->field, string);
break;
case FIELD_FLAGSTRING:
flagtable = (struct flag_type *) temp->argument;
pentero =
(flag_t *) ((int) temp->puntero_field - (int) typebase +
(int) puntero);
fprintf(fp, "%s\t\t%s~\n", temp->field,
flag_string(flagtable, *pentero));
break;
case FIELD_INT_FLAGSTRING:
flagtable = (struct flag_type *) temp->argument;
pint =
(int *) ((int) temp->puntero_field - (int) typebase +
(int) puntero);
fprintf(fp, "%s\t\t%s~\n", temp->field,
flag_string(flagtable, *pint));
break;
case FIELD_FLAGVECTOR:
pentero =
(flag_t *) ((int) temp->puntero_field - (int) typebase +
(int) puntero);
fprintf(fp, "%s\t\t%s\n", temp->field, fwrite_flags(*pentero));
break;
case FIELD_BOOL:
pbool =
(bool *) ((int) temp->puntero_field - (int) typebase +
(int) puntero);
fprintf(fp, "%s\t\t%s\n", temp->field,
(*pbool == TRUE) ? "TRUE" : "FALSE");
break;
case FIELD_INT_ARRAY:
pint =
(int *) ((int) temp->puntero_field - (int) typebase +
(int) puntero);
fprintf(fp, "%s\t\t", temp->field);
for (i = 0; i < (int) temp->argument; i++)
fprintf(fp, "%d ", pint[i]);
fprintf(fp, "@\n");
break;
case FIELD_INT_ALLOC_ARRAY:
array =
(int **) ((int) temp->puntero_field - (int) typebase +
(int) puntero);
fprintf(fp, "%s\t\t", temp->field);
for (i = 0; i < *(int *) temp->argument; i++)
fprintf(fp, "%d ", (*array)[i]);
fprintf(fp, "@\n");
break;
case FIELD_LONG_ARRAY:
plong =
(long *) ((int) temp->puntero_field - (int) typebase +
(int) puntero);
fprintf(fp, "%s\t\t", temp->field);
for (i = 0; i < (int) temp->argument; i++)
fprintf(fp, "%ld ", plong[i]);
fprintf(fp, "@\n");
break;
case FIELD_STRING_ARRAY:
pstring =
(const char **) ((int) temp->puntero_field - (int) typebase +
(int) puntero);
fprintf(fp, "%s\t\t", temp->field);
for (i = 0; i < (int) temp->argument; i++)
fprintf(fp, "%s~ ",
!IS_NULLSTR(pstring[i]) ? fix_string(pstring[i]) : "");
fprintf(fp, "@~\n");
break;
case FIELD_STRING_ARRAY_NULL:
pstring =
(const char **) ((int) temp->puntero_field - (int) typebase +
(int) puntero);
fprintf(fp, "%s\t\t", temp->field);
for (i = 0; i < (int) temp->argument && !IS_NULLSTR(pstring[i]);
i++)
fprintf(fp, "%s~ ",
!IS_NULLSTR(pstring[i]) ? fix_string(pstring[i]) : "");
fprintf(fp, "@~\n");
break;
case FIELD_BOOL_ARRAY:
pbool =
(bool *) ((int) temp->puntero_field - (int) typebase +
(int) puntero);
fprintf(fp, "%s\t\t", temp->field);
for (i = 0;
i <
(temp->argument ? (int) temp->
argument : *(int *) temp->argument2); i++)
fprintf(fp, "%d ", pbool[i] == TRUE ? 1 : 0);
fprintf(fp, "@\n");
break;
case FIELD_RANK:
rdata =
(RANK_DATA *) ((int) temp->puntero_field - (int) typebase +
(int) puntero);
for (i = 0; i < (int) temp->argument; i++)
{
fprintf(fp, "%s\t%s%d ", temp->field,
strlen(temp->field) < 8 ? "\t" : "", i + 1);
fprintf(fp, "%s~\n", fix_string(rdata[i].rankname));
}
break;
case FIELD_INUTIL:
break;
}
cnt++;
}
};
void save_commands(void)
{
FILE *fp;
CMD_DATA *i;
#if !defined(WIN32)
const char *TEMPFILE = COMMAND_FILE ".tmp";
fp = file_open(TEMPFILE, "w");
#else
fp = file_open(COMMAND_FILE, "w");
#endif
if (!fp)
{
perror("save_commands");
file_close(fp);
return;
}
for (i = cmd_first; i; i = i->next)
{
fprintf(fp, "#COMMAND\n");
save_struct(fp, &cmd, cmdsavetable, i);
fprintf(fp, "#END\n\n");
}
fprintf(fp, "#!\n\n");
file_close(fp);
#if !defined(WIN32)
rename(TEMPFILE, COMMAND_FILE);
#endif
}
void load_commands(void)
{
FILE *fp;
static CMD_DATA emptycmd;
CMD_DATA *i;
const char *word;
fp = file_open(COMMAND_FILE, "r");
if (fp == NULL)
{
perror("load_commands ");
file_close(fp);
return;
}
while (TRUE)
{
word = feof(fp) ? "#!" : fread_word(fp);
if (!str_cmp(word, "#!"))
break;
if (str_cmp(word, "#COMMAND"))
{
bugf("word %s", word);
file_close(fp);
return;
}
i = new_command();
*i = emptycmd;
load_struct(fp, &cmd, cmdsavetable, i);
LINK(i, cmd_first, cmd_last, next, prev);
}
}
void save_skills(void)
{
FILE *fp;
int i;
#if !defined(WIN32)
const char *TEMPFILE = SKILL_FILE ".tmp";
fp = file_open(TEMPFILE, "w");
#else
fp = file_open(SKILL_FILE, "w");
#endif
if (!fp)
{
bug("save_skills: NULL fp", 0);
file_close(fp);
return;
}
fprintf(fp, "%d\n", maxSkill);
for (i = 0; i < maxSkill; ++i)
{
fprintf(fp, "#SKILL\n");
save_struct(fp, &sk, skillsavetable, &skill_table[i]);
fprintf(fp, "#END\n\n");
}
fprintf(fp, "#!\n");
file_close(fp);
#if !defined(WIN32)
rename(TEMPFILE, SKILL_FILE);
#endif
}
void load_skills(void)
{
FILE *fp;
static SKILL_DATA skzero;
int i = 0;
const char *word;
fp = file_open(SKILL_FILE, "r");
if (!fp)
{
bug("load_skills: Unable to open " SKILL_FILE " to load skills.", 0);
exit(1);
}
fscanf(fp, "%d\n", &maxSkill);
alloc_mem(skill_table, SKILL_DATA, maxSkill + 1);
if (!skill_table)
{
bugf("Error! Skill_table == NULL, MAX_SKILL : %d", maxSkill);
exit(1);
}
for (;;)
{
word = fread_word(fp);
if (!str_cmp(word, "#!"))
break;
if (str_cmp(word, "#SKILL"))
{
bugf("word doesn't exist (%s)", word);
exit(1);
}
if (i >= maxSkill)
{
bug("load_skills: number greater than maxSkill", 0);
exit(1);
}
skill_table[i] = skzero;
load_struct(fp, &sk, skillsavetable, &skill_table[i++]);
}
skill_table[maxSkill].name = NULL;
file_close(fp);
}
void save_races(void)
{
FILE *fp;
RACE_DATA *temp;
#if !defined(WIN32)
const char *TEMPFILE = RACE_FILE ".tmp";
fp = file_open(TEMPFILE, "w");
#else
fp = file_open(RACE_FILE, "w");
#endif
if (!fp)
{
perror("save_races : fopen");
return;
}
for (temp = race_first; temp; temp = temp->next)
{
fprintf(fp, "#RACE\n");
save_struct(fp, &race, racesavetable, temp);
fprintf(fp, "#END\n\n");
}
fprintf(fp, "#!\n\n");
file_close(fp);
#if !defined(WIN32)
rename(TEMPFILE, RACE_FILE);
#endif
}
void load_races(void)
{
FILE *fp;
const char *word;
RACE_DATA *pRace;
fp = file_open(RACE_FILE, "r");
if (!fp)
{
perror("load_races");
return;
}
while (TRUE)
{
word = fread_word(fp);
if (!str_cmp(word, "#!"))
break;
if (str_cmp(word, "#RACE"))
{
bugf("word %s", word);
file_close(fp);
return;
}
pRace = new_race();
load_struct(fp, &race, racesavetable, pRace);
LINK(pRace, race_first, race_last, next, prev);
}
}
void save_groups(void)
{
FILE *fp;
int i;
#if !defined(WIN32)
const char *TEMPFILE = GROUP_FILE ".tmp";
fp = file_open(TEMPFILE, "w");
#else
fp = file_open(GROUP_FILE, "w");
#endif
if (!fp)
{
bug("save_groups: NULL fp", 0);
file_close(fp);
return;
}
fprintf(fp, "%d\n", maxGroup);
for (i = 0; i < maxGroup; ++i)
{
fprintf(fp, "#GROUP\n");
save_struct(fp, &grp, groupsavetable, &group_table[i]);
fprintf(fp, "#END\n\n");
}
fprintf(fp, "#!\n");
file_close(fp);
#if !defined(WIN32)
rename(TEMPFILE, GROUP_FILE);
#endif
}
void load_groups(void)
{
FILE *fp;
static GROUP_DATA grpzero;
int i = 0;
const char *word;
fp = file_open(GROUP_FILE, "r");
if (!fp)
{
bug("load_groups: Unable to open " GROUP_FILE " to load groups.", 0);
exit(1);
}
fscanf(fp, "%d\n", &maxGroup);
alloc_mem(group_table, GROUP_DATA, maxGroup + 1);
if (!group_table)
{
bugf("Error! Group_table == NULL, MAX_GROUP : %d", maxGroup);
exit(1);
}
for (;;)
{
word = fread_word(fp);
if (!str_cmp(word, "#!"))
break;
if (str_cmp(word, "#GROUP"))
{
bugf("word doesn't exist (%s)", word);
exit(1);
}
if (i >= maxGroup)
{
bug("load_groups: number greater than maxGroup", 0);
exit(1);
}
group_table[i] = grpzero;
load_struct(fp, &grp, groupsavetable, &group_table[i++]);
}
group_table[maxGroup].name = NULL;
file_close(fp);
}
void save_classes(void)
{
FILE *fp;
int i;
#if !defined(WIN32)
const char *TEMPFILE = CLASS_FILE ".tmp";
fp = file_open(TEMPFILE, "w");
#else
fp = file_open(CLASS_FILE, "w");
#endif
if (!fp)
{
bug("save_classes: NULL fp", 0);
file_close(fp);
return;
}
fprintf(fp, "%d\n", maxClass);
for (i = 0; i < maxClass; ++i)
{
fprintf(fp, "#CLASS\n");
save_struct(fp, &cls, classsavetable, &class_table[i]);
fprintf(fp, "#END\n\n");
}
fprintf(fp, "#!\n");
file_close(fp);
#if !defined(WIN32)
rename(TEMPFILE, CLASS_FILE);
#endif
}
void load_classes(void)
{
FILE *fp;
static CLASS_DATA clszero;
int i = 0;
const char *word;
fp = file_open(CLASS_FILE, "r");
if (!fp)
{
bug("load_classes: Unable to open " CLASS_FILE " to load classes.", 0);
exit(1);
}
fscanf(fp, "%d\n", &maxClass);
alloc_mem(class_table, CLASS_DATA, maxClass + 1);
if (!class_table)
{
bugf("Error! Class_table == NULL, MAX_CLASS : %d", maxClass);
exit(1);
}
for (;;)
{
word = fread_word(fp);
if (!str_cmp(word, "#!"))
break;
if (str_cmp(word, "#CLASS"))
{
bugf("word doesn't exist (%s)", word);
exit(1);
}
if (i >= maxClass)
{
bug("load_classes: number greater than maxClass", 0);
exit(1);
}
class_table[i] = clszero;
load_struct(fp, &cls, classsavetable, &class_table[i++]);
}
class_table[maxClass].name = NULL;
file_close(fp);
}
void save_social_table(void)
{
FILE *fp;
SOCIAL_DATA *i;
#if !defined(WIN32)
const char *TEMPFILE = SOCIAL_FILE ".tmp";
fp = file_open(TEMPFILE, "w");
#else
fp = file_open(SOCIAL_FILE, "w");
#endif
if (!fp)
{
bug("save_socials: NULL fp", 0);
file_close(fp);
return;
}
for (i = social_first; i; i = i->next)
{
fprintf(fp, "#SOCIAL\n");
save_struct(fp, &soc, socialsavetable, i);
fprintf(fp, "#END\n\n");
}
fprintf(fp, "#!\n");
file_close(fp);
#if !defined(WIN32)
rename(TEMPFILE, SOCIAL_FILE);
#endif
}
void load_social_table(void)
{
FILE *fp;
static SOCIAL_DATA socialzero;
SOCIAL_DATA *pSocial;
const char *word;
fp = file_open(SOCIAL_FILE, "r");
if (!fp)
{
bug("load_socials: Unable to open " SOCIAL_FILE " to load socials.", 0);
exit(1);
}
for (;;)
{
word = fread_word(fp);
if (!str_cmp(word, "#!"))
break;
if (str_cmp(word, "#SOCIAL"))
{
bugf("word doesn't exist (%s)", word);
exit(1);
}
pSocial = new_social();
*pSocial = socialzero;
load_struct(fp, &soc, socialsavetable, pSocial);
LINK(pSocial, social_first, social_last, next, prev);
}
file_close(fp);
}
void save_clans(void)
{
FILE *fp;
CLAN_DATA *i;
#if !defined(WIN32)
const char *TEMPFILE = CLAN_FILE ".tmp";
fp = file_open(TEMPFILE, "w");
#else
fp = file_open(CLAN_FILE, "w");
#endif
if (!fp)
{
bug("save_clans: NULL fp", 0);
file_close(fp);
return;
}
for (i = clan_first; i; i = i->next)
{
fprintf(fp, "#CLAN\n");
save_struct(fp, &clan, clansavetable, i);
fprintf(fp, "#END\n\n");
}
fprintf(fp, "#!\n");
file_close(fp);
#if !defined(WIN32)
rename(TEMPFILE, CLAN_FILE);
#endif
}
void load_clans(void)
{
FILE *fp;
static CLAN_DATA clanzero;
CLAN_DATA *i;
const char *word;
fp = file_open(CLAN_FILE, "r");
if (!fp)
{
bug("load_clans: Unable to open " CLAN_FILE " to load clans.", 0);
exit(1);
}
for (;;)
{
word = fread_word(fp);
if (!str_cmp(word, "#!"))
break;
if (str_cmp(word, "#CLAN"))
{
bugf("word doesn't exist (%s)", word);
exit(1);
}
i = new_clan();
*i = clanzero;
load_struct(fp, &clan, clansavetable, i);
LINK(i, clan_first, clan_last, next, prev);
}
file_close(fp);
}
void save_statlist(void)
{
STAT_DATA *pstat;
FILE *fp;
#if !defined(WIN32)
const char *TEMPFILE = STAT_FILE ".tmp";
if ((fp = file_open(TEMPFILE, "w")) == NULL)
#else
if ((fp = file_open(STAT_FILE, "w")) == NULL)
#endif
{
perror(STAT_FILE);
file_close(fp);
return;
}
for (pstat = stat_first; pstat != NULL; pstat = pstat->next)
{
fprintf(fp, "#STAT\n");
save_struct(fp, &stat, statsavetable, pstat);
fprintf(fp, "#END\n\n");
}
fprintf(fp, "#!\n");
file_close(fp);
#if !defined(WIN32)
rename(TEMPFILE, STAT_FILE);
#endif
}
void load_statlist(void)
{
FILE *fp;
STAT_DATA *pstat;
const char *word;
fp = file_open(STAT_FILE, "r");
if (!fp)
return;
for (;;)
{
word = fread_word(fp);
if (!str_cmp(word, "#!"))
break;
if (str_cmp(word, "#STAT"))
{
bugf("word doesn't exist (%s)", word);
exit(1);
}
pstat = new_stat_data();
load_struct(fp, &stat, statsavetable, pstat);
LINK(pstat, stat_first, stat_last, next, prev);
}
file_close(fp);
}
void save_bans(void)
{
BAN_DATA *pban;
FILE *fp;
#if !defined(WIN32)
const char *TEMPFILE = BAN_FILE ".tmp";
if ((fp = file_open(TEMPFILE, "w")) == NULL)
#else
if ((fp = file_open(BAN_FILE, "w")) == NULL)
#endif
{
perror(BAN_FILE);
file_close(fp);
return;
}
for (pban = ban_first; pban != NULL; pban = pban->next)
{
fprintf(fp, "#BAN\n");
save_struct(fp, &ban, bansavetable, pban);
fprintf(fp, "#END\n\n");
}
fprintf(fp, "#!\n");
file_close(fp);
#if !defined(WIN32)
rename(TEMPFILE, BAN_FILE);
return;
#endif
}
void load_bans(void)
{
FILE *fp;
BAN_DATA *pban;
const char *word;
fp = file_open(BAN_FILE, "r");
if (!fp)
return;
for (;;)
{
word = fread_word(fp);
if (!str_cmp(word, "#!"))
break;
if (str_cmp(word, "#BAN"))
{
bugf("word doesn't exist (%s)", word);
exit(1);
}
pban = new_ban();
load_struct(fp, &ban, bansavetable, pban);
LINK(pban, ban_first, ban_last, next, prev);
}
file_close(fp);
}
bool save_gquest_data(void)
{
FILE *fp;
#if !defined(WIN32)
char *TEMPFILE = GQUEST_FILE ".tmp";
if (!(fp = file_open(TEMPFILE, "w")))
#else
if (!(fp = file_open(GQUEST_FILE, "w")))
#endif
{
bugf("Could not open file %s in order to save gquest data.",
GQUEST_FILE);
file_close(fp);
return FALSE;
}
fprintf(fp, "#GQUESTDATA\n");
save_struct(fp, &gq, gqsavetable, &gquest_info);
fprintf(fp, "#END\n");
fprintf(fp, "\n#!\n");
file_close(fp);
#if !defined(WIN32)
rename(TEMPFILE, GQUEST_FILE);
#endif
return TRUE;
}
bool load_gquest_data(void)
{
FILE *fp;
const char *word;
end_gquest(NULL);
if (!(fp = file_open(GQUEST_FILE, "r")))
{
bugf("Could not open file %s in order to read gquest data. Creating.",
GQUEST_FILE);
file_close(fp);
return save_gquest_data();
}
for (;;)
{
word = fread_word(fp);
if (!str_cmp(word, "#!"))
break;
if (str_cmp(word, "#GQUESTDATA"))
{
bugf("Invalid gquest data file (%s).\n\r", GQUEST_FILE);
return FALSE;
}
load_struct(fp, &gq, gqsavetable, &gquest_info);
}
file_close(fp);
return TRUE;
}
void save_deities(void)
{
FILE *fp;
DEITY_DATA *i;
#if !defined(WIN32)
char *TEMPFILE = DEITY_FILE ".tmp";
fp = file_open(TEMPFILE, "w");
#else
fp = file_open(DEITY_FILE, "w");
#endif
if (!fp)
{
bug("save_deities: NULL fp", 0);
file_close(fp);
return;
}
for (i = deity_first; i; i = i->next)
{
fprintf(fp, "#DEITY\n");
save_struct(fp, &deity, deitysavetable, i);
fprintf(fp, "#END\n\n");
}
fprintf(fp, "#!\n");
file_close(fp);
#if !defined(WIN32)
rename(TEMPFILE, DEITY_FILE);
#endif
}
void load_deities(void)
{
FILE *fp;
static DEITY_DATA deityzero;
DEITY_DATA *i;
const char *word;
fp = file_open(DEITY_FILE, "r");
if (!fp)
{
bug("load_deities: Unable to open " DEITY_FILE " to load deities.", 0);
save_deities();
return;
}
for (;;)
{
word = fread_word(fp);
if (!str_cmp(word, "#!"))
break;
if (str_cmp(word, "#DEITY"))
{
bugf("word doesn't exist (%s)", word);
exit(1);
}
i = new_deity();
*i = deityzero;
load_struct(fp, &deity, deitysavetable, i);
LINK(i, deity_first, deity_last, next, prev);
}
file_close(fp);
}
void save_webpasses(void)
{
WPWD_DATA *ppwd;
FILE *fp;
#if !defined(WIN32)
char *TEMPFILE = WPWD_FILE ".tmp";
if ((fp = file_open(TEMPFILE, "w")) == NULL)
#else
if ((fp = file_open(WPWD_FILE, "w")) == NULL)
#endif
{
perror(WPWD_FILE);
file_close(fp);
return;
}
for (ppwd = wpwd_first; ppwd != NULL; ppwd = ppwd->next)
{
fprintf(fp, "#WPWD\n");
save_struct(fp, &pwd, pwdsavetable, ppwd);
fprintf(fp, "#END\n\n");
}
fprintf(fp, "#!\n");
file_close(fp);
#if !defined(WIN32)
rename(TEMPFILE, WPWD_FILE);
#endif
}
void load_webpasses(void)
{
FILE *fp;
WPWD_DATA *ppwd;
const char *word;
fp = file_open(WPWD_FILE, "r");
if (!fp)
{
bug("Unable to open " WPWD_FILE " to load pwdlist.", 0);
save_webpasses();
file_close(fp);
return;
}
for (;;)
{
word = fread_word(fp);
if (!str_cmp(word, "#!"))
break;
if (str_cmp(word, "#WPWD"))
{
bugf("word doesn't exist (%s)", word);
exit(1);
}
ppwd = new_pwd();
load_struct(fp, &pwd, pwdsavetable, ppwd);
LINK(ppwd, wpwd_first, wpwd_last, next, prev);
}
file_close(fp);
}
void save_members(void)
{
MBR_DATA *pmbr;
FILE *fp;
#if !defined(WIN32)
char *TEMPFILE = MBR_FILE ".tmp";
if ((fp = file_open(TEMPFILE, "w")) == NULL)
#else
if ((fp = file_open(MBR_FILE, "w")) == NULL)
#endif
{
perror(MBR_FILE);
file_close(fp);
return;
}
for (pmbr = mbr_first; pmbr != NULL; pmbr = pmbr->next)
{
if (pmbr->clan == NULL)
{
bugf("%s member data invalid.", pmbr->name);
continue;
}
fprintf(fp, "#MBR\n");
save_struct(fp, &mbr, mbrsavetable, pmbr);
fprintf(fp, "#END\n\n");
}
fprintf(fp, "#!\n");
file_close(fp);
#if !defined(WIN32)
rename(TEMPFILE, MBR_FILE);
#endif
}
void load_members(void)
{
FILE *fp;
MBR_DATA *pmbr;
const char *word;
fp = file_open(MBR_FILE, "r");
if (!fp)
{
bug("Unable to open " MBR_FILE " to load members.", 0);
save_members();
return;
}
for (;;)
{
word = fread_word(fp);
if (!str_cmp(word, "#!"))
break;
if (str_cmp(word, "#MBR"))
{
bugf("word doesn't exist (%s)", word);
exit(1);
}
pmbr = new_mbr();
load_struct(fp, &mbr, mbrsavetable, pmbr);
LINK(pmbr, mbr_first, mbr_last, next, prev);
}
file_close(fp);
}