/**************************************************************************
* 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> *
***************************************************************************/
/**************************************************************************
* File: olc_save.c *
* *
* Much time and thought has gone into this software and you are *
* benefitting. We hope that you share your changes too. What goes *
* around, comes around. *
* *
* This code was freely distributed with the The Isles 1.1 source code, *
* and has been used here for OLC - OLC would not be what it is without *
* all the previous coders who released their source code. *
* *
***************************************************************************/
/* OLC_SAVE.C
* This takes care of saving all the .are information.
* Notes:
* -If a good syntax checker is used for setting vnum ranges of areas
* then it would become possible to just cycle through vnums instead
* of using the iHash stuff and checking that the room or reset or
* mob etc is part of that area.
*/
#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 "olc.h"
#include "interp.h"
#define DIF(a,b) (~((~a)|(b)))
/*
* Verbose writes reset data in plain english into the comments
* section of the resets. It makes areas considerably larger but
* may aid in debugging.
*/
/* #define VERBOSE */
/*****************************************************************************
Name: fix_string
Purpose: Returns a string without \r and ~.
****************************************************************************/
char *fix_string(const char *str)
{
static char strfix[MAX_STRING_LENGTH * 2];
int i;
int o;
if (str == NULL || !str_cmp(str, "(null)"))
return '\0';
for (o = i = 0; str[i + o] != '\0'; i++)
{
if (str[i + o] == '\r' || str[i + o] == '~')
o++;
strfix[i] = str[i + o];
}
strfix[i] = '\0';
return strfix;
}
/*****************************************************************************
Name: save_area_list
Purpose: Saves the listing of files to be loaded at startup.
Called by: do_asave(olc_save.c).
****************************************************************************/
void save_area_list()
{
FILE *fp;
AREA_DATA *pArea;
if ((fp = file_open("area.lst", "w")) == NULL)
{
bug("Save_area_list: file_open", 0);
perror("area.lst");
}
else
{
fprintf(fp, "%s\n", HELP_FILE);
for (pArea = area_first; pArea; pArea = pArea->next)
{
fprintf(fp, "%s\n", pArea->file_name);
}
fprintf(fp, "$\n");
file_close(fp);
}
return;
}
#define NBUF 5
#define NBITS 52
char *fwrite_flags(flag_t flags)
{
static int cnt;
static char buf[NBUF][NBITS + 1];
flag_t count = 0, temp = 1;
cnt = (cnt + 1) % NBUF;
buf[cnt][0] = '+';
do
{
if (IS_SET(flags, (temp << count)))
buf[cnt][count + 1] = 'Y';
else
buf[cnt][count + 1] = 'n';
count++;
}
while ((temp << count) <= flags && count < 64);
buf[cnt][count + 1] = '\0';
return buf[cnt];
}
void save_mobprogs(FILE * fp, AREA_DATA * pArea)
{
PROG_CODE *pMprog;
vnum_t i;
fprintf(fp, "#MOBPROGS\n");
for (i = pArea->min_vnum; i <= pArea->max_vnum; i++)
{
if ((pMprog = get_prog_index(i, PRG_MPROG)) != NULL)
{
fprintf(fp, "#%ld\n", i);
fprintf(fp, "%s~\n", fix_string(pMprog->code));
}
}
fprintf(fp, "#0\n\n");
return;
}
void save_objprogs(FILE * fp, AREA_DATA * pArea)
{
PROG_CODE *pOprog;
vnum_t i;
fprintf(fp, "#OBJPROGS\n");
for (i = pArea->min_vnum; i <= pArea->max_vnum; i++)
{
if ((pOprog = get_prog_index(i, PRG_OPROG)) != NULL)
{
fprintf(fp, "#%ld\n", i);
fprintf(fp, "%s~\n", fix_string(pOprog->code));
}
}
fprintf(fp, "#0\n\n");
return;
}
void save_roomprogs(FILE * fp, AREA_DATA * pArea)
{
PROG_CODE *pRprog;
vnum_t i;
fprintf(fp, "#ROOMPROGS\n");
for (i = pArea->min_vnum; i <= pArea->max_vnum; i++)
{
if ((pRprog = get_prog_index(i, PRG_RPROG)) != NULL)
{
fprintf(fp, "#%ld\n", i);
fprintf(fp, "%s~\n", fix_string(pRprog->code));
}
}
fprintf(fp, "#0\n\n");
return;
}
/*****************************************************************************
Name: save_mobile
Purpose: Save one mobile to file, new format -- Hugin
Called by: save_mobiles (below).
****************************************************************************/
void save_mobile(FILE * fp, MOB_INDEX_DATA * pMobIndex)
{
RACE_DATA *race = pMobIndex->race;
PROG_LIST *pMprog;
flag_t temp;
fprintf(fp, "#%ld\n", pMobIndex->vnum);
fprintf(fp, "%s~\n", pMobIndex->player_name);
fprintf(fp, "%s~\n", pMobIndex->short_descr);
fprintf(fp, "%s~\n", fix_string(pMobIndex->long_descr));
fprintf(fp, "%s~\n", fix_string(pMobIndex->description));
fprintf(fp, "%s~\n", race->name);
fprintf(fp, "%s ", fwrite_flags(pMobIndex->act));
fprintf(fp, "%s ", fwrite_flags(pMobIndex->affected_by));
fprintf(fp, "%d %ld\n", pMobIndex->alignment, pMobIndex->group);
fprintf(fp, "%d ", pMobIndex->level);
fprintf(fp, "%d ", pMobIndex->hitroll);
fprintf(fp, "%dd%d+%d ", pMobIndex->hit[DICE_NUMBER],
pMobIndex->hit[DICE_TYPE], pMobIndex->hit[DICE_BONUS]);
fprintf(fp, "%dd%d+%d ", pMobIndex->mana[DICE_NUMBER],
pMobIndex->mana[DICE_TYPE], pMobIndex->mana[DICE_BONUS]);
fprintf(fp, "%dd%d+%d ", pMobIndex->damage[DICE_NUMBER],
pMobIndex->damage[DICE_TYPE], pMobIndex->damage[DICE_BONUS]);
fprintf(fp, "%s\n", attack_table[pMobIndex->dam_type].name);
fprintf(fp, "%d %d %d %d\n", pMobIndex->ac[AC_PIERCE] / 10,
pMobIndex->ac[AC_BASH] / 10, pMobIndex->ac[AC_SLASH] / 10,
pMobIndex->ac[AC_EXOTIC] / 10);
fprintf(fp, "%s ", fwrite_flags(pMobIndex->off_flags));
fprintf(fp, "%s ", fwrite_flags(pMobIndex->imm_flags));
fprintf(fp, "%s ", fwrite_flags(pMobIndex->res_flags));
fprintf(fp, "%s\n", fwrite_flags(pMobIndex->vuln_flags));
fprintf(fp, "%s %s %s %ld\n",
position_table[pMobIndex->start_pos].short_name,
position_table[pMobIndex->default_pos].short_name,
sex_table[pMobIndex->sex].name, pMobIndex->wealth);
fprintf(fp, "%s ", fwrite_flags(pMobIndex->form));
fprintf(fp, "%s ", fwrite_flags(pMobIndex->parts));
fprintf(fp, "%s ", size_table[pMobIndex->size].name);
fprintf(fp, "%s\n",
IS_NULLSTR(pMobIndex->material) ? pMobIndex->material : "unknown");
if ((temp = DIF(race->act, pMobIndex->act)))
fprintf(fp, "F act %s\n", fwrite_flags(temp));
if ((temp = DIF(race->aff, pMobIndex->affected_by)))
fprintf(fp, "F aff %s\n", fwrite_flags(temp));
if ((temp = DIF(race->off, pMobIndex->off_flags)))
fprintf(fp, "F off %s\n", fwrite_flags(temp));
if ((temp = DIF(race->imm, pMobIndex->imm_flags)))
fprintf(fp, "F imm %s\n", fwrite_flags(temp));
if ((temp = DIF(race->res, pMobIndex->res_flags)))
fprintf(fp, "F res %s\n", fwrite_flags(temp));
if ((temp = DIF(race->vuln, pMobIndex->vuln_flags)))
fprintf(fp, "F vul %s\n", fwrite_flags(temp));
if ((temp = DIF(race->form, pMobIndex->form)))
fprintf(fp, "F for %s\n", fwrite_flags(temp));
if ((temp = DIF(race->parts, pMobIndex->parts)))
fprintf(fp, "F par %s\n", fwrite_flags(temp));
for (pMprog = pMobIndex->first_mprog; pMprog; pMprog = pMprog->next)
{
fprintf(fp, "M %s %ld %s~\n",
prog_type_to_name(pMprog->trig_type), pMprog->vnum,
pMprog->trig_phrase);
}
return;
}
/*****************************************************************************
Name: save_mobiles
Purpose: Save #MOBILES secion of an area file.
Called by: save_area(olc_save.c).
Notes: Changed for ROM OLC.
****************************************************************************/
void save_mobiles(FILE * fp, AREA_DATA * pArea)
{
vnum_t i;
MOB_INDEX_DATA *pMob;
fprintf(fp, "#MOBILES\n");
for (i = pArea->min_vnum; i <= pArea->max_vnum; i++)
{
if ((pMob = get_mob_index(i)))
save_mobile(fp, pMob);
}
fprintf(fp, "#0\n\n\n\n");
return;
}
/*****************************************************************************
Name: save_object
Purpose: Save one object to file.
new ROM format saving -- Hugin
Called by: save_objects (below).
****************************************************************************/
void save_object(FILE * fp, OBJ_INDEX_DATA * pObjIndex)
{
char letter;
AFFECT_DATA *pAf;
EXTRA_DESCR_DATA *pEd;
PROG_LIST *pOprog;
fprintf(fp, "#%ld\n", pObjIndex->vnum);
fprintf(fp, "%s~\n", pObjIndex->name);
fprintf(fp, "%s~\n", pObjIndex->short_descr);
fprintf(fp, "%s~\n", fix_string(pObjIndex->description));
fprintf(fp, "%s~\n", pObjIndex->material);
fprintf(fp, "%s ", item_name(pObjIndex->item_type));
fprintf(fp, "%s ", fwrite_flags(pObjIndex->extra_flags));
fprintf(fp, "%s\n", fwrite_flags(pObjIndex->wear_flags));
/*
* Using fwrite_flag to write most values gives a strange
* looking area file, consider making a case for each
* item type later.
*/
switch (pObjIndex->item_type)
{
default:
fprintf(fp, "%s ", fwrite_flags(pObjIndex->value[0]));
fprintf(fp, "%s ", fwrite_flags(pObjIndex->value[1]));
fprintf(fp, "%s ", fwrite_flags(pObjIndex->value[2]));
fprintf(fp, "%s ", fwrite_flags(pObjIndex->value[3]));
fprintf(fp, "%s\n", fwrite_flags(pObjIndex->value[4]));
break;
case ITEM_DRINK_CON:
case ITEM_FOUNTAIN:
fprintf(fp, "%ld %ld '%s' %ld %ld\n", pObjIndex->value[0],
pObjIndex->value[1],
liq_table[pObjIndex->value[2]].liq_name,
pObjIndex->value[3], pObjIndex->value[4]);
break;
case ITEM_CONTAINER:
fprintf(fp, "%ld %s %ld %ld %ld\n", pObjIndex->value[0],
fwrite_flags(pObjIndex->value[1]),
pObjIndex->value[2], pObjIndex->value[3], pObjIndex->value[4]);
break;
case ITEM_WEAPON:
fprintf(fp, "%s %ld %ld %s %s\n",
weapon_name(pObjIndex->value[0]),
pObjIndex->value[1], pObjIndex->value[2],
attack_table[pObjIndex->value[3]].name,
fwrite_flags(pObjIndex->value[4]));
break;
case ITEM_PILL:
case ITEM_POTION:
case ITEM_SCROLL:
fprintf(fp, "%ld '%s' '%s' '%s' '%s'\n", pObjIndex->value[0] > 0 ? /* no negative numbers */
pObjIndex->value[0] : 0,
pObjIndex->value[1] !=
-1 ? skill_table[pObjIndex->value[1]].name : "",
pObjIndex->value[2] !=
-1 ? skill_table[pObjIndex->value[2]].name : "",
pObjIndex->value[3] !=
-1 ? skill_table[pObjIndex->value[3]].name : "",
pObjIndex->value[4] !=
-1 ? skill_table[pObjIndex->value[4]].name : "");
break;
case ITEM_STAFF:
case ITEM_WAND:
fprintf(fp, "%ld %ld %ld '%s' %ld\n", pObjIndex->value[0],
pObjIndex->value[1], pObjIndex->value[2],
pObjIndex->value[3] !=
-1 ? skill_table[pObjIndex->value[3]].name : "",
pObjIndex->value[4]);
break;
}
fprintf(fp, "%d ", pObjIndex->level);
fprintf(fp, "%d ", pObjIndex->weight);
fprintf(fp, "%d ", pObjIndex->cost);
if (pObjIndex->condition > 90)
letter = 'P';
else if (pObjIndex->condition > 75)
letter = 'G';
else if (pObjIndex->condition > 50)
letter = 'A';
else if (pObjIndex->condition > 25)
letter = 'W';
else if (pObjIndex->condition > 10)
letter = 'D';
else if (pObjIndex->condition > 0)
letter = 'B';
else
letter = 'R';
fprintf(fp, "%c\n", letter);
for (pAf = pObjIndex->first_affect; pAf; pAf = pAf->next)
{
if (pAf->where == TO_OBJECT || pAf->bitvector == 0)
fprintf(fp, "A\n%d %d\n", pAf->location, pAf->modifier);
else
{
fprintf(fp, "F\n");
switch (pAf->where)
{
case TO_AFFECTS:
fprintf(fp, "A ");
break;
case TO_IMMUNE:
fprintf(fp, "I ");
break;
case TO_RESIST:
fprintf(fp, "R ");
break;
case TO_VULN:
fprintf(fp, "V ");
break;
default:
bug("olc_save: Invalid Affect->where", 0);
break;
}
fprintf(fp, "%d %d %s\n", pAf->location, pAf->modifier,
fwrite_flags(pAf->bitvector));
}
}
for (pEd = pObjIndex->first_extra_descr; pEd; pEd = pEd->next)
{
fprintf(fp, "E\n%s~\n%s~\n", pEd->keyword,
fix_string(pEd->description));
}
for (pOprog = pObjIndex->first_oprog; pOprog; pOprog = pOprog->next)
{
fprintf(fp, "O %s %ld %s~\n",
prog_type_to_name(pOprog->trig_type), pOprog->vnum,
pOprog->trig_phrase);
}
return;
}
/*****************************************************************************
Name: save_objects
Purpose: Save #OBJECTS section of an area file.
Called by: save_area(olc_save.c).
Notes: Changed for ROM OLC.
****************************************************************************/
void save_objects(FILE * fp, AREA_DATA * pArea)
{
vnum_t i;
OBJ_INDEX_DATA *pObj;
fprintf(fp, "#OBJECTS\n");
for (i = pArea->min_vnum; i <= pArea->max_vnum; i++)
{
if ((pObj = get_obj_index(i)))
save_object(fp, pObj);
}
fprintf(fp, "#0\n\n\n\n");
return;
}
/*****************************************************************************
Name: save_rooms
Purpose: Save #ROOMS section of an area file.
Called by: save_area(olc_save.c).
****************************************************************************/
void save_rooms(FILE * fp, AREA_DATA * pArea)
{
ROOM_INDEX_DATA *pRoomIndex;
EXTRA_DESCR_DATA *pEd;
EXIT_DATA *pExit;
int iHash;
int door;
PROG_LIST *pRprog;
fprintf(fp, "#ROOMS\n");
for (iHash = 0; iHash < MAX_KEY_HASH; iHash++)
{
for (pRoomIndex = room_index_hash[iHash]; pRoomIndex;
pRoomIndex = pRoomIndex->next)
{
if (pRoomIndex->area == pArea)
{
fprintf(fp, "#%ld\n", pRoomIndex->vnum);
fprintf(fp, "%s~\n", pRoomIndex->name);
fprintf(fp, "%s~\n", fix_string(pRoomIndex->description));
fprintf(fp, "0 ");
fprintf(fp, "%s ", fwrite_flags(pRoomIndex->room_flags));
fprintf(fp, "%d\n", pRoomIndex->sector_type);
for (pEd = pRoomIndex->first_extra_descr; pEd; pEd = pEd->next)
{
fprintf(fp, "E\n%s~\n%s~\n",
pEd->keyword, fix_string(pEd->description));
}
for (door = 0; door < MAX_DIR; door++) /* I hate this! */
{
if ((pExit = pRoomIndex->exit[door]) && pExit->u1.to_room)
{
int locks = 0;
/* HACK : TO PREVENT EX_LOCKED etc without EX_ISDOOR
to stop booting the mud */
if (IS_SET
(pExit->rs_flags, EX_CLOSED)
|| IS_SET(pExit->rs_flags,
EX_LOCKED)
|| IS_SET(pExit->rs_flags,
EX_PICKPROOF)
|| IS_SET(pExit->rs_flags,
EX_NOPASS)
|| IS_SET(pExit->rs_flags,
EX_EASY)
|| IS_SET(pExit->rs_flags,
EX_HARD)
|| IS_SET(pExit->rs_flags,
EX_INFURIATING)
|| IS_SET(pExit->rs_flags,
EX_NOCLOSE)
|| IS_SET(pExit->rs_flags, EX_NOLOCK))
SET_BIT(pExit->rs_flags, EX_ISDOOR);
else
REMOVE_BIT(pExit->rs_flags, EX_ISDOOR);
/* THIS SUCKS but it's backwards compatible */
/* NOTE THAT EX_NOCLOSE NOLOCK etc aren't being saved */
if (IS_SET
(pExit->rs_flags, EX_ISDOOR)
&&
(!IS_SET
(pExit->rs_flags,
EX_PICKPROOF))
&& (!IS_SET(pExit->rs_flags, EX_NOPASS)))
locks = 1;
if (IS_SET
(pExit->rs_flags, EX_ISDOOR)
&&
(IS_SET
(pExit->rs_flags,
EX_PICKPROOF))
&& (!IS_SET(pExit->rs_flags, EX_NOPASS)))
locks = 2;
if (IS_SET
(pExit->rs_flags, EX_ISDOOR)
&&
(!IS_SET
(pExit->rs_flags,
EX_PICKPROOF))
&& (IS_SET(pExit->rs_flags, EX_NOPASS)))
locks = 3;
if (IS_SET
(pExit->rs_flags, EX_ISDOOR)
&&
(IS_SET
(pExit->rs_flags,
EX_PICKPROOF))
&& (IS_SET(pExit->rs_flags, EX_NOPASS)))
locks = 4;
fprintf(fp, "D%d\n", pExit->orig_door);
fprintf(fp, "%s~\n", fix_string(pExit->description));
fprintf(fp, "%s~\n", pExit->keyword);
fprintf(fp, "%d %ld %ld\n",
locks, pExit->key, pExit->u1.to_room->vnum);
}
}
if (pRoomIndex->mana_rate != 100 ||
pRoomIndex->heal_rate != 100)
fprintf(fp, "M %d H %d\n",
pRoomIndex->mana_rate, pRoomIndex->heal_rate);
if (pRoomIndex->clan != NULL)
fprintf(fp, "C %s~\n", pRoomIndex->clan->name);
if (!IS_NULLSTR(pRoomIndex->owner))
fprintf(fp, "O %s~\n", pRoomIndex->owner);
for (pRprog = pRoomIndex->first_rprog; pRprog;
pRprog = pRprog->next)
{
fprintf(fp, "R %s %ld %s~\n",
prog_type_to_name(pRprog->trig_type), pRprog->vnum,
pRprog->trig_phrase);
}
fprintf(fp, "S\n");
}
}
}
fprintf(fp, "#0\n\n\n\n");
return;
}
/*****************************************************************************
Name: save_specials
Purpose: Save #SPECIALS section of area file.
Called by: save_area(olc_save.c).
****************************************************************************/
void save_specials(FILE * fp, AREA_DATA * pArea)
{
int iHash;
MOB_INDEX_DATA *pMobIndex;
fprintf(fp, "#SPECIALS\n");
for (iHash = 0; iHash < MAX_KEY_HASH; iHash++)
{
for (pMobIndex = mob_index_hash[iHash]; pMobIndex;
pMobIndex = pMobIndex->next)
{
if (pMobIndex && pMobIndex->area == pArea && pMobIndex->spec_fun)
{
#if defined( VERBOSE )
fprintf(fp, "M %d %s Load to: %s\n",
pMobIndex->vnum,
spec_name(pMobIndex->spec_fun), pMobIndex->short_descr);
#else
fprintf(fp, "M %ld %s\n", pMobIndex->vnum,
spec_name(pMobIndex->spec_fun));
#endif
}
}
}
fprintf(fp, "S\n\n\n\n");
return;
}
/*
* This function is obsolete. It it not needed but has been left here
* for historical reasons. It is used currently for the same reason.
*
* I don't think it's obsolete in ROM -- Hugin.
*/
void save_door_resets(FILE * fp, AREA_DATA * pArea)
{
int iHash;
ROOM_INDEX_DATA *pRoomIndex;
EXIT_DATA *pExit;
int door;
for (iHash = 0; iHash < MAX_KEY_HASH; iHash++)
{
for (pRoomIndex = room_index_hash[iHash]; pRoomIndex;
pRoomIndex = pRoomIndex->next)
{
if (pRoomIndex->area == pArea)
{
for (door = 0; door < MAX_DIR; door++)
{
if ((pExit = pRoomIndex->exit[door]) &&
pExit->u1.to_room &&
(IS_SET(pExit->rs_flags, EX_CLOSED)
|| IS_SET(pExit->rs_flags, EX_LOCKED)))
#if defined( VERBOSE )
fprintf(fp,
"D 0 %d %d %d The %s door of %s is %s\n",
pRoomIndex->vnum,
pExit->orig_door,
IS_SET(pExit->rs_flags,
EX_LOCKED) ? 2 : 1,
dir_name[pExit->orig_door],
pRoomIndex->name,
IS_SET(pExit->rs_flags,
EX_LOCKED) ?
"closed and locked" : "closed");
#endif
#if !defined( VERBOSE )
fprintf(fp, "D 0 %ld %d %d\n",
pRoomIndex->vnum,
pExit->orig_door,
IS_SET(pExit->rs_flags, EX_LOCKED) ? 2 : 1);
#endif
}
}
}
}
return;
}
/*****************************************************************************
Name: save_resets
Purpose: Saves the #RESETS section of an area file.
Called by: save_area(olc_save.c)
****************************************************************************/
void save_resets(FILE * fp, AREA_DATA * pArea)
{
RESET_DATA *pReset;
MOB_INDEX_DATA *pLastMob = NULL;
OBJ_INDEX_DATA *pLastObj;
ROOM_INDEX_DATA *pRoom;
char buf[MAX_STRING_LENGTH];
int iHash;
fprintf(fp, "#RESETS\n");
save_door_resets(fp, pArea);
for (iHash = 0; iHash < MAX_KEY_HASH; iHash++)
{
for (pRoom = room_index_hash[iHash]; pRoom; pRoom = pRoom->next)
{
if (pRoom->area == pArea)
{
for (pReset = pRoom->reset_first; pReset; pReset = pReset->next)
{
switch (pReset->command)
{
default:
bug("Save_resets: bad command %c.", pReset->command);
break;
#if defined( VERBOSE )
case 'M':
pLastMob = get_mob_index(pReset->arg1);
fprintf(fp,
"M 0 %ld %d %ld %d Load %s\n",
pReset->arg1,
pReset->arg2,
pReset->arg3,
pReset->arg4, pLastMob->short_descr);
break;
case 'O':
pLastObj = get_obj_index(pReset->arg1);
pRoom = get_room_index(pReset->arg3);
fprintf(fp,
"O 0 %ld 0 %ld %s loaded to %s\n",
pReset->arg1,
pReset->arg3,
capitalize(pLastObj->short_descr), pRoom->name);
break;
case 'P':
pLastObj = get_obj_index(pReset->arg1);
fprintf(fp,
"P 0 %ld %d %ld %d %s put inside %s\n",
pReset->arg1,
pReset->arg2,
pReset->arg3,
pReset->arg4,
capitalize(get_obj_index
(pReset->arg1)->short_descr),
pLastObj->short_descr);
break;
case 'G':
fprintf(fp,
"G 0 %ld 0 %s is given to %s\n",
pReset->arg1,
capitalize(get_obj_index
(pReset->arg1)->short_descr),
pLastMob ? pLastMob->short_descr : "!NO_MOB!");
if (!pLastMob)
{
sprintf(buf,
"Save_resets: !NO_MOB! in [%s]",
pArea->file_name);
bug(buf, 0);
}
break;
case 'E':
fprintf(fp,
"E 0 %ld 0 %ld %s is loaded %s of %s\n",
pReset->arg1,
pReset->arg3,
capitalize(get_obj_index
(pReset->arg1)->short_descr),
flag_string
(wear_loc_strings,
pReset->arg3),
pLastMob ? pLastMob->short_descr : "!NO_MOB!");
if (!pLastMob)
{
sprintf(buf,
"Save_resets: !NO_MOB! in [%s]",
pArea->file_name);
bug(buf, 0);
}
break;
case 'D':
break;
case 'R':
pRoom = get_room_index(pReset->arg1);
fprintf(fp,
"R 0 %ld %d Randomize %s\n",
pReset->arg1, pReset->arg2, pRoom->name);
break;
#endif
#if !defined( VERBOSE )
case 'M':
pLastMob = get_mob_index(pReset->arg1);
fprintf(fp,
"M 0 %ld %d %ld %d\n",
pReset->arg1,
pReset->arg2, pReset->arg3, pReset->arg4);
break;
case 'O':
pLastObj = get_obj_index(pReset->arg1);
pRoom = get_room_index(pReset->arg3);
fprintf(fp, "O 0 %ld 0 %ld\n",
pReset->arg1, pReset->arg3);
break;
case 'P':
pLastObj = get_obj_index(pReset->arg1);
fprintf(fp,
"P 0 %ld %d %ld %d\n",
pReset->arg1,
pReset->arg2, pReset->arg3, pReset->arg4);
break;
case 'G':
fprintf(fp, "G 0 %ld 0\n", pReset->arg1);
if (!pLastMob)
{
sprintf(buf,
"Save_resets: !NO_MOB! in [%s]",
pArea->file_name);
bug(buf, 0);
}
break;
case 'E':
fprintf(fp, "E 0 %ld 0 %ld\n",
pReset->arg1, pReset->arg3);
if (!pLastMob)
{
sprintf(buf,
"Save_resets: !NO_MOB! in [%s]",
pArea->file_name);
bug(buf, 0);
}
break;
case 'D':
break;
case 'R':
pRoom = get_room_index(pReset->arg1);
fprintf(fp, "R 0 %ld %d\n", pReset->arg1, pReset->arg2);
break;
#endif
}
}
} /* End if correct area */
} /* End for pRoom */
} /* End for iHash */
fprintf(fp, "S\n\n\n\n");
return;
}
/*****************************************************************************
Name: save_shops
Purpose: Saves the #SHOPS section of an area file.
Called by: save_area(olc_save.c)
****************************************************************************/
void save_shops(FILE * fp, AREA_DATA * pArea)
{
SHOP_DATA *pShopIndex;
MOB_INDEX_DATA *pMobIndex;
int iTrade;
int iHash;
fprintf(fp, "#SHOPS\n");
for (iHash = 0; iHash < MAX_KEY_HASH; iHash++)
{
for (pMobIndex = mob_index_hash[iHash]; pMobIndex;
pMobIndex = pMobIndex->next)
{
if (pMobIndex && pMobIndex->area == pArea && pMobIndex->pShop)
{
pShopIndex = pMobIndex->pShop;
fprintf(fp, "%ld ", pShopIndex->keeper);
for (iTrade = 0; iTrade < MAX_TRADE; iTrade++)
{
if (pShopIndex->buy_type[iTrade] != 0)
{
fprintf(fp, "%d ", pShopIndex->buy_type[iTrade]);
}
else
fprintf(fp, "0 ");
}
fprintf(fp, "%d %d ", pShopIndex->profit_buy,
pShopIndex->profit_sell);
fprintf(fp, "%d %d\n", pShopIndex->open_hour,
pShopIndex->close_hour);
}
}
}
fprintf(fp, "0\n\n\n\n");
return;
}
void save_helps(void)
{
HELP_DATA *help;
FILE *fp;
#if !defined(WIN32)
char *TEMPFILE = HELP_FILE ".tmp";
if ((fp = file_open(TEMPFILE, "w")) != NULL)
#else
if ((fp = file_open(HELP_FILE, "w")) != NULL)
#endif
{
fprintf(fp, "#HELPS\n");
for (help = help_first; help; help = help->next)
{
fprintf(fp, "%d %s~\n", help->level, help->keyword);
fprintf(fp, "%s~\n\n", fix_string(help->text));
}
fprintf(fp, "-1 $~\n\n");
fprintf(fp, "#$\n");
}
else
bug("Error opening " HELP_FILE ".", 0);
file_close(fp);
#if !defined(WIN32)
rename(TEMPFILE, HELP_FILE);
#endif
return;
}
/*****************************************************************************
Name: save_area
Purpose: Save an area, note that this format is new.
Called by: do_asave(olc_save.c).
****************************************************************************/
void save_area(AREA_DATA * pArea)
{
FILE *fp;
if (!(fp = file_open(pArea->file_name, "w")))
{
bug("Open_area: file_open", 0);
perror(pArea->file_name);
}
REMOVE_BIT(pArea->area_flags, AREA_CHANGED);
fprintf(fp, "#AREADATA\n");
fprintf(fp, "Name %s~\n", pArea->name);
fprintf(fp, "Builders %s~\n", fix_string(pArea->builders));
fprintf(fp, "VNUMs %ld %ld\n", pArea->min_vnum, pArea->max_vnum);
fprintf(fp, "Credits %s~\n", pArea->credits);
fprintf(fp, "Security %d\n", pArea->security);
fprintf(fp, "Flags %s\n", fwrite_flags(pArea->area_flags));
fprintf(fp, "End\n\n\n\n");
save_mobiles(fp, pArea);
save_objects(fp, pArea);
save_rooms(fp, pArea);
save_specials(fp, pArea);
save_resets(fp, pArea);
save_shops(fp, pArea);
save_mobprogs(fp, pArea);
save_objprogs(fp, pArea);
save_roomprogs(fp, pArea);
fprintf(fp, "#$\n");
file_close(fp);
return;
}
/*****************************************************************************
Name: do_asave
Purpose: Entry point for saving area data.
Called by: interpreter(interp.c)
****************************************************************************/
CH_CMD(do_asave)
{
char arg1[MAX_INPUT_LENGTH];
AREA_DATA *pArea;
FILE *fp;
int value, sec;
fp = NULL;
if (!ch) /* Do an autosave */
sec = 9;
else if (!IS_NPC(ch))
sec = ch->pcdata->security;
else
sec = 0;
/* {
save_area_list();
for( pArea = area_first; pArea; pArea = pArea->next )
{
save_area( pArea );
REMOVE_BIT( pArea->area_flags, AREA_CHANGED );
}
return;
} */
smash_tilde(argument);
strcpy(arg1, argument);
if (arg1[0] == '\0')
{
if (ch)
{
chprintln(ch, "Syntax:");
chprintln(ch, " asave <vnum> - saves a particular area");
chprintln(ch, " asave list - saves the area.lst file");
chprintln(ch, " asave area - saves the area being edited");
chprintln(ch, " asave changed - saves all changed zones");
chprintln(ch, " asave world - saves the world! (db dump)");
chprintln(ch, " asave clans - saves clan data");
chprintln(ch, " asave commands - saves command data");
chprintln(ch, " asave skills - saves skill data");
chprintln(ch, " asave groups - saves group data");
chprintln(ch, " asave races - saves race data");
chprintln(ch, " asave classes - saves class data");
chprintln(ch, " asave socials - saves social data");
chprintln(ch, " asave helps - saves the help file");
chprintln(ch, " asave deity - save deity data");
chprintln(ch, "");
}
return;
}
/* Snarf the value (which need not be numeric). */
value = atoi(arg1);
if (!(pArea = get_area_data(value)) && is_number(arg1))
{
if (ch)
chprintln(ch, "That area does not exist.");
return;
}
/* Save area of given vnum. */
/* ------------------------ */
if (is_number(arg1))
{
if (ch && !IS_BUILDER(ch, pArea))
{
chprintln(ch, "You are not a builder for this area.");
return;
}
save_area_list();
save_area(pArea);
return;
}
/* Save the world, only authorized areas. */
/* -------------------------------------- */
if (!str_cmp("world", arg1))
{
save_area_list();
for (pArea = area_first; pArea; pArea = pArea->next)
{
/* Builder must be assigned this area. */
if (ch && !IS_BUILDER(ch, pArea))
continue;
save_area(pArea);
REMOVE_BIT(pArea->area_flags, AREA_CHANGED);
}
if (ch)
chprintln(ch, "You saved the world.");
save_helps();
return;
}
/* Save changed areas, only authorized areas. */
/* ------------------------------------------ */
if (!str_cmp("changed", arg1))
{
char buf[MAX_INPUT_LENGTH];
save_area_list();
if (ch)
chprintln(ch, "Saved zones:");
else
log_string("Saved zones:");
sprintf(buf, "None.\n\r");
for (pArea = area_first; pArea; pArea = pArea->next)
{
/* Builder must be assigned this area. */
if (ch && !IS_BUILDER(ch, pArea))
continue;
/* Save changed areas. */
if (IS_SET(pArea->area_flags, AREA_CHANGED))
{
save_area(pArea);
sprintf(buf, "%24s - '%s'", pArea->name, pArea->file_name);
if (ch)
{
chprint(ch, buf);
chprintln(ch, "");
}
else
log_string(buf);
REMOVE_BIT(pArea->area_flags, AREA_CHANGED);
}
}
if (!str_cmp(buf, "None.\n\r"))
{
if (ch)
chprint(ch, buf);
else
log_string("None.");
}
return;
}
/* Save the area.lst file. */
/* ----------------------- */
if (!str_cmp(arg1, "list"))
{
save_area_list();
return;
}
if (!str_cmp(arg1, "clans"))
{
save_clans();
chprint(ch, "Clans saved.");
return;
}
if (!str_cmp(arg1, "socials"))
{
save_social_table();
chprintln(ch, "Socials saved.");
return;
}
if (!str_cmp(arg1, "helps"))
{
save_area_list();
save_helps();
chprintln(ch, "Helps saved.");
return;
}
if (!str_cmp(arg1, "deity"))
{
save_deities();
if (ch)
chprintln(ch, "Deity data saved.");
return;
}
if (!str_cmp(arg1, "commands"))
{
save_commands();
chprintln(ch, "Commands saved.");
return;
}
if (!str_cmp(arg1, "skills"))
{
save_skills();
chprintln(ch, "Skills saved.");
return;
}
if (!str_cmp(arg1, "groups"))
{
save_groups();
chprintln(ch, "Groups saved.");
return;
}
if (!str_cmp(arg1, "races"))
{
save_races();
chprintln(ch, "Races saved.");
return;
}
if (!str_cmp(arg1, "classes"))
{
save_classes();
chprintln(ch, "Classes saved.");
return;
}
/* Save area being edited, if authorized. */
/* -------------------------------------- */
if (!str_cmp(arg1, "area"))
{
if (!ch || !ch->desc)
return;
/* Is character currently editing. */
if (ch->desc->editor == ED_NONE)
{
chprintln(ch, "You are not editing an area, "
"therefore an area vnum is required.");
return;
}
/* Find the area to save. */
switch (ch->desc->editor)
{
case ED_AREA:
pArea = (AREA_DATA *) ch->desc->pEdit;
break;
case ED_ROOM:
pArea = ch->in_room->area;
break;
case ED_OBJECT:
pArea = ((OBJ_INDEX_DATA *) ch->desc->pEdit)->area;
break;
case ED_MOBILE:
pArea = ((MOB_INDEX_DATA *) ch->desc->pEdit)->area;
break;
default:
pArea = ch->in_room->area;
break;
}
if (!IS_BUILDER(ch, pArea))
{
chprintln(ch, "You are not a builder for this area.");
return;
}
save_area_list();
save_area(pArea);
REMOVE_BIT(pArea->area_flags, AREA_CHANGED);
chprintln(ch, "Area saved.");
return;
}
/* Show correct syntax. */
/* -------------------- */
if (ch)
do_asave(ch, "");
return;
}