/************************************************************************** * 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 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; 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) { int *raza = (int *) temp; return race_table[*raza].name; } 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 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}, {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} }; 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; 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); if ((*pentero = flag_value (flagtable, string)) == NO_FLAG) *pentero = 0; 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); if ((*pint = flag_value (flagtable, string)) == NO_FLAG) *pint = 0; 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_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; 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) ? "" : *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]) ? 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]) ? 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_INUTIL: break; } cnt++; } }; void save_commands (void) { FILE *fp; int i; #if !defined(WIN32) const char *TEMPFILE = DATA_DIR "commands_tmp"; fp = file_open (TEMPFILE, "w"); #else fp = file_open (COMMAND_FILE, "w"); #endif if (!fp) { perror ("save_commands"); file_close (fp); return; } fprintf (fp, "%d\n\n", maxCommands); for (i = 0; i < maxCommands; ++i) { fprintf (fp, "#COMMAND\n"); save_struct (fp, &cmd, cmdsavetable, &cmd_table[i]); fprintf (fp, "#END\n\n"); } file_close (fp); #if !defined(WIN32) rename (TEMPFILE, COMMAND_FILE); #endif } void load_commands (void) { FILE *fp; static CMD_DATA emptycmd; int i = 0, largo; const char *word; fp = file_open (COMMAND_FILE, "r"); if (fp == NULL) { perror ("load_commands "); file_close (fp); return; } largo = fread_number (fp); maxCommands = largo; alloc_mem (cmd_table, CMD_DATA, largo + 1); for (i = 0; i <= largo; i++) cmd_table[i] = emptycmd; i = 0; while (TRUE) { word = fread_word (fp); if (str_cmp (word, "#COMMAND")) { bugf ("word %s", word); file_close (fp); return; } load_struct (fp, &cmd, cmdsavetable, &cmd_table[i++]); if (i == largo) { file_close (fp); cmd_table[i].name = str_dup (str_empty); return; } } } void save_skills (void) { FILE *fp; int i; #if !defined(WIN32) const char *TEMPFILE = DATA_DIR "skills_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; int cnt = 0; #if !defined(WIN32) const char *TEMPFILE = DATA_DIR "races_tmp"; fp = file_open (TEMPFILE, "w"); #else fp = file_open (RACE_FILE, "w"); #endif if (!fp) { perror ("save_races : fopen"); return; } for (temp = race_table; !IS_NULLSTR (temp->name); temp = temp++) { cnt++; } fprintf (fp, "%d\n", cnt); for (temp = race_table; !IS_NULLSTR (temp->name); temp = temp++) { fprintf (fp, "#RACE\n"); save_struct (fp, &race, racesavetable, temp); fprintf (fp, "#END\n\n"); } file_close (fp); #if !defined(WIN32) rename (TEMPFILE, RACE_FILE); #endif } void load_races (void) { FILE *fp; const char *word; int i; fp = file_open (RACE_FILE, "r"); if (!fp) { perror ("load_races"); return; } maxRace = fread_number (fp); alloc_mem (race_table, RACE_DATA, maxRace + 1); i = 0; while (TRUE) { word = fread_word (fp); if (str_cmp (word, "#RACE")) { bugf ("word %s", word); file_close (fp); return; } load_struct (fp, &race, racesavetable, &race_table[i++]); if (i == maxRace) { file_close (fp); race_table[i].name = NULL; return; } } } void save_groups (void) { FILE *fp; int i; #if !defined(WIN32) const char *TEMPFILE = DATA_DIR "groups_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 = DATA_DIR "class_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; int i; #if !defined(WIN32) const char *TEMPFILE = DATA_DIR "social_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; } fprintf (fp, "%d\n", maxSocial); for (i = 0; i < maxSocial; ++i) { fprintf (fp, "#SOCIAL\n"); save_struct (fp, &soc, socialsavetable, &social_table[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; int i = 0; 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); } fscanf (fp, "%d\n", &maxSocial); alloc_mem (social_table, SOCIAL_DATA, maxSocial + 1); if (!social_table) { bugf ("Error! Social_table == NULL, MAX_SOCIAL : %d", maxSocial); 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); } if (i >= maxSocial) { bug ("load_socials: number greater than maxSocial", 0); exit (1); } social_table[i] = socialzero; load_struct (fp, &soc, socialsavetable, &social_table[i++]); } social_table[maxSocial].name = NULL; file_close (fp); } void save_clans (void) { FILE *fp; int i; #if !defined(WIN32) const char *TEMPFILE = DATA_DIR "clan_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; } fprintf (fp, "%d\n", maxClan); for (i = 0; i < maxClan; ++i) { fprintf (fp, "#CLAN\n"); save_struct (fp, &clan, clansavetable, &clan_table[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; int i = 0; 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); } fscanf (fp, "%d\n", &maxClan); alloc_mem (clan_table, CLAN_DATA, maxClan + 1); if (!clan_table) { bugf ("Error! Clan_table == NULL, MAX_CLAN : %d", maxClan); 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); } if (i >= maxClan) { bug ("load_clans: number greater than maxClan", 0); exit (1); } clan_table[i] = clanzero; load_struct (fp, &clan, clansavetable, &clan_table[i++]); } clan_table[maxClan].name = NULL; file_close (fp); } void save_statlist (void) { STAT_DATA *pstat; FILE *fp; #if !defined(WIN32) const char *TEMPFILE = DATA_DIR "stats_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_list; 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); pstat->next = stat_list; stat_list = pstat; } file_close (fp); } void save_bans (void) { BAN_DATA *pban; FILE *fp; #if !defined(WIN32) const char *TEMPFILE = DATA_DIR "ban_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_list; 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); pban->next = ban_list; ban_list = pban; } file_close (fp); }