/**************************************************************************
* 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_act.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. *
* *
***************************************************************************/
#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 "recycle.h"
#include "lookup.h"
#include "interp.h"
#include "magic.h"
#define ALT_FLAGVALUE_SET( _blargh, _table, _arg ) \
{ \
flag_t blah = flag_value( _table, _arg ); \
_blargh = UMAX(0, blah); \
}
#define ALT_FLAGVALUE_TOGGLE( _blargh, _table, _arg ) \
{ \
flag_t blah = flag_value( _table, _arg ); \
TOGGLE_BIT(_blargh, UMAX(0, blah)); \
}
/* Return TRUE if area changed, FALSE if not. */
#define REDIT( fun ) bool fun( CHAR_DATA *ch, const char *argument )
#define OEDIT( fun ) bool fun( CHAR_DATA *ch, const char *argument )
#define MEDIT( fun ) bool fun( CHAR_DATA *ch, const char *argument )
#define AEDIT( fun ) bool fun( CHAR_DATA *ch, const char *argument )
#define CEDIT( fun ) bool fun( CHAR_DATA *ch, const char *argument )
struct olc_help_type
{
char *command;
const void *structure;
char *desc;
};
void unlink_reset(ROOM_INDEX_DATA * pRoom, RESET_DATA * pReset)
{
RESET_DATA *prev, *wReset;
for (wReset = pRoom->reset_first; wReset; wReset = prev)
{
prev = wReset->next;
if (wReset == pReset)
{
UNLINK(pReset, pRoom->reset_first, pRoom->reset_last, next, prev);
}
}
}
void unlink_obj_index(OBJ_INDEX_DATA * pObj)
{
int iHash;
iHash = pObj->vnum % MAX_KEY_HASH;
UNLINK_SINGLE(pObj, next, OBJ_INDEX_DATA, obj_index_hash[iHash]);
}
void unlink_room_index(ROOM_INDEX_DATA * pRoom)
{
int iHash;
iHash = pRoom->vnum % MAX_KEY_HASH;
UNLINK_SINGLE(pRoom, next, ROOM_INDEX_DATA, room_index_hash[iHash]);
}
void unlink_mob_index(MOB_INDEX_DATA * pMob)
{
int iHash;
iHash = pMob->vnum % MAX_KEY_HASH;
UNLINK_SINGLE(pMob, next, MOB_INDEX_DATA, mob_index_hash[iHash]);
}
bool show_version(CHAR_DATA * ch, char *argument)
{
chprintln(ch, VERSION);
chprintln(ch, AUTHOR);
chprintln(ch, DATE);
chprintln(ch, CREDITS);
return FALSE;
}
/*
* This table contains help commands and a brief description of each.
* ------------------------------------------------------------------
*/
const struct olc_help_type help_table[] = {
{"area", area_flags, "Area attributes."},
{"room", room_flags, "Room attributes."},
{"sector", sector_flags, "Sector types, terrain."},
{"exit", exit_flags, "Exit types."},
{"type", type_flags, "Types of objects."},
{"extra", extra_flags, "Object attributes."},
{"wear", wear_flags, "Where to wear object."},
{"spec", spec_table, "Available special programs."},
{"sex", sex_flags, "Sexes."},
{"act", act_flags, "Mobile attributes."},
{"affect", affect_flags, "Mobile affects."},
{"wear-loc", wear_loc_flags, "Where mobile wears object."},
{"container", container_flags, "Container status."},
{"targets", target_flags, "Skill target types."},
/* ROM specific bits: */
{"armor", ac_type, "Ac for different attacks."},
{"apply", apply_flags, "Apply flags"},
{"form", form_flags, "Mobile body form."},
{"part", part_flags, "Mobile body parts."},
{"imm", imm_flags, "Mobile immunity."},
{"res", res_flags, "Mobile resistance."},
{"vuln", vuln_flags, "Mobile vulnerability."},
{"off", off_flags, "Mobile offensive behaviour."},
{"size", size_flags, "Mobile size."},
{"position", position_flags, "Mobile positions."},
{"wclass", weapon_class, "Weapon class."},
{"wtype", weapon_type2, "Special weapon type."},
{"portal", portal_flags, "Portal types."},
{"furniture", furniture_flags, "Furniture types."},
{"liquid", liq_table, "Liquid types."},
{"apptype", apply_types, "Apply types."},
{"weapon", attack_table, "Weapon types."},
{"mprog", mprog_flags, "MobProgram flags."},
{"logflags", log_flags, "Command log types."},
{NULL, NULL, NULL}
};
/*****************************************************************************
Name: show_flag_cmds
Purpose: Displays settable flags and stats.
Called by: show_help(olc_act.c).
****************************************************************************/
void show_flag_cmds(CHAR_DATA * ch, const struct flag_type *flag_table)
{
char buf[MAX_STRING_LENGTH];
char buf1[MAX_STRING_LENGTH];
int flag;
int col;
buf1[0] = '\0';
col = 0;
for (flag = 0; flag_table[flag].name != NULL; flag++)
{
if (flag_table[flag].settable)
{
sprintf(buf, "%-19.18s", flag_table[flag].name);
strcat(buf1, buf);
if (++col % 4 == 0)
strcat(buf1, "\n\r");
}
}
if (col % 4 != 0)
strcat(buf1, "\n\r");
chprint(ch, buf1);
return;
}
/*****************************************************************************
Name: show_skill_cmds
Purpose: Displays all skill functions.
Does remove those damn immortal commands from the list.
Could be improved by:
(1) Adding a check for a particular class.
(2) Adding a check for a level range.
Called by: show_help(olc_act.c).
****************************************************************************/
void show_skill_cmds(CHAR_DATA * ch, int tar)
{
char buf[MAX_STRING_LENGTH];
char buf1[MAX_STRING_LENGTH * 2];
int sn;
int col;
buf1[0] = '\0';
col = 0;
for (sn = 0; sn < maxSkill; sn++)
{
if (!skill_table[sn].name)
break;
if (!str_cmp(skill_table[sn].name, "reserved") ||
skill_table[sn].spell_fun == spell_null)
continue;
if (tar == -1 || skill_table[sn].target == tar)
{
sprintf(buf, "%-19.18s", skill_table[sn].name);
strcat(buf1, buf);
if (++col % 4 == 0)
strcat(buf1, "\n\r");
}
}
if (col % 4 != 0)
strcat(buf1, "\n\r");
chprint(ch, buf1);
return;
}
/*****************************************************************************
Name: show_spec_cmds
Purpose: Displays settable special functions.
Called by: show_help(olc_act.c).
****************************************************************************/
void show_spec_cmds(CHAR_DATA * ch)
{
char buf[MAX_STRING_LENGTH];
char buf1[MAX_STRING_LENGTH];
int spec;
int col;
buf1[0] = '\0';
col = 0;
chprintln(ch, "Preceed special functions with 'spec_'\n\r");
for (spec = 0; spec_table[spec].function != NULL; spec++)
{
sprintf(buf, "%-19.18s", &spec_table[spec].name[5]);
strcat(buf1, buf);
if (++col % 4 == 0)
strcat(buf1, "\n\r");
}
if (col % 4 != 0)
strcat(buf1, "\n\r");
chprint(ch, buf1);
return;
}
/*****************************************************************************
Name: show_help
Purpose: Displays help for many tables used in OLC.
Called by: olc interpreters.
****************************************************************************/
bool show_help(CHAR_DATA * ch, const char *argument)
{
char arg[MAX_INPUT_LENGTH];
char spell[MAX_INPUT_LENGTH];
int cnt;
argument = one_argument(argument, arg);
one_argument(argument, spell);
/*
* Display syntax.
*/
if (arg[0] == '\0')
{
chprintln(ch, "Syntax: ? [command]\n\r");
chprintln(ch, "[command] [description]");
for (cnt = 0; help_table[cnt].command != NULL; cnt++)
{
chprintlnf(ch, "%-10.10s -%s",
capitalize(help_table[cnt].command),
help_table[cnt].desc);
}
return FALSE;
}
/*
* Find the command, show changeable data.
* ---------------------------------------
*/
for (cnt = 0; help_table[cnt].command != NULL; cnt++)
{
if (arg[0] == help_table[cnt].command[0] &&
!str_prefix(arg, help_table[cnt].command))
{
if (help_table[cnt].structure == spec_table)
{
show_spec_cmds(ch);
return FALSE;
}
else if (help_table[cnt].structure == liq_table)
{
show_liqlist(ch);
return FALSE;
}
else if (help_table[cnt].structure == attack_table)
{
show_damlist(ch);
return FALSE;
}
else if (help_table[cnt].structure == skill_table)
{
if (spell[0] == '\0')
{
chprintln(ch, "Syntax: ? spells "
"[ignore/attack/defend/self/object/all]");
return FALSE;
}
if (!str_prefix(spell, "all"))
show_skill_cmds(ch, -1);
else if (!str_prefix(spell, "ignore"))
show_skill_cmds(ch, TAR_IGNORE);
else if (!str_prefix(spell, "attack"))
show_skill_cmds(ch, TAR_CHAR_OFFENSIVE);
else if (!str_prefix(spell, "defend"))
show_skill_cmds(ch, TAR_CHAR_DEFENSIVE);
else if (!str_prefix(spell, "self"))
show_skill_cmds(ch, TAR_CHAR_SELF);
else if (!str_prefix(spell, "object"))
show_skill_cmds(ch, TAR_OBJ_INV);
else
chprintln(ch, "Syntax: ? spell "
"[ignore/attack/defend/self/object/all]");
return FALSE;
}
else
{
show_flag_cmds(ch,
(struct flag_type *) help_table[cnt].structure);
return FALSE;
}
}
}
show_help(ch, "");
return FALSE;
}
REDIT(redit_format)
{
ROOM_INDEX_DATA *pRoom;
EDIT_ROOM(ch, pRoom);
pRoom->description = format_string(pRoom->description);
chprintln(ch, "String formatted.");
return TRUE;
}
REDIT(redit_rlist)
{
ROOM_INDEX_DATA *pRoomIndex;
AREA_DATA *pArea;
char buf[MAX_STRING_LENGTH];
BUFFER *buf1;
char arg[MAX_INPUT_LENGTH];
bool found;
vnum_t vnum;
int col = 0;
one_argument(argument, arg);
pArea = ch->in_room->area;
buf1 = new_buf();
/* buf1[0] = '\0'; */
found = FALSE;
for (vnum = pArea->min_vnum; vnum <= pArea->max_vnum; vnum++)
{
if ((pRoomIndex = get_room_index(vnum)))
{
found = TRUE;
sprintf(buf, "[%5ld] %-17.16s", vnum, capitalize(pRoomIndex->name));
add_buf(buf1, buf);
if (++col % 3 == 0)
add_buf(buf1, "\n\r");
}
}
if (!found)
{
chprintln(ch, "Room(s) not found in this area.");
return FALSE;
}
if (col % 3 != 0)
add_buf(buf1, "\n\r");
page_to_char(buf_string(buf1), ch);
free_buf(buf1);
return FALSE;
}
REDIT(redit_mlist)
{
MOB_INDEX_DATA *pMobIndex;
AREA_DATA *pArea;
char buf[MAX_STRING_LENGTH];
BUFFER *buf1;
char arg[MAX_INPUT_LENGTH];
bool fAll, found;
vnum_t vnum;
int col = 0;
one_argument(argument, arg);
if (arg[0] == '\0')
{
chprintln(ch, "Syntax: mlist <all/name>");
return FALSE;
}
buf1 = new_buf();
pArea = ch->in_room->area;
/* buf1[0] = '\0'; */
fAll = !str_cmp(arg, "all");
found = FALSE;
for (vnum = pArea->min_vnum; vnum <= pArea->max_vnum; vnum++)
{
if ((pMobIndex = get_mob_index(vnum)) != NULL)
{
if (fAll || is_name(arg, pMobIndex->player_name))
{
found = TRUE;
sprintf(buf, "[%5ld] %-17.16s", pMobIndex->vnum,
capitalize(pMobIndex->short_descr));
add_buf(buf1, buf);
if (++col % 3 == 0)
add_buf(buf1, "\n\r");
}
}
}
if (!found)
{
chprintln(ch, "Mobile(s) not found in this area.");
return FALSE;
}
if (col % 3 != 0)
add_buf(buf1, "\n\r");
page_to_char(buf_string(buf1), ch);
free_buf(buf1);
return FALSE;
}
REDIT(redit_delete)
{
ROOM_INDEX_DATA *pRoom, *pRoom2;
RESET_DATA *pReset;
EXIT_DATA *ex;
OBJ_DATA *Obj, *obj_next;
CHAR_DATA *wch, *wnext;
EXTRA_DESCR_DATA *pExtra;
char arg[MIL];
vnum_t pIndex, v;
int i, iHash, rcount, ecount, mcount, ocount, edcount;
if (IS_NULLSTR(argument))
{
if (ch)
chprintln(ch, "Syntax: redit delete [vnum]");
return FALSE;
}
one_argument(argument, arg);
if (is_number(arg))
{
pIndex = atol(arg);
pRoom = get_room_index(pIndex);
}
else
{
if (ch)
chprintln(ch, "That is not a number.");
return FALSE;
}
for (i = 0; vnum_table[i].vnum != -1; i++)
{
if (vnum_table[i].type != VNUM_ROOM)
continue;
if (vnum_table[i].vnum == pIndex)
{
if (ch)
chprintln(ch, "That vnum is reserved.");
return FALSE;
}
}
if (!pRoom)
{
if (ch)
chprintln(ch, "No such room.");
return FALSE;
}
stop_editing(pRoom);
SET_BIT(pRoom->area->area_flags, AREA_CHANGED);
rcount = 0;
for (pReset = pRoom->reset_first; pReset; pReset = pReset->next)
{
rcount++;
}
ocount = 0;
for (Obj = pRoom->first_content; Obj; Obj = obj_next)
{
obj_next = Obj->next_content;
extract_obj(Obj);
ocount++;
}
mcount = 0;
for (wch = pRoom->first_person; wch; wch = wnext)
{
wnext = wch->next_in_room;
if (IS_NPC(wch))
{
extract_char(wch, TRUE);
mcount++;
}
else
{
chprintln(wch,
"This room is being deleted. Moving you somewhere safe.");
if (wch->fighting != NULL)
stop_fighting(wch, TRUE);
char_from_room(wch);
char_to_room(wch, get_room_index(ROOM_VNUM_TEMPLE));
wch->was_in_room = wch->in_room;
}
}
ecount = 0;
for (iHash = 0; iHash < MAX_KEY_HASH; iHash++)
{
for (pRoom2 = room_index_hash[iHash]; pRoom2; pRoom2 = pRoom2->next)
{
for (i = 0; i <= MAX_DIR; i++)
{
if (!(ex = pRoom2->exit[i]))
continue;
if (pRoom2 == pRoom)
{
ecount++;
continue;
}
if (ex->u1.to_room == pRoom)
{
free_exit(pRoom2->exit[i]);
pRoom2->exit[i] = NULL;
SET_BIT(pRoom2->area->area_flags, AREA_CHANGED);
ecount++;
}
}
}
}
edcount = 0;
for (pExtra = pRoom->first_extra_descr; pExtra; pExtra = pExtra->next)
{
edcount++;
}
if (top_vnum_room == pIndex)
for (v = 1; v < pIndex; v++)
if (get_room_index(v))
top_vnum_room = v;
top_room--;
if (!IS_SET(pRoom->room_flags, ROOM_NOEXPLORE))
top_explored--;
unlink_room_index(pRoom);
pRoom->area = NULL;
pRoom->vnum = 0;
free_room_index(pRoom);
if (ch)
{
chprintf(ch,
"Removed room vnum {C%ld{x, %d resets, %d extra "
"descriptions and %d exits.\n\r", pIndex, rcount,
edcount, ecount);
chprintf(ch,
"{C%d{x objects and {C%d{x mobiles were extracted "
"from the room.\n\r", ocount, mcount);
}
return TRUE;
}
REDIT(redit_olist)
{
OBJ_INDEX_DATA *pObjIndex;
AREA_DATA *pArea;
char buf[MAX_STRING_LENGTH];
BUFFER *buf1;
char arg[MAX_INPUT_LENGTH];
bool fAll, found;
vnum_t vnum;
int col = 0;
one_argument(argument, arg);
if (arg[0] == '\0')
{
chprintln(ch, "Syntax: olist <all/name/item_type>");
return FALSE;
}
pArea = ch->in_room->area;
buf1 = new_buf();
/* buf1[0] = '\0'; */
fAll = !str_cmp(arg, "all");
found = FALSE;
for (vnum = pArea->min_vnum; vnum <= pArea->max_vnum; vnum++)
{
if ((pObjIndex = get_obj_index(vnum)))
{
if (fAll || is_name(arg, pObjIndex->name) ||
(int) flag_value(type_flags, arg) == pObjIndex->item_type)
{
found = TRUE;
sprintf(buf, "[%5ld] %-17.16s", pObjIndex->vnum,
capitalize(pObjIndex->short_descr));
add_buf(buf1, buf);
if (++col % 3 == 0)
add_buf(buf1, "\n\r");
}
}
}
if (!found)
{
chprintln(ch, "Object(s) not found in this area.");
return FALSE;
}
if (col % 3 != 0)
add_buf(buf1, "\n\r");
page_to_char(buf_string(buf1), ch);
free_buf(buf1);
return FALSE;
}
REDIT(redit_mshow)
{
MOB_INDEX_DATA *pMob;
vnum_t value;
if (argument[0] == '\0')
{
chprintln(ch, "Syntax: mshow <vnum>");
return FALSE;
}
if (!is_number(argument))
{
chprintln(ch, "REdit: Ingresa un numero.");
return FALSE;
}
if (is_number(argument))
{
value = atol(argument);
if (!(pMob = get_mob_index(value)))
{
chprintln(ch, "REdit: That mobile does not exist.");
return FALSE;
}
ch->desc->pEdit = (void *) pMob;
}
medit_show(ch, argument);
ch->desc->pEdit = (void *) ch->in_room;
return FALSE;
}
REDIT(redit_oshow)
{
OBJ_INDEX_DATA *pObj;
vnum_t value;
if (argument[0] == '\0')
{
chprintln(ch, "Syntax: oshow <vnum>");
return FALSE;
}
if (!is_number(argument))
{
chprintln(ch, "REdit: Ingresa un numero.");
return FALSE;
}
if (is_number(argument))
{
value = atol(argument);
if (!(pObj = get_obj_index(value)))
{
chprintln(ch, "REdit: That object does not exist.");
return FALSE;
}
ch->desc->pEdit = (void *) pObj;
}
oedit_show(ch, argument);
ch->desc->pEdit = (void *) ch->in_room;
return FALSE;
}
/*****************************************************************************
Name: check_range( lower vnum, upper vnum )
Purpose: Ensures the range spans only one area.
Called by: aedit_vnum(olc_act.c).
****************************************************************************/
bool check_range(long lower, long upper)
{
AREA_DATA *pArea;
int cnt = 0;
for (pArea = area_first; pArea; pArea = pArea->next)
{
/*
* lower < area < upper
*/
if ((lower <= pArea->min_vnum && pArea->min_vnum <= upper) ||
(lower <= pArea->max_vnum && pArea->max_vnum <= upper))
++cnt;
if (cnt > 1)
return FALSE;
}
return TRUE;
}
AREA_DATA *get_vnum_area(vnum_t vnum)
{
AREA_DATA *pArea;
for (pArea = area_first; pArea; pArea = pArea->next)
{
if (vnum >= pArea->min_vnum && vnum <= pArea->max_vnum)
return pArea;
}
return 0;
}
/*
* Area Editor Functions.
*/
AEDIT(aedit_show)
{
AREA_DATA *pArea;
EDIT_AREA(ch, pArea);
chprintf(ch, "%s\n\r",
stringf(ch, 0, ALIGN_CENTER, "-",
FORMATF("[ %s: %s ]", olc_ed_name(ch), olc_ed_vnum(ch))));
chprintlnf(ch, "Name: [%5d] %s", pArea->vnum, pArea->name);
#if 0 /* ROM OLC */
chprintlnf(ch, "Recall: [%5d] %s", pArea->recall,
get_room_index(pArea->recall) ? get_room_index(pArea->recall)->
name : "none");
#endif /* ROM */
chprintlnf(ch, "File: %s", pArea->file_name);
chprintlnf(ch, "Vnums: [%ld-%ld]", pArea->min_vnum, pArea->max_vnum);
chprintlnf(ch, "Age: [%d]", pArea->age);
chprintlnf(ch, "Players: [%d]", pArea->nplayer);
chprintlnf(ch, "Security: [%d]", pArea->security);
chprintlnf(ch, "Builders: [%s]", pArea->builders);
chprintlnf(ch, "Credits : [%s]", pArea->credits);
chprintlnf(ch, "Flags: [%s]",
flag_string(area_flags, pArea->area_flags));
chprintln(ch, draw_line(ch, NULL, 0));
return FALSE;
}
AEDIT(aedit_reset)
{
AREA_DATA *pArea;
EDIT_AREA(ch, pArea);
reset_area(pArea);
chprintln(ch, "Area reset.");
return FALSE;
}
AEDIT(aedit_create)
{
AREA_DATA *pArea;
pArea = new_area();
add_area(pArea);
top_area++;
edit_start(ch, pArea, ED_AREA);
SET_BIT(pArea->area_flags, AREA_ADDED);
chprintln(ch, "Area Created.");
return FALSE;
}
AEDIT(aedit_file)
{
AREA_DATA *pArea;
char file[MAX_STRING_LENGTH];
int i, length;
EDIT_AREA(ch, pArea);
one_argument(argument, file); /* Forces Lowercase */
if (argument[0] == '\0')
{
chprintln(ch, "Syntax: filename [$file]");
return FALSE;
}
/*
* Simple Syntax Check.
*/
length = strlen(argument);
if (length > 8)
{
chprintln(ch, "No more than eight characters allowed.");
return FALSE;
}
/*
* Allow only letters and numbers.
*/
for (i = 0; i < length; i++)
{
if (!isalnum(file[i]))
{
chprintln(ch, "Only letters and numbers are valid.");
return FALSE;
}
}
free_string(pArea->file_name);
strcat(file, ".are");
pArea->file_name = str_dup(file);
chprintln(ch, "Filename set.");
return TRUE;
}
AEDIT(aedit_builder)
{
AREA_DATA *pArea;
char name[MAX_STRING_LENGTH];
char buf[MAX_STRING_LENGTH];
EDIT_AREA(ch, pArea);
one_argument(argument, name);
if (name[0] == '\0')
{
chprintln(ch, "Syntax: builder [$name] -toggles builder");
chprintln(ch, "Syntax: builder All -allows everyone");
return FALSE;
}
name[0] = UPPER(name[0]);
if (strstr(pArea->builders, name) != '\0')
{
pArea->builders = string_replace(pArea->builders, name, "\0");
pArea->builders = string_unpad(pArea->builders);
if (pArea->builders[0] == '\0')
{
free_string(pArea->builders);
pArea->builders = str_dup("None");
}
chprintln(ch, "Builder removed.");
return TRUE;
}
else
{
buf[0] = '\0';
if (strstr(pArea->builders, "None") != '\0')
{
pArea->builders = string_replace(pArea->builders, "None", "\0");
pArea->builders = string_unpad(pArea->builders);
}
if (pArea->builders[0] != '\0')
{
strcat(buf, pArea->builders);
strcat(buf, " ");
}
strcat(buf, name);
free_string(pArea->builders);
pArea->builders = string_proper(str_dup(buf));
chprintln(ch, "Builder added.");
chprint(ch, pArea->builders);
return TRUE;
}
return FALSE;
}
AEDIT(aedit_vnum)
{
AREA_DATA *pArea;
char lower[MAX_STRING_LENGTH];
char upper[MAX_STRING_LENGTH];
vnum_t ilower;
vnum_t iupper;
EDIT_AREA(ch, pArea);
argument = one_argument(argument, lower);
one_argument(argument, upper);
if (!is_number(lower) || lower[0] == '\0' || !is_number(upper) ||
upper[0] == '\0')
{
chprintln(ch, "Syntax: vnum [#xlower] [#xupper]");
return FALSE;
}
if ((ilower = atoi(lower)) > (iupper = atoi(upper)))
{
chprintln(ch, "AEdit: Upper must be larger then lower.");
return FALSE;
}
if (!check_range(atol(lower), atol(upper)))
{
chprintln(ch, "AEdit: Range must include only this area.");
return FALSE;
}
if (get_vnum_area(ilower) && get_vnum_area(ilower) != pArea)
{
chprintln(ch, "AEdit: Lower vnum already assigned.");
return FALSE;
}
pArea->min_vnum = ilower;
chprintln(ch, "Lower vnum set.");
if (get_vnum_area(iupper) && get_vnum_area(iupper) != pArea)
{
chprintln(ch, "AEdit: Upper vnum already assigned.");
return TRUE; /* The lower value has been set. */
}
if (iupper > MAX_VNUM)
{
chprintlnf(ch, "Vnum can't be higher than %d.", MAX_VNUM);
return FALSE;
}
pArea->max_vnum = iupper;
chprintln(ch, "Upper vnum set.");
return TRUE;
}
AEDIT(aedit_lvnum)
{
AREA_DATA *pArea;
char lower[MAX_STRING_LENGTH];
vnum_t ilower;
vnum_t iupper;
EDIT_AREA(ch, pArea);
one_argument(argument, lower);
if (!is_number(lower) || lower[0] == '\0')
{
chprintln(ch, "Syntax: min_vnum [#xlower]");
return FALSE;
}
if ((ilower = atol(lower)) > (iupper = pArea->max_vnum))
{
chprintln(ch, "AEdit: Value must be less than the max_vnum.");
return FALSE;
}
if (!check_range(ilower, iupper))
{
chprintln(ch, "AEdit: Range must include only this area.");
return FALSE;
}
if (get_vnum_area(ilower) && get_vnum_area(ilower) != pArea)
{
chprintln(ch, "AEdit: Lower vnum already assigned.");
return FALSE;
}
if (ilower > MAX_VNUM)
{
chprintlnf(ch, "Vnum can't be higher than %d", MAX_VNUM);
return FALSE;
}
pArea->min_vnum = ilower;
chprintln(ch, "Lower vnum set.");
return TRUE;
}
AEDIT(aedit_uvnum)
{
AREA_DATA *pArea;
char upper[MAX_STRING_LENGTH];
vnum_t ilower;
vnum_t iupper;
EDIT_AREA(ch, pArea);
one_argument(argument, upper);
if (!is_number(upper) || upper[0] == '\0')
{
chprintln(ch, "Syntax: max_vnum [#xupper]");
return FALSE;
}
if ((ilower = pArea->min_vnum) > (iupper = atol(upper)))
{
chprintln(ch, "AEdit: Upper must be larger then lower.");
return FALSE;
}
if (!check_range(ilower, iupper))
{
chprintln(ch, "AEdit: Range must include only this area.");
return FALSE;
}
if (get_vnum_area(iupper) && get_vnum_area(iupper) != pArea)
{
chprintln(ch, "AEdit: Upper vnum already assigned.");
return FALSE;
}
pArea->max_vnum = iupper;
chprintln(ch, "Upper vnum set.");
return TRUE;
}
/*
* Room Editor Functions.
*/
REDIT(redit_show)
{
ROOM_INDEX_DATA *pRoom;
char buf[MAX_STRING_LENGTH];
char buf1[2 * MAX_STRING_LENGTH];
OBJ_DATA *obj;
CHAR_DATA *rch;
int door;
bool fcnt;
PROG_LIST *list;
EDIT_ROOM(ch, pRoom);
buf1[0] = '\0';
strcat(buf1,
stringf(ch, 0, ALIGN_CENTER, "-",
FORMATF("[ %s: %s ]", olc_ed_name(ch), olc_ed_vnum(ch))));
strcat(buf1, "\n\r");
sprintf(buf, "Description:\n\r%s", pRoom->description);
strcat(buf1, buf);
sprintf(buf, "Name: [%s]\n\rArea: [%5d] %s\n\r",
pRoom->name, pRoom->area->vnum, pRoom->area->name);
strcat(buf1, buf);
sprintf(buf, "Vnum: [%5ld]\n\rSector: [%s]\n\r", pRoom->vnum,
flag_string(sector_flags, pRoom->sector_type));
strcat(buf1, buf);
sprintf(buf, "Room flags: [%s]\n\r",
flag_string(room_flags, pRoom->room_flags));
strcat(buf1, buf);
if (pRoom->heal_rate != 100 || pRoom->mana_rate != 100)
{
sprintf(buf, "Health rec: [%d]\n\rMana rec : [%d]\n\r",
pRoom->heal_rate, pRoom->mana_rate);
strcat(buf1, buf);
}
if (pRoom->clan != NULL)
{
sprintf(buf, "Clan : %s\n\r", pRoom->clan->name);
strcat(buf1, buf);
}
if (!IS_NULLSTR(pRoom->owner))
{
sprintf(buf, "Owner : [%s]\n\r", pRoom->owner);
strcat(buf1, buf);
}
if (pRoom->first_extra_descr)
{
EXTRA_DESCR_DATA *ed;
strcat(buf1, "Desc Kwds: [");
for (ed = pRoom->first_extra_descr; ed; ed = ed->next)
{
strcat(buf1, ed->keyword);
if (ed->next)
strcat(buf1, " ");
}
strcat(buf1, "]\n\r");
}
strcat(buf1, "Characters: [");
fcnt = FALSE;
for (rch = pRoom->first_person; rch; rch = rch->next_in_room)
{
one_argument(rch->name, buf);
strcat(buf1, buf);
strcat(buf1, " ");
fcnt = TRUE;
}
if (fcnt)
{
int end;
end = strlen(buf1) - 1;
buf1[end] = ']';
strcat(buf1, "\n\r");
}
else
strcat(buf1, "none]\n\r");
strcat(buf1, "Objects: [");
fcnt = FALSE;
for (obj = pRoom->first_content; obj; obj = obj->next_content)
{
one_argument(obj->name, buf);
strcat(buf1, buf);
strcat(buf1, " ");
fcnt = TRUE;
}
if (fcnt)
{
int end;
end = strlen(buf1) - 1;
buf1[end] = ']';
strcat(buf1, "\n\r");
}
else
strcat(buf1, "none]\n\r");
for (door = 0; door < MAX_DIR; door++)
{
EXIT_DATA *pexit;
if ((pexit = pRoom->exit[door]))
{
char word[MAX_INPUT_LENGTH];
char reset_state[MAX_STRING_LENGTH];
const char *state;
int i, length;
sprintf(buf, "-%-5s to [%5ld] Key: [%5ld] ",
capitalize(dir_name[door]),
pexit->u1.to_room ? pexit->u1.to_room->vnum : 0, /* ROM OLC */
pexit->key);
strcat(buf1, buf);
/*
* Format up the exit info.
* Capitalize all flags that are not part of the reset info.
*/
strcpy(reset_state, flag_string(exit_flags, pexit->rs_flags));
state = flag_string(exit_flags, pexit->exit_info);
strcat(buf1, " Exit flags: [");
for (;;)
{
state = one_argument((char *) state, word);
if (word[0] == '\0')
{
int end;
end = strlen(buf1) - 1;
buf1[end] = ']';
strcat(buf1, "\n\r");
break;
}
if (str_infix(word, reset_state))
{
length = strlen(word);
for (i = 0; i < length; i++)
word[i] = UPPER(word[i]);
}
strcat(buf1, word);
strcat(buf1, " ");
}
if (pexit->keyword && pexit->keyword[0] != '\0')
{
sprintf(buf, "Kwds: [%s]\n\r", pexit->keyword);
strcat(buf1, buf);
}
if (pexit->description && pexit->description[0] != '\0')
{
sprintf(buf, "%s", pexit->description);
strcat(buf1, buf);
}
}
}
strcat(buf1, draw_line(ch, NULL, 0));
chprintln(ch, buf1);
if (pRoom->first_rprog)
{
int cnt;
sprintf(buf, "\n\rROOMPrograms for [%5ld]:", pRoom->vnum);
chprintln(ch, buf);
for (cnt = 0, list = pRoom->first_rprog; list; list = list->next)
{
if (cnt == 0)
{
chprintln(ch, " Number Vnum Trigger Phrase");
chprintln(ch, " ------ ---- ------- ------");
}
chprintlnf(ch, "[%5d] %4ld %7s %s", cnt,
list->vnum, prog_type_to_name(list->trig_type),
list->trig_phrase);
cnt++;
}
}
return FALSE;
}
/* Local function. */
bool change_exit(CHAR_DATA * ch, const char *argument, int door)
{
ROOM_INDEX_DATA *pRoom;
char command[MAX_INPUT_LENGTH];
char arg[MAX_INPUT_LENGTH];
flag_t value;
EDIT_ROOM(ch, pRoom);
/*
* Set the exit flags, needs full argument.
* ----------------------------------------
*/
if ((value = flag_value(exit_flags, argument)) != NO_FLAG)
{
ROOM_INDEX_DATA *pToRoom;
int rev; /* ROM OLC */
if (!pRoom->exit[door])
{
chprintln(ch, "Salida no existe.");
return FALSE;
}
/*
* This room.
*/
TOGGLE_BIT(pRoom->exit[door]->rs_flags, value);
/* Don't toggle exit_info because it can be changed by players. */
pRoom->exit[door]->exit_info = pRoom->exit[door]->rs_flags;
/*
* Connected room.
*/
pToRoom = pRoom->exit[door]->u1.to_room; /* ROM OLC */
rev = rev_dir[door];
if (pToRoom->exit[rev] != NULL)
{
pToRoom->exit[rev]->rs_flags = pRoom->exit[door]->rs_flags;
pToRoom->exit[rev]->exit_info = pRoom->exit[door]->exit_info;
}
chprintln(ch, "Exit flag toggled.");
return TRUE;
}
/*
* Now parse the arguments.
*/
argument = one_argument(argument, command);
one_argument(argument, arg);
if (command[0] == '\0' && argument[0] == '\0') /* Move command. */
{
move_char(ch, door, TRUE); /* ROM OLC */
return FALSE;
}
if (command[0] == '?')
{
do_oldhelp(ch, "EXIT");
return FALSE;
}
if (!str_cmp(command, "delete"))
{
ROOM_INDEX_DATA *pToRoom;
int rev; /* ROM OLC */
if (!pRoom->exit[door])
{
chprintln(ch, "REdit: Cannot delete a null exit.");
return FALSE;
}
/*
* Remove ToRoom Exit.
*/
rev = rev_dir[door];
pToRoom = pRoom->exit[door]->u1.to_room; /* ROM OLC */
if (pToRoom->exit[rev])
{
free_exit(pToRoom->exit[rev]);
pToRoom->exit[rev] = NULL;
}
/*
* Remove this exit.
*/
free_exit(pRoom->exit[door]);
pRoom->exit[door] = NULL;
chprintln(ch, "Exit unlinked.");
return TRUE;
}
if (!str_cmp(command, "link"))
{
EXIT_DATA *pExit;
ROOM_INDEX_DATA *toRoom;
if (arg[0] == '\0' || !is_number(arg))
{
chprintln(ch, "Syntax: [direction] link [vnum]");
return FALSE;
}
value = atol(arg);
if (!(toRoom = get_room_index(value)))
{
chprintln(ch, "REdit: Cannot link to non-existant room.");
return FALSE;
}
if (!IS_BUILDER(ch, toRoom->area))
{
chprintln(ch, "REdit: Cannot link to that area.");
return FALSE;
}
if (toRoom->exit[rev_dir[door]])
{
chprintln(ch, "REdit: Remote side's exit already exists.");
return FALSE;
}
if (!pRoom->exit[door])
pRoom->exit[door] = new_exit();
pRoom->exit[door]->u1.to_room = toRoom;
pRoom->exit[door]->orig_door = door;
door = rev_dir[door];
pExit = new_exit();
pExit->u1.to_room = pRoom;
pExit->orig_door = door;
toRoom->exit[door] = pExit;
chprintln(ch, "Two-way link established.");
return TRUE;
}
if (!str_cmp(command, "dig"))
{
char buf[MAX_STRING_LENGTH];
if (arg[0] == '\0' || !is_number(arg))
{
chprintln(ch, "Syntax: [direction] dig <vnum>");
return FALSE;
}
redit_create(ch, arg);
sprintf(buf, "link %s", arg);
change_exit(ch, buf, door);
return TRUE;
}
if (!str_cmp(command, "room"))
{
ROOM_INDEX_DATA *toRoom;
if (arg[0] == '\0' || !is_number(arg))
{
chprintln(ch, "Syntax: [direction] room [vnum]");
return FALSE;
}
value = atol(arg);
if (!(toRoom = get_room_index(value)))
{
chprintln(ch, "REdit: Cannot link to non-existant room.");
return FALSE;
}
if (!pRoom->exit[door])
pRoom->exit[door] = new_exit();
pRoom->exit[door]->u1.to_room = toRoom; /* ROM OLC */
pRoom->exit[door]->orig_door = door;
chprintln(ch, "One-way link established.");
return TRUE;
}
if (!str_cmp(command, "key"))
{
OBJ_INDEX_DATA *key;
if (arg[0] == '\0' || !is_number(arg))
{
chprintln(ch, "Syntax: [direction] key [vnum]");
return FALSE;
}
if (!pRoom->exit[door])
{
chprintln(ch, "Salida no existe.");
return FALSE;
}
value = atol(arg);
if (!(key = get_obj_index(value)))
{
chprintln(ch, "REdit: Key doesn't exist.");
return FALSE;
}
if (key->item_type != ITEM_KEY)
{
chprintln(ch, "REdit: Objeto no es llave.");
return FALSE;
}
pRoom->exit[door]->key = value;
chprintln(ch, "Exit key set.");
return TRUE;
}
if (!str_cmp(command, "name"))
{
if (arg[0] == '\0')
{
chprintln(ch, "Syntax: [direction] name [string]");
chprintln(ch, " [direction] name none");
return FALSE;
}
if (!pRoom->exit[door])
{
chprintln(ch, "Salida no existe.");
return FALSE;
}
free_string(pRoom->exit[door]->keyword);
if (str_cmp(arg, "none"))
pRoom->exit[door]->keyword = str_dup(arg);
else
pRoom->exit[door]->keyword = str_dup("");
chprintln(ch, "Exit name set.");
return TRUE;
}
if (!str_prefix(command, "description"))
{
if (arg[0] == '\0')
{
if (!pRoom->exit[door])
{
chprintln(ch, "Salida no existe.");
return FALSE;
}
string_append(ch, &pRoom->exit[door]->description);
return TRUE;
}
chprintln(ch, "Syntax: [direction] desc");
return FALSE;
}
return FALSE;
}
REDIT(redit_create)
{
AREA_DATA *pArea;
ROOM_INDEX_DATA *pRoom;
vnum_t value;
int iHash;
EDIT_ROOM(ch, pRoom);
value = atol(argument);
if (argument[0] == '\0' || value <= 0)
{
chprintln(ch, "Syntax: create [vnum > 0]");
return FALSE;
}
pArea = get_vnum_area(value);
if (!pArea)
{
chprintln(ch, "REdit: That vnum is not assigned an area.");
return FALSE;
}
if (!IS_BUILDER(ch, pArea))
{
chprintln(ch, "REdit: Vnum in an area you cannot build in.");
return FALSE;
}
if (get_room_index(value))
{
chprintln(ch, "REdit: Room vnum already exists.");
return FALSE;
}
pRoom = new_room_index();
pRoom->area = pArea;
pRoom->vnum = value;
if (value > top_vnum_room)
top_vnum_room = value;
iHash = value % MAX_KEY_HASH;
LINK_SINGLE(pRoom, next, room_index_hash[iHash]);
edit_start(ch, pRoom, ED_ROOM);
chprintln(ch, "Room created.");
return TRUE;
}
REDIT(redit_clan)
{
ROOM_INDEX_DATA *pRoom;
EDIT_ROOM(ch, pRoom);
pRoom->clan = clan_lookup(argument);
chprintln(ch, "Clan set.");
return TRUE;
}
REDIT(redit_mreset)
{
ROOM_INDEX_DATA *pRoom;
MOB_INDEX_DATA *pMobIndex;
CHAR_DATA *newmob;
char arg[MAX_INPUT_LENGTH];
char arg2[MAX_INPUT_LENGTH];
RESET_DATA *pReset;
EDIT_ROOM(ch, pRoom);
argument = one_argument(argument, arg);
argument = one_argument(argument, arg2);
if (arg[0] == '\0' || !is_number(arg))
{
chprintln(ch, "Syntax: mreset <vnum> <max #x> <mix #x>");
return FALSE;
}
if (!(pMobIndex = get_mob_index(atol(arg))))
{
chprintln(ch, "REdit: No mobile has that vnum.");
return FALSE;
}
if (pMobIndex->area != pRoom->area)
{
chprintln(ch, "REdit: No such mobile in this area.");
return FALSE;
}
/*
* Create the mobile reset.
*/
pReset = new_reset_data();
pReset->command = 'M';
pReset->arg1 = pMobIndex->vnum;
pReset->arg2 = is_number(arg2) ? atoi(arg2) : MAX_MOB;
pReset->arg3 = pRoom->vnum;
pReset->arg4 = is_number(argument) ? atoi(argument) : 1;
add_reset(pRoom, pReset, 0 /* Last slot */ );
/*
* Create the mobile.
*/
newmob = create_mobile(pMobIndex);
char_to_room(newmob, pRoom);
chprintlnf(ch,
"%s (%ld) has been loaded and added to resets.\n\r"
"There will be a maximum of %d loaded to this room.",
capitalize(pMobIndex->short_descr), pMobIndex->vnum,
pReset->arg2);
act("$n has created $N!", ch, NULL, newmob, TO_ROOM);
return TRUE;
}
struct wear_type
{
int wear_loc;
int wear_bit;
};
const struct wear_type wear_table[] = {
{WEAR_NONE, ITEM_TAKE},
{WEAR_LIGHT, ITEM_LIGHT},
{WEAR_FINGER_L, ITEM_WEAR_FINGER},
{WEAR_FINGER_R, ITEM_WEAR_FINGER},
{WEAR_NECK_1, ITEM_WEAR_NECK},
{WEAR_NECK_2, ITEM_WEAR_NECK},
{WEAR_BODY, ITEM_WEAR_BODY},
{WEAR_HEAD, ITEM_WEAR_HEAD},
{WEAR_LEGS, ITEM_WEAR_LEGS},
{WEAR_FEET, ITEM_WEAR_FEET},
{WEAR_HANDS, ITEM_WEAR_HANDS},
{WEAR_ARMS, ITEM_WEAR_ARMS},
{WEAR_SHIELD, ITEM_WEAR_SHIELD},
{WEAR_ABOUT, ITEM_WEAR_ABOUT},
{WEAR_WAIST, ITEM_WEAR_WAIST},
{WEAR_WRIST_L, ITEM_WEAR_WRIST},
{WEAR_WRIST_R, ITEM_WEAR_WRIST},
{WEAR_WIELD, ITEM_WIELD},
{WEAR_HOLD, ITEM_HOLD},
{-2, -2}
};
/*****************************************************************************
Name: wear_loc
Purpose: Returns the location of the bit that matches the count.
1 = first match, 2 = second match etc.
Called by: oedit_reset(olc_act.c).
****************************************************************************/
int wear_loc(flag_t bits, int count)
{
int flag;
for (flag = 0; wear_table[flag].wear_bit != -2; flag++)
{
if (IS_SET(bits, wear_table[flag].wear_bit) && --count < 1)
return wear_table[flag].wear_loc;
}
return 0;
}
/*****************************************************************************
Name: wear_bit
Purpose: Converts a wear_loc into a bit.
Called by: redit_oreset(olc_act.c).
****************************************************************************/
flag_t wear_bit(int loc)
{
int flag;
for (flag = 0; wear_table[flag].wear_loc != -2; flag++)
{
if (loc == wear_table[flag].wear_loc)
return wear_table[flag].wear_bit;
}
return 0;
}
REDIT(redit_oreset)
{
ROOM_INDEX_DATA *pRoom;
OBJ_INDEX_DATA *pObjIndex;
OBJ_DATA *newobj;
OBJ_DATA *to_obj;
CHAR_DATA *to_mob;
char arg1[MAX_INPUT_LENGTH];
char arg2[MAX_INPUT_LENGTH];
int olevel = 0;
RESET_DATA *pReset;
EDIT_ROOM(ch, pRoom);
argument = one_argument(argument, arg1);
argument = one_argument(argument, arg2);
if (arg1[0] == '\0' || !is_number(arg1))
{
chprintln(ch, "Syntax: oreset <vnum> <args>");
chprintln(ch, " -no_args = into room");
chprintln(ch, " -<obj_name> = into obj");
chprintln(ch, " -<mob_name> <wear_loc> = into mob");
return FALSE;
}
if (!(pObjIndex = get_obj_index(atol(arg1))))
{
chprintln(ch, "REdit: No object has that vnum.");
return FALSE;
}
if (pObjIndex->area != pRoom->area)
{
chprintln(ch, "REdit: No such object in this area.");
return FALSE;
}
/*
* Load into room.
*/
if (arg2[0] == '\0')
{
pReset = new_reset_data();
pReset->command = 'O';
pReset->arg1 = pObjIndex->vnum;
pReset->arg2 = 0;
pReset->arg3 = pRoom->vnum;
pReset->arg4 = 0;
add_reset(pRoom, pReset, 0 /* Last slot */ );
newobj = create_object(pObjIndex, number_fuzzy(olevel));
obj_to_room(newobj, pRoom);
chprintlnf(ch,
"%s (%ld) has been loaded and added to resets.",
capitalize(pObjIndex->short_descr), pObjIndex->vnum);
}
else
/*
* Load into object's inventory.
*/
if (argument[0] == '\0' &&
((to_obj = get_obj_list(ch, arg2, pRoom->first_content)) != NULL))
{
pReset = new_reset_data();
pReset->command = 'P';
pReset->arg1 = pObjIndex->vnum;
pReset->arg2 = 0;
pReset->arg3 = to_obj->pIndexData->vnum;
pReset->arg4 = 1;
add_reset(pRoom, pReset, 0 /* Last slot */ );
newobj = create_object(pObjIndex, number_fuzzy(olevel));
newobj->cost = 0;
obj_to_obj(newobj, to_obj);
chprintlnf(ch,
"%s (%ld) has been loaded into "
"%s (%ld) and added to resets.",
capitalize(newobj->short_descr),
newobj->pIndexData->vnum, to_obj->short_descr,
to_obj->pIndexData->vnum);
}
else
/*
* Load into mobile's inventory.
*/
if ((to_mob = get_char_room(ch, NULL, arg2)) != NULL)
{
int pwear_loc = -1;
/*
* Make sure the location on mobile is valid.
*/
if ((pwear_loc = flag_value(wear_loc_flags, argument)) == NO_FLAG)
{
chprintln(ch, "REdit: Invalid wear_loc. '? wear-loc'");
return FALSE;
}
/*
* Disallow loading a sword(WEAR_WIELD) into WEAR_HEAD.
*/
if (!IS_SET(pObjIndex->wear_flags, wear_bit(pwear_loc)))
{
chprintlnf(ch, "%s (%ld) has wear flags: [%s]",
capitalize(pObjIndex->short_descr),
pObjIndex->vnum, flag_string(wear_flags,
pObjIndex->wear_flags));
return FALSE;
}
/*
* Can't load into same position.
*/
if (get_eq_char(to_mob, pwear_loc))
{
chprintln(ch, "REdit: Object already equipped.");
return FALSE;
}
pReset = new_reset_data();
pReset->arg1 = pObjIndex->vnum;
pReset->arg2 = pwear_loc;
pReset->arg3 = pwear_loc;
if (pReset->arg2 == WEAR_NONE)
pReset->command = 'G';
else
pReset->command = 'E';
add_reset(pRoom, pReset, 0 /* Last slot */ );
olevel = URANGE(0, to_mob->level - 2, LEVEL_HERO);
newobj = create_object(pObjIndex, number_fuzzy(olevel));
if (to_mob->pIndexData->pShop) /* Shop-keeper? */
{
switch (pObjIndex->item_type)
{
default:
olevel = 0;
break;
case ITEM_PILL:
olevel = number_range(0, 10);
break;
case ITEM_POTION:
olevel = number_range(0, 10);
break;
case ITEM_SCROLL:
olevel = number_range(5, 15);
break;
case ITEM_WAND:
olevel = number_range(10, 20);
break;
case ITEM_STAFF:
olevel = number_range(15, 25);
break;
case ITEM_ARMOR:
olevel = number_range(5, 15);
break;
case ITEM_WEAPON:
if (pReset->command == 'G')
olevel = number_range(5, 15);
else
olevel = number_fuzzy(olevel);
break;
}
newobj = create_object(pObjIndex, olevel);
if (pReset->arg2 == WEAR_NONE)
SET_BIT(newobj->extra_flags, ITEM_INVENTORY);
}
else
newobj = create_object(pObjIndex, number_fuzzy(olevel));
obj_to_char(newobj, to_mob);
if (pReset->command == 'E')
equip_char(to_mob, newobj, pReset->arg3);
chprintlnf(ch,
"%s (%ld) has been loaded "
"%s of %s (%ld) and added to resets.",
capitalize(pObjIndex->short_descr), pObjIndex->vnum,
flag_string(wear_loc_strings, pReset->arg3),
to_mob->short_descr, to_mob->pIndexData->vnum);
}
else /* Display Syntax */
{
chprintln(ch, "REdit: That mobile isn't here.");
return FALSE;
}
act("$n has created $p!", ch, newobj, NULL, TO_ROOM);
return TRUE;
}
/*
* Object Editor Functions.
*/
void show_obj_values(CHAR_DATA * ch, OBJ_INDEX_DATA * obj)
{
switch (obj->item_type)
{
default: /* No values. */
break;
case ITEM_LIGHT:
if (obj->value[2] == -1 || obj->value[2] == 999) /* ROM OLC */
chprintln(ch, "[v2] Light: Infinite[-1]");
else
chprintlnf(ch, "[v2] Light: [%ld]", obj->value[2]);
break;
case ITEM_WAND:
case ITEM_STAFF:
chprintlnf(ch,
"[v0] Level: [%ld]\n\r"
"[v1] Charges Total: [%ld]\n\r"
"[v2] Charges Left: [%ld]\n\r"
"[v3] Spell: %s", obj->value[0],
obj->value[1], obj->value[2],
obj->value[3] !=
-1 ? skill_table[obj->value[3]].name : "none");
break;
case ITEM_PORTAL:
chprintlnf(ch,
"[v0] Charges: [%ld]\n\r"
"[v1] Exit Flags: %s\n\r"
"[v2] Portal Flags: %s\n\r"
"[v3] Goes to (vnum): [%ld]", obj->value[0],
flag_string(exit_flags, obj->value[1]),
flag_string(portal_flags, obj->value[2]), obj->value[3]);
break;
case ITEM_FURNITURE:
chprintlnf(ch,
"[v0] Max people: [%ld]\n\r"
"[v1] Max weight: [%ld]\n\r"
"[v2] Furniture Flags: %s\n\r"
"[v3] Heal bonus: [%ld]\n\r"
"[v4] Mana bonus: [%ld]", obj->value[0],
obj->value[1], flag_string(furniture_flags,
obj->value[2]),
obj->value[3], obj->value[4]);
break;
case ITEM_SCROLL:
case ITEM_POTION:
case ITEM_PILL:
chprintlnf(ch,
"[v0] Level: [%ld]\n\r" "[v1] Spell: %s\n\r"
"[v2] Spell: %s\n\r" "[v3] Spell: %s\n\r"
"[v4] Spell: %s", obj->value[0],
obj->value[1] !=
-1 ? skill_table[obj->value[1]].name : "none",
obj->value[2] !=
-1 ? skill_table[obj->value[2]].name : "none",
obj->value[3] !=
-1 ? skill_table[obj->value[3]].name : "none",
obj->value[4] !=
-1 ? skill_table[obj->value[4]].name : "none");
break;
/* ARMOR for ROM */
case ITEM_ARMOR:
chprintlnf(ch,
"[v0] Ac pierce [%ld]\n\r"
"[v1] Ac bash [%ld]\n\r"
"[v2] Ac slash [%ld]\n\r"
"[v3] Ac exotic [%ld]", obj->value[0],
obj->value[1], obj->value[2], obj->value[3]);
break;
/* WEAPON changed in ROM: */
/* I had to split the output here, I have no idea why, but it helped -- Hugin */
/* It somehow fixed a bug in showing scroll/pill/potions too ?! */
case ITEM_WEAPON:
chprintlnf(ch, "[v0] Weapon class: %s",
flag_string(weapon_class, obj->value[0]));
chprintlnf(ch, "[v1] Number of dice: [%ld]", obj->value[1]);
chprintlnf(ch, "[v2] Type of dice: [%ld]", obj->value[2]);
chprintlnf(ch, "[v3] Type: %s",
attack_table[obj->value[3]].name);
chprintlnf(ch, "[v4] Special type: %s",
flag_string(weapon_type2, obj->value[4]));
break;
case ITEM_CONTAINER:
chprintlnf(ch,
"[v0] Weight: [%ld kg]\n\r"
"[v1] Flags: [%s]\n\r" "[v2] Key: %s [%ld]\n\r"
"[v3] Capacity [%ld]\n\r"
"[v4] Weight Mult [%ld]", obj->value[0],
flag_string(container_flags, obj->value[1]),
get_obj_index(obj->value[2]) ? get_obj_index(obj->value
[2])->short_descr
: "none", obj->value[2], obj->value[3], obj->value[4]);
break;
case ITEM_DRINK_CON:
chprintlnf(ch,
"[v0] Liquid Total: [%ld]\n\r"
"[v1] Liquid Left: [%ld]\n\r"
"[v2] Liquid: %s\n\r" "[v3] Poisoned: %s",
obj->value[0], obj->value[1],
liq_table[obj->value[2]].liq_name,
obj->value[3] != 0 ? "Yes" : "No");
break;
case ITEM_FOUNTAIN:
chprintlnf(ch,
"[v0] Liquid Total: [%ld]\n\r"
"[v1] Liquid Left: [%ld]\n\r"
"[v2] Liquid: %s", obj->value[0],
obj->value[1], liq_table[obj->value[2]].liq_name);
break;
case ITEM_FOOD:
chprintlnf(ch,
"[v0] Food hours: [%ld]\n\r"
"[v1] Full hours: [%ld]\n\r" "[v3] Poisoned: %s",
obj->value[0], obj->value[1],
obj->value[3] != 0 ? "Yes" : "No");
break;
case ITEM_MONEY:
chprintlnf(ch, "[v0] Gold: [%ld]", obj->value[0]);
break;
}
return;
}
bool set_obj_values(CHAR_DATA * ch, OBJ_INDEX_DATA * pObj, int value_num,
const char *argument)
{
switch (pObj->item_type)
{
default:
break;
case ITEM_LIGHT:
switch (value_num)
{
default:
do_oldhelp(ch, "ITEM_LIGHT");
return FALSE;
case 2:
chprintln(ch, "HOURS OF LIGHT SET.\n\r");
pObj->value[2] = atol(argument);
break;
}
break;
case ITEM_WAND:
case ITEM_STAFF:
switch (value_num)
{
default:
do_oldhelp(ch, "ITEM_STAFF_WAND");
return FALSE;
case 0:
chprintln(ch, "SPELL LEVEL SET.\n\r");
pObj->value[0] = atol(argument);
break;
case 1:
chprintln(ch, "TOTAL NUMBER OF CHARGES SET.\n\r");
pObj->value[1] = atol(argument);
break;
case 2:
chprintln(ch, "CURRENT NUMBER OF CHARGES SET.\n\r");
pObj->value[2] = atol(argument);
break;
case 3:
chprintln(ch, "SPELL TYPE SET.");
pObj->value[3] = skill_lookup(argument);
break;
}
break;
case ITEM_SCROLL:
case ITEM_POTION:
case ITEM_PILL:
switch (value_num)
{
default:
do_oldhelp(ch, "ITEM_SCROLL_POTION_PILL");
return FALSE;
case 0:
chprintln(ch, "SPELL LEVEL SET.\n\r");
pObj->value[0] = atol(argument);
break;
case 1:
chprintln(ch, "SPELL TYPE 1 SET.\n\r");
pObj->value[1] = skill_lookup(argument);
break;
case 2:
chprintln(ch, "SPELL TYPE 2 SET.\n\r");
pObj->value[2] = skill_lookup(argument);
break;
case 3:
chprintln(ch, "SPELL TYPE 3 SET.\n\r");
pObj->value[3] = skill_lookup(argument);
break;
case 4:
chprintln(ch, "SPELL TYPE 4 SET.\n\r");
pObj->value[4] = skill_lookup(argument);
break;
}
break;
/* ARMOR for ROM: */
case ITEM_ARMOR:
switch (value_num)
{
default:
do_oldhelp(ch, "ITEM_ARMOR");
return FALSE;
case 0:
chprintln(ch, "AC PIERCE SET.\n\r");
pObj->value[0] = atol(argument);
break;
case 1:
chprintln(ch, "AC BASH SET.\n\r");
pObj->value[1] = atol(argument);
break;
case 2:
chprintln(ch, "AC SLASH SET.\n\r");
pObj->value[2] = atol(argument);
break;
case 3:
chprintln(ch, "AC EXOTIC SET.\n\r");
pObj->value[3] = atol(argument);
break;
}
break;
/* WEAPONS changed in ROM */
case ITEM_WEAPON:
switch (value_num)
{
default:
do_oldhelp(ch, "ITEM_WEAPON");
return FALSE;
case 0:
chprintln(ch, "WEAPON CLASS SET.\n\r");
ALT_FLAGVALUE_SET(pObj->value[0], weapon_class, argument);
break;
case 1:
chprintln(ch, "NUMBER OF DICE SET.\n\r");
pObj->value[1] = atol(argument);
break;
case 2:
chprintln(ch, "TYPE OF DICE SET.\n\r");
pObj->value[2] = atol(argument);
break;
case 3:
chprintln(ch, "WEAPON TYPE SET.\n\r");
pObj->value[3] = attack_lookup(argument);
break;
case 4:
chprintln(ch, "SPECIAL WEAPON TYPE TOGGLED.\n\r");
ALT_FLAGVALUE_TOGGLE(pObj->value[4], weapon_type2, argument);
break;
}
break;
case ITEM_PORTAL:
switch (value_num)
{
default:
do_oldhelp(ch, "ITEM_PORTAL");
return FALSE;
case 0:
chprintln(ch, "CHARGES SET.\n\r");
pObj->value[0] = atol(argument);
break;
case 1:
chprintln(ch, "EXIT FLAGS SET.\n\r");
ALT_FLAGVALUE_SET(pObj->value[1], exit_flags, argument);
break;
case 2:
chprintln(ch, "PORTAL FLAGS SET.\n\r");
ALT_FLAGVALUE_SET(pObj->value[2], portal_flags, argument);
break;
case 3:
chprintln(ch, "EXIT vnum_t SET.\n\r");
pObj->value[3] = atol(argument);
break;
}
break;
case ITEM_FURNITURE:
switch (value_num)
{
default:
do_oldhelp(ch, "ITEM_FURNITURE");
return FALSE;
case 0:
chprintln(ch, "NUMBER OF PEOPLE SET.\n\r");
pObj->value[0] = atol(argument);
break;
case 1:
chprintln(ch, "MAX WEIGHT SET.\n\r");
pObj->value[1] = atol(argument);
break;
case 2:
chprintln(ch, "FURNITURE FLAGS TOGGLED.\n\r");
ALT_FLAGVALUE_TOGGLE(pObj->value[2], furniture_flags, argument);
break;
case 3:
chprintln(ch, "HEAL BONUS SET.\n\r");
pObj->value[3] = atol(argument);
break;
case 4:
chprintln(ch, "MANA BONUS SET.\n\r");
pObj->value[4] = atol(argument);
break;
}
break;
case ITEM_CONTAINER:
switch (value_num)
{
flag_t value;
default:
do_oldhelp(ch, "ITEM_CONTAINER");
return FALSE;
case 0:
chprintln(ch, "WEIGHT CAPACITY SET.\n\r");
pObj->value[0] = atol(argument);
break;
case 1:
if ((value = flag_value(container_flags, argument)) != NO_FLAG)
TOGGLE_BIT(pObj->value[1], value);
else
{
do_oldhelp(ch, "ITEM_CONTAINER");
return FALSE;
}
chprintln(ch, "CONTAINER TYPE SET.\n\r");
break;
case 2:
if (atol(argument) != 0)
{
if (!get_obj_index(atol(argument)))
{
chprintln(ch, "THERE IS NO SUCH ITEM.\n\r");
return FALSE;
}
if (get_obj_index(atol(argument))->item_type != ITEM_KEY)
{
chprintln(ch, "THAT ITEM IS NOT A KEY.\n\r");
return FALSE;
}
}
chprintln(ch, "CONTAINER KEY SET.\n\r");
pObj->value[2] = atol(argument);
break;
case 3:
chprintln(ch, "CONTAINER MAX WEIGHT SET.");
pObj->value[3] = atol(argument);
break;
case 4:
chprintln(ch, "WEIGHT MULTIPLIER SET.\n\r");
pObj->value[4] = atol(argument);
break;
}
break;
case ITEM_DRINK_CON:
switch (value_num)
{
default:
do_oldhelp(ch, "ITEM_DRINK");
/* OLC do_oldhelp( ch, "liquids" ); */
return FALSE;
case 0:
chprintln(ch, "MAXIMUM AMOUT OF LIQUID HOURS SET.\n\r");
pObj->value[0] = atol(argument);
break;
case 1:
chprintln(ch, "CURRENT AMOUNT OF LIQUID HOURS SET.\n\r");
pObj->value[1] = atol(argument);
break;
case 2:
chprintln(ch, "LIQUID TYPE SET.\n\r");
pObj->value[2] =
(liq_lookup(argument) != -1 ? liq_lookup(argument) : 0);
break;
case 3:
chprintln(ch, "POISON VALUE TOGGLED.\n\r");
pObj->value[3] = (pObj->value[3] == 0) ? 1 : 0;
break;
}
break;
case ITEM_FOUNTAIN:
switch (value_num)
{
default:
do_oldhelp(ch, "ITEM_FOUNTAIN");
/* OLC do_oldhelp( ch, "liquids" ); */
return FALSE;
case 0:
chprintln(ch, "MAXIMUM AMOUT OF LIQUID HOURS SET.\n\r");
pObj->value[0] = atol(argument);
break;
case 1:
chprintln(ch, "CURRENT AMOUNT OF LIQUID HOURS SET.\n\r");
pObj->value[1] = atol(argument);
break;
case 2:
chprintln(ch, "LIQUID TYPE SET.\n\r");
pObj->value[2] =
(liq_lookup(argument) != -1 ? liq_lookup(argument) : 0);
break;
}
break;
case ITEM_FOOD:
switch (value_num)
{
default:
do_oldhelp(ch, "ITEM_FOOD");
return FALSE;
case 0:
chprintln(ch, "HOURS OF FOOD SET.\n\r");
pObj->value[0] = atol(argument);
break;
case 1:
chprintln(ch, "HOURS OF FULL SET.\n\r");
pObj->value[1] = atol(argument);
break;
case 3:
chprintln(ch, "POISON VALUE TOGGLED.\n\r");
pObj->value[3] = (pObj->value[3] == 0) ? 1 : 0;
break;
}
break;
case ITEM_MONEY:
switch (value_num)
{
default:
do_oldhelp(ch, "ITEM_MONEY");
return FALSE;
case 0:
chprintln(ch, "GOLD AMOUNT SET.\n\r");
pObj->value[0] = atol(argument);
break;
case 1:
chprintln(ch, "SILVER AMOUNT SET.\n\r");
pObj->value[1] = atol(argument);
break;
}
break;
}
show_obj_values(ch, pObj);
return TRUE;
}
OEDIT(oedit_show)
{
OBJ_INDEX_DATA *pObj;
AFFECT_DATA *paf;
int cnt;
PROG_LIST *list;
EDIT_OBJ(ch, pObj);
chprintf(ch, "%s\n\r",
stringf(ch, 0, ALIGN_CENTER, "-",
FORMATF("[ %s: %s ]", olc_ed_name(ch), olc_ed_vnum(ch))));
chprintlnf(ch, "Name: [%s]\n\rArea: [%5d] %s",
pObj->name, !pObj->area ? -1 : pObj->area->vnum,
!pObj->area ? "No Area" : pObj->area->name);
chprintlnf(ch, "Vnum: [%5ld]\n\rType: [%s]", pObj->vnum,
flag_string(type_flags, pObj->item_type));
chprintlnf(ch, "Level: [%5d]", pObj->level);
chprintlnf(ch, "Wear flags: [%s]",
flag_string(wear_flags, pObj->wear_flags));
chprintlnf(ch, "Extra flags: [%s]",
flag_string(extra_flags, pObj->extra_flags));
chprintlnf(ch, "Material: [%s]", /* ROM */
pObj->material);
chprintlnf(ch, "Condition: [%5d]", /* ROM */
pObj->condition);
chprintlnf(ch, "Weight: [%5d]\n\rCost: [%5d]",
pObj->weight, pObj->cost);
if (pObj->first_extra_descr)
{
EXTRA_DESCR_DATA *ed;
chprint(ch, "Ex desc kwd: ");
for (ed = pObj->first_extra_descr; ed; ed = ed->next)
{
chprint(ch, "[");
chprint(ch, ed->keyword);
chprint(ch, "]");
}
chprintln(ch, "");
}
chprintlnf(ch, "Short desc: %s\n\rLong desc:\n\r %s",
pObj->short_descr, pObj->description);
for (cnt = 0, paf = pObj->first_affect; paf; paf = paf->next)
{
if (cnt == 0)
{
chprintln(ch, "Number Modifier Affects");
chprintln(ch, "------ -------- -------");
}
chprintlnf(ch, "[%4d] %-8d %s", cnt, paf->modifier,
flag_string(apply_flags, paf->location));
cnt++;
}
show_obj_values(ch, pObj);
chprintln(ch, draw_line(ch, NULL, 0));
if (pObj->first_oprog)
{
int cnt;
chprintlnf(ch, "\n\rOBJPrograms for [%5ld]:", pObj->vnum);
for (cnt = 0, list = pObj->first_oprog; list; list = list->next)
{
if (cnt == 0)
{
chprintln(ch, " Number Vnum Trigger Phrase");
chprintln(ch, " ------ ---- ------- ------");
}
chprintlnf(ch, "[%5d] %4ld %7s %s", cnt,
list->vnum, prog_type_to_name(list->trig_type),
list->trig_phrase);
cnt++;
}
}
return FALSE;
}
/*
* Need to issue warning if flag_t isn't valid. -- does so now -- Hugin.
*/
OEDIT(oedit_addaffect)
{
int value;
OBJ_INDEX_DATA *pObj;
AFFECT_DATA *pAf;
char loc[MAX_STRING_LENGTH];
char mod[MAX_STRING_LENGTH];
EDIT_OBJ(ch, pObj);
argument = one_argument(argument, loc);
one_argument(argument, mod);
if (loc[0] == '\0' || mod[0] == '\0' || !is_number(mod))
{
chprintln(ch, "Syntax: addaffect [location] [#xmod]");
return FALSE;
}
if ((value = flag_value(apply_flags, loc)) == NO_FLAG) /* Hugin */
{
chprintln(ch, "Valid affects are:");
show_help(ch, "apply");
return FALSE;
}
pAf = new_affect();
pAf->location = value;
pAf->modifier = atoi(mod);
pAf->where = TO_OBJECT;
pAf->type = -1;
pAf->duration = -1;
pAf->bitvector = 0;
pAf->level = pObj->level;
LINK(pAf, pObj->first_affect, pObj->last_affect, next, prev);
chprintln(ch, "Affect added.");
return TRUE;
}
OEDIT(oedit_delete)
{
OBJ_DATA *obj, *obj_next;
OBJ_INDEX_DATA *pObj;
RESET_DATA *pReset, *wReset;
ROOM_INDEX_DATA *pRoom;
char arg[MIL];
vnum_t pIndex, i;
int rcount, ocount, iHash;
if (IS_NULLSTR(argument))
{
if (ch)
chprintln(ch, "Syntax: oedit delete [vnum]");
return FALSE;
}
one_argument(argument, arg);
if (is_number(arg))
{
pIndex = atol(arg);
pObj = get_obj_index(pIndex);
}
else
{
if (ch)
chprintln(ch, "That is not a number.");
return FALSE;
}
for (i = 0; vnum_table[i].vnum != -1; i++)
{
if (vnum_table[i].type != VNUM_OBJ)
continue;
if (vnum_table[i].vnum == pIndex)
{
if (ch)
chprintln(ch, "That vnum is reserved.");
return FALSE;
}
}
if (!pObj)
{
if (ch)
chprintln(ch, "No such object.");
return FALSE;
}
stop_editing(pObj);
SET_BIT(pObj->area->area_flags, AREA_CHANGED);
if (top_vnum_obj == pIndex)
for (i = 1; i < pIndex; i++)
if (get_obj_index(i))
top_vnum_obj = i;
top_obj_index--;
ocount = 0;
for (obj = object_first; obj; obj = obj_next)
{
obj_next = obj->next;
if (obj->pIndexData == pObj)
{
extract_obj(obj);
ocount++;
}
}
rcount = 0;
for (iHash = 0; iHash < MAX_KEY_HASH; iHash++)
{
for (pRoom = room_index_hash[iHash]; pRoom; pRoom = pRoom->next)
{
for (pReset = pRoom->reset_first; pReset; pReset = wReset)
{
wReset = pReset->next;
switch (pReset->command)
{
case 'O':
case 'E':
case 'P':
case 'G':
if ((pReset->arg1 == pIndex) ||
((pReset->command == 'P') && (pReset->arg3 == pIndex)))
{
unlink_reset(pRoom, pReset);
free_reset_data(pReset);
rcount++;
SET_BIT(pRoom->area->area_flags, AREA_CHANGED);
}
}
}
}
}
unlink_obj_index(pObj);
pObj->area = NULL;
pObj->vnum = 0;
free_obj_index(pObj);
if (ch)
{
chprintf(ch,
"Removed object vnum {C%ld{x and" " {C%d{x resets.\n\r",
pIndex, rcount);
chprintf(ch,
"{C%d{x occurences of the object"
" were extracted from the mud.\n\r", ocount);
}
return TRUE;
}
OEDIT(oedit_addapply)
{
int value, typ;
flag_t bv;
OBJ_INDEX_DATA *pObj;
AFFECT_DATA *pAf;
char loc[MAX_STRING_LENGTH];
char mod[MAX_STRING_LENGTH];
char type[MAX_STRING_LENGTH];
char bvector[MAX_STRING_LENGTH];
EDIT_OBJ(ch, pObj);
argument = one_argument(argument, type);
argument = one_argument(argument, loc);
argument = one_argument(argument, mod);
one_argument(argument, bvector);
if (type[0] == '\0' || (typ = flag_value(apply_types, type)) == NO_FLAG)
{
chprintln(ch, "Invalid apply type. Valid apply types are:");
show_help(ch, "apptype");
return FALSE;
}
if (loc[0] == '\0' || (value = flag_value(apply_flags, loc)) == NO_FLAG)
{
chprintln(ch, "Valid applys are:");
show_help(ch, "apply");
return FALSE;
}
if (bvector[0] == '\0' ||
(bv = flag_value(bitvector_type[typ].table, bvector)) == NO_FLAG)
{
chprintln(ch, "Invalid bitvector type.");
chprintln(ch, "Valid bitvector types are:");
show_help(ch, bitvector_type[typ].help);
return FALSE;
}
if (mod[0] == '\0' || !is_number(mod))
{
chprintln(ch,
"Syntax: addapply [type] [location] [#xmod] [bitvector]");
return FALSE;
}
pAf = new_affect();
pAf->location = value;
pAf->modifier = atoi(mod);
pAf->where = apply_types[typ].bit;
pAf->type = -1;
pAf->duration = -1;
pAf->bitvector = bv;
pAf->level = pObj->level;
LINK(pAf, pObj->first_affect, pObj->last_affect, next, prev);
chprintln(ch, "Apply added.");
return TRUE;
}
/*
* My thanks to Hans Hvidsten Birkeland and Noam Krendel(Walker)
* for really teaching me how to manipulate pointers.
*/
OEDIT(oedit_delaffect)
{
OBJ_INDEX_DATA *pObj;
AFFECT_DATA *pAf;
char affect[MAX_STRING_LENGTH];
int value;
int cnt = 0;
EDIT_OBJ(ch, pObj);
one_argument(argument, affect);
if (!is_number(affect) || affect[0] == '\0')
{
chprintln(ch, "Syntax: delaffect [#xaffect]");
return FALSE;
}
value = atoi(affect);
if (value < 0)
{
chprintln(ch, "Only non-negative affect-numbers allowed.");
return FALSE;
}
for (pAf = pObj->first_affect; pAf != NULL; pAf = pAf->next)
if (++cnt == value)
break;
if (!pAf)
{
chprintln(ch, "OEdit: Non-existant affect.");
return FALSE;
}
UNLINK(pAf, pObj->first_affect, pObj->last_affect, next, prev);
free_affect(pAf);
chprintln(ch, "Affect removed.");
return TRUE;
}
bool set_value(CHAR_DATA * ch, OBJ_INDEX_DATA * pObj, const char *argument,
int value)
{
if (argument[0] == '\0')
{
set_obj_values(ch, pObj, -1, ""); /* '\0' changed to "" -- Hugin */
return FALSE;
}
if (set_obj_values(ch, pObj, value, argument))
return TRUE;
return FALSE;
}
/*****************************************************************************
Name: oedit_values
Purpose: Finds the object and sets its value.
Called by: The four valueX functions below. (now five -- Hugin )
****************************************************************************/
bool oedit_values(CHAR_DATA * ch, const char *argument, int value)
{
OBJ_INDEX_DATA *pObj;
EDIT_OBJ(ch, pObj);
if (set_value(ch, pObj, argument, value))
return TRUE;
return FALSE;
}
OEDIT(oedit_create)
{
OBJ_INDEX_DATA *pObj;
AREA_DATA *pArea;
vnum_t value;
int iHash;
value = atol(argument);
if (argument[0] == '\0' || value == 0)
{
chprintln(ch, "Syntax: oedit create [vnum]");
return FALSE;
}
pArea = get_vnum_area(value);
if (!pArea)
{
chprintln(ch, "OEdit: That vnum is not assigned an area.");
return FALSE;
}
if (!IS_BUILDER(ch, pArea))
{
chprintln(ch, "OEdit: Vnum in an area you cannot build in.");
return FALSE;
}
if (get_obj_index(value))
{
chprintln(ch, "OEdit: Object vnum already exists.");
return FALSE;
}
pObj = new_obj_index();
pObj->vnum = value;
pObj->area = pArea;
if (value > top_vnum_obj)
top_vnum_obj = value;
iHash = value % MAX_KEY_HASH;
LINK_SINGLE(pObj, next, obj_index_hash[iHash]);
edit_start(ch, pObj, ED_OBJECT);
chprintln(ch, "Object Created.");
return TRUE;
}
/*
* Mobile Editor Functions.
*/
MEDIT(medit_show)
{
MOB_INDEX_DATA *pMob;
PROG_LIST *list;
EDIT_MOB(ch, pMob);
chprintf(ch, "%s\n\r",
stringf(ch, 0, ALIGN_CENTER, "-",
FORMATF("[ %s: %s ]", olc_ed_name(ch), olc_ed_vnum(ch))));
chprintlnf(ch, "Name: [%s]\n\rArea: [%5d] %s",
pMob->player_name, !pMob->area ? -1 : pMob->area->vnum,
!pMob->area ? "No Area" : pMob->area->name);
chprintlnf(ch, "Act: [%s]", flag_string(act_flags, pMob->act));
chprintlnf(ch, "Vnum: [%5ld] Sex: [%s] Race: [%s]",
pMob->vnum,
pMob->sex == SEX_MALE ? "male " : pMob->sex ==
SEX_FEMALE ? "female " : pMob->sex ==
3 ? "random " : "neutral", pMob->race->name);
chprintlnf(ch,
"Level: [%2d] Align: [%4d] Hitroll: [%2d] Dam Type: [%s]",
pMob->level, pMob->alignment, pMob->hitroll,
attack_table[pMob->dam_type].name);
if (pMob->group)
{
chprintlnf(ch, "Group: [%5ld]", pMob->group);
}
chprintf(ch, "Hit dice: [%2dd%-3d+%4d] ", pMob->hit[DICE_NUMBER],
pMob->hit[DICE_TYPE], pMob->hit[DICE_BONUS]);
chprintf(ch, "Damage dice: [%2dd%-3d+%4d] ", pMob->damage[DICE_NUMBER],
pMob->damage[DICE_TYPE], pMob->damage[DICE_BONUS]);
chprintlnf(ch, "Mana dice: [%2dd%-3d+%4d]", pMob->mana[DICE_NUMBER],
pMob->mana[DICE_TYPE], pMob->mana[DICE_BONUS]);
/* ROM values end */
chprintlnf(ch, "Affected by: [%s]",
flag_string(affect_flags, pMob->affected_by));
/* ROM values: */
chprintlnf(ch,
"Armor: [pierce: %d bash: %d slash: %d magic: %d]",
pMob->ac[AC_PIERCE], pMob->ac[AC_BASH], pMob->ac[AC_SLASH],
pMob->ac[AC_EXOTIC]);
chprintlnf(ch, "Form: [%s]", flag_string(form_flags, pMob->form));
chprintlnf(ch, "Parts: [%s]", flag_string(part_flags, pMob->parts));
chprintlnf(ch, "Imm: [%s]",
flag_string(imm_flags, pMob->imm_flags));
chprintlnf(ch, "Res: [%s]",
flag_string(res_flags, pMob->res_flags));
chprintlnf(ch, "Vuln: [%s]",
flag_string(vuln_flags, pMob->vuln_flags));
chprintlnf(ch, "Off: [%s]",
flag_string(off_flags, pMob->off_flags));
chprintlnf(ch, "Size: [%s]", flag_string(size_flags, pMob->size));
chprintlnf(ch, "Material: [%s]", pMob->material);
chprintlnf(ch, "Start pos. [%s]",
flag_string(position_flags, pMob->start_pos));
chprintlnf(ch, "Default pos [%s]",
flag_string(position_flags, pMob->default_pos));
chprintlnf(ch, "Wealth: [%5ld]", pMob->wealth);
/* ROM values end */
if (pMob->spec_fun)
{
chprintlnf(ch, "Spec fun: [%s]", spec_name(pMob->spec_fun));
}
chprintf(ch, "Short descr: %s\n\rLong descr:\n\r%s", pMob->short_descr,
pMob->long_descr);
chprintf(ch, "Description:\n\r%s", pMob->description);
if (pMob->pShop)
{
SHOP_DATA *pShop;
int iTrade;
pShop = pMob->pShop;
chprintlnf(ch,
"Shop data for [%5ld]:\n\r"
" Markup for purchaser: %d%%\n\r"
" Markdown for seller: %d%%", pShop->keeper,
pShop->profit_buy, pShop->profit_sell);
chprintlnf(ch, " Hours: %d to %d.", pShop->open_hour,
pShop->close_hour);
for (iTrade = 0; iTrade < MAX_TRADE; iTrade++)
{
if (pShop->buy_type[iTrade] != 0)
{
if (iTrade == 0)
{
chprintln(ch, " Number Trades Type");
chprintln(ch, " ------ -----------");
}
chprintlnf(ch, " [%4d] %s", iTrade,
flag_string(type_flags, pShop->buy_type[iTrade]));
}
}
}
if (pMob->first_mprog)
{
int cnt;
chprintlnf(ch, "\n\rMOBPrograms for [%5ld]:", pMob->vnum);
for (cnt = 0, list = pMob->first_mprog; list; list = list->next)
{
if (cnt == 0)
{
chprintln(ch, " Number Vnum Trigger Phrase");
chprintln(ch, " ------ ---- ------- ------");
}
chprintlnf(ch, "[%5d] %4ld %7s %s", cnt, list->vnum,
prog_type_to_name(list->trig_type), list->trig_phrase);
cnt++;
}
}
chprintln(ch, draw_line(ch, NULL, 0));
return FALSE;
}
MEDIT(medit_create)
{
MOB_INDEX_DATA *pMob;
AREA_DATA *pArea;
vnum_t value;
int iHash;
value = atol(argument);
if (argument[0] == '\0' || value == 0)
{
chprintln(ch, "Syntax: medit create [vnum]");
return FALSE;
}
pArea = get_vnum_area(value);
if (!pArea)
{
chprintln(ch, "MEdit: That vnum is not assigned an area.");
return FALSE;
}
if (!IS_BUILDER(ch, pArea))
{
chprintln(ch, "MEdit: Vnum in an area you cannot build in.");
return FALSE;
}
if (get_mob_index(value))
{
chprintln(ch, "MEdit: Mobile vnum already exists.");
return FALSE;
}
pMob = new_mob_index();
pMob->vnum = value;
pMob->area = pArea;
if (value > top_vnum_mob)
top_vnum_mob = value;
pMob->act = ACT_IS_NPC;
iHash = value % MAX_KEY_HASH;
LINK_SINGLE(pMob, next, mob_index_hash[iHash]);
edit_start(ch, pMob, ED_MOBILE);
chprintln(ch, "Mobile Created.");
return TRUE;
}
MEDIT(medit_delete)
{
CHAR_DATA *wch, *wnext;
MOB_INDEX_DATA *pMob;
RESET_DATA *pReset, *wReset;
ROOM_INDEX_DATA *pRoom;
char arg[MIL];
vnum_t pIndex, i;
int mcount, rcount, iHash;
bool foundmob = FALSE;
bool foundobj = FALSE;
if (IS_NULLSTR(argument))
{
if (ch)
chprintln(ch, "Syntax: medit delete [vnum]");
return FALSE;
}
one_argument(argument, arg);
if (is_number(arg))
{
pIndex = atol(arg);
pMob = get_mob_index(pIndex);
}
else
{
if (ch)
chprintln(ch, "That is not a number.");
return FALSE;
}
for (i = 0; vnum_table[i].vnum != -1; i++)
{
if (vnum_table[i].type != VNUM_MOB)
continue;
if (vnum_table[i].vnum == pIndex)
{
if (ch)
chprintln(ch, "That vnum is reserved.");
return FALSE;
}
}
if (!pMob)
{
if (ch)
chprintln(ch, "No such mobile.");
return FALSE;
}
stop_editing(pMob);
SET_BIT(pMob->area->area_flags, AREA_CHANGED);
if (top_vnum_mob == pIndex)
for (i = 1; i < pIndex; i++)
if (get_mob_index(i))
top_vnum_mob = i;
top_mob_index--;
rcount = 0;
mcount = 0;
for (iHash = 0; iHash < MAX_KEY_HASH; iHash++)
{
for (pRoom = room_index_hash[iHash]; pRoom; pRoom = pRoom->next)
{
for (wch = pRoom->first_person; wch; wch = wnext)
{
wnext = wch->next_in_room;
if (wch->pIndexData == pMob)
{
extract_char(wch, TRUE);
mcount++;
}
}
for (pReset = pRoom->reset_first; pReset; pReset = wReset)
{
wReset = pReset->next;
switch (pReset->command)
{
case 'M':
if (pReset->arg1 == pIndex)
{
foundmob = TRUE;
unlink_reset(pRoom, pReset);
free_reset_data(pReset);
rcount++;
SET_BIT(pRoom->area->area_flags, AREA_CHANGED);
}
else
foundmob = FALSE;
break;
case 'E':
case 'G':
if (foundmob)
{
foundobj = TRUE;
unlink_reset(pRoom, pReset);
free_reset_data(pReset);
rcount++;
SET_BIT(pRoom->area->area_flags, AREA_CHANGED);
}
else
foundobj = FALSE;
break;
case '0':
foundobj = FALSE;
break;
case 'P':
if (foundobj && foundmob)
{
unlink_reset(pRoom, pReset);
free_reset_data(pReset);
rcount++;
SET_BIT(pRoom->area->area_flags, AREA_CHANGED);
}
}
}
}
}
unlink_mob_index(pMob);
pMob->area = NULL;
pMob->vnum = 0;
free_mob_index(pMob);
if (ch)
{
chprintf(ch,
"Removed mobile vnum {C%ld{x and {C%d{x resets.\n\r",
pIndex, rcount);
chprintf(ch,
"{C%d{x mobiles were extracted" " from the mud.\n\r", mcount);
}
return TRUE;
}
void show_liqlist(CHAR_DATA * ch)
{
int liq;
BUFFER *buffer;
char buf[MAX_STRING_LENGTH];
buffer = new_buf();
for (liq = 0; liq_table[liq].liq_name != NULL; liq++)
{
if ((liq % 21) == 0)
add_buf(buffer,
"Name Color Proof Full Thirst Food Ssize\n\r");
sprintf(buf, "%-20s %-14s %5d %4d %6d %4d %5d\n\r",
liq_table[liq].liq_name, liq_table[liq].liq_color,
liq_table[liq].liq_affect[0],
liq_table[liq].liq_affect[1],
liq_table[liq].liq_affect[2],
liq_table[liq].liq_affect[3], liq_table[liq].liq_affect[4]);
add_buf(buffer, buf);
}
page_to_char(buf_string(buffer), ch);
free_buf(buffer);
return;
}
void show_damlist(CHAR_DATA * ch)
{
int att;
BUFFER *buffer;
char buf[MAX_STRING_LENGTH];
buffer = new_buf();
for (att = 0; attack_table[att].name != NULL; att++)
{
if ((att % 21) == 0)
add_buf(buffer, "Name Noun\n\r");
sprintf(buf, "%-20s %-20s\n\r", attack_table[att].name,
attack_table[att].noun);
add_buf(buffer, buf);
}
page_to_char(buf_string(buffer), ch);
free_buf(buffer);
return;
}
MEDIT(medit_group)
{
MOB_INDEX_DATA *pMob;
MOB_INDEX_DATA *pMTemp;
char arg[MAX_STRING_LENGTH];
char buf[MAX_STRING_LENGTH];
int temp;
BUFFER *buffer;
bool found = FALSE;
EDIT_MOB(ch, pMob);
if (argument[0] == '\0')
{
chprintln(ch, "Syntax: group [number]");
chprintln(ch, " group show [number]");
return FALSE;
}
if (is_number(argument))
{
pMob->group = atol(argument);
chprintln(ch, "Group set.");
return TRUE;
}
argument = one_argument(argument, arg);
if (!str_cmp(arg, "show") && is_number(argument))
{
if (atol(argument) == 0)
{
chprintln(ch, "Are you crazy?");
return FALSE;
}
buffer = new_buf();
for (temp = 0; temp < 65536; temp++)
{
pMTemp = get_mob_index(temp);
if (pMTemp && (pMTemp->group == atol(argument)))
{
found = TRUE;
sprintf(buf, "[%5ld] %s\n\r", pMTemp->vnum,
pMTemp->player_name);
add_buf(buffer, buf);
}
}
if (found)
page_to_char(buf_string(buffer), ch);
else
chprintln(ch, "No mobs in that group.");
free_buf(buffer);
return FALSE;
}
return FALSE;
}
MEDIT(medit_addmprog)
{
flag_t value;
MOB_INDEX_DATA *pMob;
PROG_LIST *list;
PROG_CODE *code;
char trigger[MAX_STRING_LENGTH];
char phrase[MAX_STRING_LENGTH];
char num[MAX_STRING_LENGTH];
EDIT_MOB(ch, pMob);
argument = one_argument(argument, num);
argument = one_argument(argument, trigger);
argument = one_argument(argument, phrase);
if (!is_number(num) || trigger[0] == '\0' || phrase[0] == '\0')
{
chprintln(ch, "Syntax: addmprog [vnum] [trigger] [phrase]");
return FALSE;
}
if ((value = flag_value(mprog_flags, trigger)) == NO_FLAG)
{
chprintln(ch, "Valid flags are:");
show_help(ch, "mprog");
return FALSE;
}
if ((code = get_prog_index(atol(num), PRG_MPROG)) == NULL)
{
chprintln(ch, "No such MOBProgram.");
return FALSE;
}
list = new_prog();
list->vnum = atol(num);
list->trig_type = value;
list->trig_phrase = str_dup(phrase);
replace_string(list->code, code->code);
SET_BIT(pMob->mprog_flags, value);
LINK(list, pMob->first_mprog, pMob->last_mprog, next, prev);
chprintln(ch, "Mprog Added.");
return TRUE;
}
MEDIT(medit_delmprog)
{
MOB_INDEX_DATA *pMob;
PROG_LIST *list;
char mprog[MAX_STRING_LENGTH];
int value;
int cnt = 0;
EDIT_MOB(ch, pMob);
one_argument(argument, mprog);
if (!is_number(mprog) || mprog[0] == '\0')
{
chprintln(ch, "Syntax: delmprog [#mprog]");
return FALSE;
}
value = atoi(mprog);
if (value < 0)
{
chprintln(ch, "Only non-negative mprog-numbers allowed.");
return FALSE;
}
for (list = pMob->first_mprog; list != NULL; list = list->next)
if ((++cnt == value))
break;
if (!list)
{
chprintln(ch, "MEdit: Non existant mprog.");
return FALSE;
}
REMOVE_BIT(pMob->mprog_flags, list->trig_type);
UNLINK(list, pMob->first_mprog, pMob->last_mprog, next, prev);
free_prog(list);
chprintln(ch, "Mprog removed.");
return TRUE;
}
OEDIT(oedit_addoprog)
{
flag_t value;
OBJ_INDEX_DATA *pObj;
PROG_LIST *list;
PROG_CODE *code;
char trigger[MSL];
char phrase[MSL];
char num[MSL];
EDIT_OBJ(ch, pObj);
argument = one_argument(argument, num);
argument = one_argument(argument, trigger);
strcpy(phrase, argument);
if (!is_number(num) || IS_NULLSTR(trigger) || IS_NULLSTR(phrase))
{
chprintln(ch, "Syntax: addoprog [vnum] [trigger] [phrase]");
return FALSE;
}
if ((value = flag_value(oprog_flags, trigger)) == NO_FLAG)
{
chprintln(ch, "Valid flags are:");
show_help(ch, "oprog");
return FALSE;
}
if ((code = get_prog_index(atol(num), PRG_OPROG)) == NULL)
{
chprintln(ch, "No such OBJProgram.");
return FALSE;
}
list = new_prog();
list->vnum = atol(num);
list->trig_type = value;
replace_string(list->trig_phrase, phrase);
replace_string(list->code, code->code);
SET_BIT(pObj->oprog_flags, value);
LINK(list, pObj->first_oprog, pObj->last_oprog, next, prev);
chprintln(ch, "Oprog Added.");
return TRUE;
}
OEDIT(oedit_deloprog)
{
OBJ_INDEX_DATA *pObj;
PROG_LIST *list;
char oprog[MSL];
int value;
int cnt = -1;
EDIT_OBJ(ch, pObj);
one_argument(argument, oprog);
if (!is_number(oprog) || IS_NULLSTR(oprog))
{
chprintln(ch, "Syntax: deloprog [#oprog]");
return FALSE;
}
value = atoi(oprog);
if (value < 0)
{
chprintln(ch, "Only non-negative oprog-numbers allowed.");
return FALSE;
}
for (list = pObj->first_oprog; list != NULL; list = list->next)
if (++cnt == value)
break;
if (!list)
{
chprintln(ch, "OEdit: Non existant oprog.");
return FALSE;
}
REMOVE_BIT(pObj->oprog_flags, list->trig_type);
UNLINK(list, pObj->first_oprog, pObj->last_oprog, next, prev);
free_prog(list);
chprintln(ch, "Oprog removed.");
return TRUE;
}
REDIT(redit_addrprog)
{
flag_t value;
ROOM_INDEX_DATA *pRoom;
PROG_LIST *list;
PROG_CODE *code;
char trigger[MSL];
char phrase[MSL];
char num[MSL];
EDIT_ROOM(ch, pRoom);
argument = one_argument(argument, num);
argument = one_argument(argument, trigger);
strcpy(phrase, argument);
if (!is_number(num) || IS_NULLSTR(trigger) || IS_NULLSTR(phrase))
{
chprintln(ch, "Syntax: addrprog [vnum] [trigger] [phrase]");
return FALSE;
}
if ((value = flag_value(rprog_flags, trigger)) == NO_FLAG)
{
chprintln(ch, "Valid flags are:");
show_help(ch, "rprog");
return FALSE;
}
if ((code = get_prog_index(atol(num), PRG_RPROG)) == NULL)
{
chprintln(ch, "No such ROOMProgram.");
return FALSE;
}
list = new_prog();
list->vnum = atol(num);
list->trig_type = value;
replace_string(list->trig_phrase, phrase);
replace_string(list->code, code->code);
SET_BIT(pRoom->rprog_flags, value);
LINK(list, pRoom->first_rprog, pRoom->last_rprog, next, prev);
chprintln(ch, "Rprog Added.");
return TRUE;
}
REDIT(redit_delrprog)
{
ROOM_INDEX_DATA *pRoom;
PROG_LIST *list;
char rprog[MSL];
int value;
int cnt = -1;
EDIT_ROOM(ch, pRoom);
one_argument(argument, rprog);
if (!is_number(rprog) || IS_NULLSTR(rprog))
{
chprintln(ch, "Syntax: delrprog [#rprog]");
return FALSE;
}
value = atoi(rprog);
if (value < 0)
{
chprintln(ch, "Only non-negative rprog-numbers allowed.");
return FALSE;
}
for (list = pRoom->first_rprog; list != NULL; list = list->next)
if ((++cnt == value))
break;
if (!list)
{
chprintln(ch, "REdit: Non existant rprog.");
return FALSE;
}
REMOVE_BIT(pRoom->rprog_flags, list->trig_type);
UNLINK(list, pRoom->first_rprog, pRoom->last_rprog, next, prev);
free_prog(list);
chprintln(ch, "Rprog removed.");
return TRUE;
}
VALIDATE_FUN(validate_level)
{
int num = *(int *) arg;
if (num < 0 || num > MAX_LEVEL)
{
chprintf(ch, "Number must be between 0 and %d.\n\r", MAX_LEVEL);
return FALSE;
}
return TRUE;
}
VALIDATE_FUN(validate_align)
{
int num = *(int *) arg;
if (num < -1000 || num > 1000)
{
chprintln(ch, "Number must be between -1000 and 1000.");
return FALSE;
}
return TRUE;
}
ED_FUN_DEC(olced_str)
{
VALIDATE_FUN *validator;
const char **string = (const char **) arg;
if (IS_NULLSTR(argument))
{
chprintf(ch, "Syntax: %s string\n\r", n_fun);
return FALSE;
}
if ((validator = (VALIDATE_FUN *) par) && !validator(ch, argument))
return FALSE;
replace_string(*string, argument);
chprintln(ch, "Ok.");
return TRUE;
}
ED_FUN_DEC(olced_str_line)
{
VALIDATE_FUN *validator;
const char **string = (const char **) arg;
char buf[MSL];
if (IS_NULLSTR(argument))
{
chprintf(ch, "Syntax: %s string\n\r", n_fun);
return FALSE;
}
if ((validator = (VALIDATE_FUN *) par) && !validator(ch, argument))
return FALSE;
sprintf(buf, "%s\n\r", argument);
replace_string(*string, buf);
chprintln(ch, "Ok.");
return TRUE;
}
ED_FUN_DEC(olced_desc)
{
if (IS_NULLSTR(argument))
{
string_append(ch, (const char **) arg);
return TRUE;
}
chprintln(ch, "Syntax : desc");
return FALSE;
}
ED_FUN_DEC(olced_bool)
{
if (IS_NULLSTR(argument))
{
chprintf(ch, "Syntax : %s [TRUE/FALSE]\n\r\n\r", n_fun);
return FALSE;
}
if (!str_cmp(argument, "TRUE"))
*(bool *) arg = TRUE;
else if (!str_cmp(argument, "FALSE"))
*(bool *) arg = FALSE;
else
{
chprintln(ch, "ERROR : invalid argument.");
return FALSE;
}
chprintln(ch, "Ok.");
return TRUE;
}
ED_FUN_DEC(olced_olded)
{
return (*(OLC_FUN *) par) (ch, argument);
}
ED_FUN_DEC(olced_number)
{
int *value = (int *) arg;
char *endptr;
int temp;
char arg1[MIL];
VALIDATE_FUN *validator;
one_argument(argument, arg1);
temp = strtol(arg1, &endptr, 0);
if (IS_NULLSTR(arg1) || !IS_NULLSTR(endptr))
{
chprintf(ch, "Syntax: %s number\n\r", n_fun);
return FALSE;
}
if ((validator = (VALIDATE_FUN *) par) && !validator(ch, &temp))
return FALSE;
*value = temp;
chprintln(ch, "Ok.");
return TRUE;
}
ED_FUN_DEC(olced_number_long)
{
long *value = (long *) arg;
char *endptr;
long temp;
char arg1[MIL];
VALIDATE_FUN *validator;
one_argument(argument, arg1);
temp = strtol(arg1, &endptr, 0);
if (IS_NULLSTR(arg1) || !IS_NULLSTR(endptr))
{
chprintf(ch, "Syntax: %s number\n\r", n_fun);
return FALSE;
}
if ((validator = (VALIDATE_FUN *) par) && !validator(ch, &temp))
return FALSE;
*value = temp;
chprintln(ch, "Ok.");
return TRUE;
}
ED_FUN_DEC(olced_vnum)
{
vnum_t *value = (vnum_t *) arg;
char *endptr;
vnum_t temp;
char arg1[MIL];
VALIDATE_FUN *validator;
one_argument(argument, arg1);
temp = strtol(arg1, &endptr, 0);
if (IS_NULLSTR(arg1) || !IS_NULLSTR(endptr))
{
chprintf(ch, "Syntax: %s number\n\r", n_fun);
return FALSE;
}
if ((validator = (VALIDATE_FUN *) par) && !validator(ch, &temp))
return FALSE;
*value = temp;
chprintln(ch, "Ok.");
return TRUE;
}
void show_flags_buf(BUFFER * output, const struct flag_type *flag_table)
{
int flag;
char buf[MSL];
int col;
col = 0;
for (flag = 0; flag_table[flag].name != NULL; flag++)
{
if (flag_table[flag].settable)
{
sprintf(buf, "%-19.18s", flag_table[flag].name);
add_buf(output, buf);
if (++col % 4 == 0)
add_buf(output, "\n\r");
}
}
if (col % 4 != 0)
add_buf(output, "\n\r");
}
/*****************************************************************************
Name: show_flags
Purpose: Displays settable flags and stats.
****************************************************************************/
void show_flags(CHAR_DATA * ch, const struct flag_type *flag_table)
{
BUFFER *output;
output = new_buf();
show_flags_buf(output, flag_table);
page_to_char(buf_string(output), ch);
free_buf(output);
}
ED_FUN_DEC(olced_flag)
{
int stat;
const struct flag_type *f;
flag_t marked;
if ((stat = is_stat((const struct flag_type *) par)) < 0)
{
chprintf
(ch,
"%s: Unknown table of values (report it to implementors).", n_fun);
return FALSE;
}
if (IS_NULLSTR(argument))
{
chprintlnf(ch, "Syntax: %s value\n\r\n\r"
"Type '%s ?' for a list of "
"acceptable values.", n_fun, n_fun);
return FALSE;
}
if (!str_cmp(argument, "?"))
{
show_flags(ch, (const struct flag_type *) par);
return FALSE;
}
if (stat)
{
if ((f = flag_lookup(argument, (const struct flag_type *) par)) == NULL)
{
chprintlnf(ch, "Syntax: %s value\n\r\n\r"
"Type '%s ?' for a list of "
"acceptable values.", n_fun, n_fun);
return FALSE;
}
if (!f->settable)
{
chprintf(ch, "%s: '%s': value is not settable.\n\n\r",
n_fun, f->name);
return FALSE;
}
*(int *) arg = f->bit;
chprintf(ch, "%s: '%s': Ok.\n\n\r", n_fun, f->name);
return TRUE;
}
marked = 0;
/*
* Accept multiple flags.
*/
for (;;)
{
char word[MAX_INPUT_LENGTH];
argument = one_argument(argument, word);
if (IS_NULLSTR(word))
break;
if ((f = flag_lookup(word, (const struct flag_type *) par)) == NULL)
{
chprintf(ch, "Syntax: %s flag...\n\r\n\r"
"Type '%s ?' for a list of "
"acceptable flags.", n_fun, n_fun);
return FALSE;
}
if (!f->settable)
{
chprintf(ch, "%s: '%s': flag is not settable.\n\r", n_fun, f->name);
continue;
}
SET_BIT(marked, f->bit);
}
if (marked)
{
TOGGLE_BIT(*(flag_t *) arg, marked);
chprintf(ch, "%s: '%s': flag(s) toggled.\n\r",
n_fun, flag_string((const struct flag_type *) par, marked));
return TRUE;
}
return FALSE;
}
ED_FUN_DEC(olced_shop)
{
MOB_INDEX_DATA *pMob = (MOB_INDEX_DATA *) arg;
char command[MAX_INPUT_LENGTH];
char arg1[MAX_INPUT_LENGTH];
argument = one_argument(argument, command);
argument = one_argument(argument, arg1);
if (IS_NULLSTR(command))
{
chprintln(ch, "Syntax : shop hours [open] [close]");
chprintln(ch, " shop profit [%% buy] [%% sell]");
chprintln(ch, " shop type [0-4] [obj type]");
chprintln(ch, " shop type [0-4] none");
chprintln(ch, " shop assign");
chprintln(ch, " shop remove");
return FALSE;
}
if (!str_cmp(command, "hours"))
{
if (IS_NULLSTR(arg1) || !is_number(arg1)
|| IS_NULLSTR(argument) || !is_number(argument))
{
chprintln(ch, "Syntax : shop hours [open] [close]");
return FALSE;
}
if (!pMob->pShop)
{
chprintln(ch, "ERROR : Debes crear un shop primero (shop assign).");
return FALSE;
}
pMob->pShop->open_hour = atoi(arg1);
pMob->pShop->close_hour = atoi(argument);
chprintln(ch, "Hours set.");
return TRUE;
}
if (!str_cmp(command, "profit"))
{
if (IS_NULLSTR(arg1) || !is_number(arg1)
|| IS_NULLSTR(argument) || !is_number(argument))
{
chprintf(ch, "Syntax : shop profit [%% buy] [%% sell]\n\r");
return FALSE;
}
if (!pMob->pShop)
{
chprintln(ch,
"MEdit: You must create a shop first (shop assign).");
return FALSE;
}
pMob->pShop->profit_buy = atoi(arg1);
pMob->pShop->profit_sell = atoi(argument);
chprintln(ch, "Shop profit set.");
return TRUE;
}
if (!str_cmp(command, "type"))
{
flag_t value = 0;
if (IS_NULLSTR(arg1) || !is_number(arg1) || IS_NULLSTR(argument))
{
chprintln(ch, "Syntax: shop type [#x0-4] [item type]");
return FALSE;
}
if (atoi(arg1) >= MAX_TRADE)
{
chprintf(ch, "MEdit: May sell %d items max.\n\r", MAX_TRADE);
return FALSE;
}
if (!pMob->pShop)
{
chprintln(ch,
"MEdit: You must create a shop first (shop assign).");
return FALSE;
}
if ((value = flag_value(type_flags, argument)) == NO_FLAG)
{
chprintln(ch, "MEdit: That type of item is not known.");
return FALSE;
}
pMob->pShop->buy_type[atoi(arg1)] = value;
chprintln(ch, "Shop type set.");
return TRUE;
}
/* shop assign && shop delete by Phoenix */
if (!str_prefix(command, "assign"))
{
if (pMob->pShop)
{
chprintln(ch, "Mob already has a shop assigned to it.");
return FALSE;
}
pMob->pShop = new_shop();
LINK(pMob->pShop, shop_first, shop_last, next, prev);
pMob->pShop->keeper = pMob->vnum;
chprintln(ch, "New shop assigned to mobile.");
return TRUE;
}
if (!str_prefix(command, "remove"))
{
SHOP_DATA *pShop;
pShop = pMob->pShop;
pMob->pShop = NULL;
UNLINK(pShop, shop_first, shop_last, next, prev);
free_shop(pShop);
chprintln(ch, "Mobile is no longer a shopkeeper.");
return TRUE;
}
olced_shop(n_fun, ch, str_empty, arg, par);
return FALSE;
}
ED_FUN_DEC(olced_spec)
{
SPEC_FUN **spec = (SPEC_FUN **) arg;
if (IS_NULLSTR(argument))
{
chprintf(ch, "Sintaxis : %s [%s]\n\r", n_fun, n_fun);
return FALSE;
}
if (!str_cmp(argument, "none"))
{
*spec = NULL;
chprintln(ch, "Spec removed.");
return TRUE;
}
if (spec_lookup(argument))
{
*spec = spec_lookup(argument);
chprintln(ch, "Spec set.");
return TRUE;
}
else
{
chprintln(ch, "ERROR : Spec inexistente.");
return FALSE;
}
return FALSE;
}
ED_FUN_DEC(olced_race)
{
MOB_INDEX_DATA *pMob = (MOB_INDEX_DATA *) arg;
RACE_DATA *race;
if (!IS_NULLSTR(argument) && (race = race_lookup(argument)) != NULL)
{
pMob->race = race;
pMob->act |= race->act;
pMob->affected_by |= race->aff;
pMob->off_flags |= race->off;
pMob->imm_flags |= race->imm;
pMob->res_flags |= race->res;
pMob->vuln_flags |= race->vuln;
pMob->form |= race->form;
pMob->parts |= race->parts;
chprintln(ch, "Race set.");
return TRUE;
}
if (argument[0] == '?')
{
int i = 0;
chprintln(ch, "Available races are:");
for (race = race_first; race != NULL; race = race->next)
{
if ((i % 3) == 0)
chprintln(ch, "");
chprintf(ch, " %-15s", race->name);
i++;
}
chprintln(ch, "");
return FALSE;
}
chprintln(ch, "Syntax: race [race]\n\r"
"Type 'race ?' for a list of races.");
return FALSE;
}
ED_FUN_DEC(olced_ac)
{
MOB_INDEX_DATA *pMob = (MOB_INDEX_DATA *) arg;
char blarg[MAX_INPUT_LENGTH];
int pierce, bash, slash, exotic;
do /* So that I can use break and send the syntax in one place */
{
if (IS_NULLSTR(argument))
break;
argument = one_argument(argument, blarg);
if (!is_number(blarg))
break;
pierce = atoi(blarg);
argument = one_argument(argument, blarg);
if (!IS_NULLSTR(blarg))
{
if (!is_number(blarg))
break;
bash = atoi(blarg);
argument = one_argument(argument, blarg);
}
else
bash = pMob->ac[AC_BASH];
if (!IS_NULLSTR(blarg))
{
if (!is_number(blarg))
break;
slash = atoi(blarg);
argument = one_argument(argument, blarg);
}
else
slash = pMob->ac[AC_SLASH];
if (!IS_NULLSTR(blarg))
{
if (!is_number(blarg))
break;
exotic = atoi(blarg);
}
else
exotic = pMob->ac[AC_EXOTIC];
pMob->ac[AC_PIERCE] = pierce;
pMob->ac[AC_BASH] = bash;
pMob->ac[AC_SLASH] = slash;
pMob->ac[AC_EXOTIC] = exotic;
chprintln(ch, "Ac set.");
return TRUE;
}
while (FALSE); /* Just do it once.. */
chprintln(ch,
"Syntax: ac [ac-pierce [ac-bash [ac-slash [ac-exotic]]]]\n\r"
"help MOB_AC gives a list of reasonable ac-values.");
return FALSE;
}
ED_FUN_DEC(olced_dice)
{
static char syntax[] = "Syntax: %s <number> d <type> + <bonus>\n\r";
char *numb, *type, *bonus, *cp;
int *arreglo = (int *) arg;
if (IS_NULLSTR(argument))
{
chprintf(ch, syntax, n_fun);
return FALSE;
}
numb = cp = (char *) argument;
while (isdigit(*cp))
++cp;
while (*cp != '\0' && !isdigit(*cp))
*(cp++) = '\0';
type = cp;
while (isdigit(*cp))
++cp;
while (*cp != '\0' && !isdigit(*cp))
*(cp++) = '\0';
bonus = cp;
while (isdigit(*cp))
++cp;
if (*cp != '\0')
*cp = '\0';
if ((!is_number(numb) || atoi(numb) < 1)
|| (!is_number(type) || atoi(type) < 1)
|| (!is_number(bonus) || atoi(bonus) < 0))
{
chprintf(ch, syntax, n_fun);
return FALSE;
}
arreglo[DICE_NUMBER] = atoi(numb);
arreglo[DICE_TYPE] = atoi(type);
arreglo[DICE_BONUS] = atoi(bonus);
chprintf(ch, "%s set.\n\r", n_fun);
return TRUE;
}
ED_FUN_DEC(olced_ed)
{
EXTRA_DESCR_DATA *ed;
EXTRA_DESCR_DATA **pEd = (EXTRA_DESCR_DATA **) arg;
EXTRA_DESCR_DATA **lEd = (EXTRA_DESCR_DATA **) par;
char command[MAX_INPUT_LENGTH];
char keyword[MAX_INPUT_LENGTH];
argument = one_argument(argument, command);
argument = one_argument(argument, keyword);
if (IS_NULLSTR(command))
{
chprintln(ch, "Syntax: ed add [keyword]");
chprintln(ch, " ed delete [keyword]");
chprintln(ch, " ed edit [keyword]");
chprintln(ch, " ed format [keyword]");
chprintln(ch, " ed rename [keyword]");
return FALSE;
}
if (!str_cmp(command, "add"))
{
if (IS_NULLSTR(keyword))
{
chprintln(ch, "Syntax: ed add [keyword]");
return FALSE;
}
ed = new_extra_descr();
replace_string(ed->keyword, keyword);
LINK(ed, *pEd, *lEd, next, prev);
string_append(ch, &ed->description);
return TRUE;
}
if (!str_cmp(command, "edit"))
{
if (IS_NULLSTR(keyword))
{
chprintln(ch, "Syntax: ed edit [keyword]");
return FALSE;
}
for (ed = *pEd; ed; ed = ed->next)
{
if (is_name(keyword, ed->keyword))
break;
}
if (!ed)
{
chprintln(ch, "ERROR : No such extra description.");
return FALSE;
}
string_append(ch, &ed->description);
return TRUE;
}
if (!str_cmp(command, "delete"))
{
EXTRA_DESCR_DATA *ped = NULL;
if (IS_NULLSTR(keyword))
{
chprintln(ch, "Syntax: ed delete [keyword]");
return FALSE;
}
for (ed = *pEd; ed; ed = ed->next)
{
if (is_name(keyword, ed->keyword))
break;
ped = ed;
}
if (!ed)
{
chprintln(ch, "ERROR : No such extra description.");
return FALSE;
}
UNLINK(ed, *pEd, *lEd, next, prev);
free_extra_descr(ed);
chprintln(ch, "Extra description deleted.");
return TRUE;
}
if (!str_cmp(command, "format"))
{
EXTRA_DESCR_DATA *ped = NULL;
if (IS_NULLSTR(keyword))
{
chprintln(ch, "Syntax: ed format [keyword]");
return FALSE;
}
for (ed = *pEd; ed; ed = ed->next)
{
if (is_name(keyword, ed->keyword))
break;
ped = ed;
}
if (!ed)
{
chprintln(ch, "ERROR : No Such Extra Description");
return FALSE;
}
ed->description = format_string(ed->description);
chprintln(ch, "Extra description formatted.");
return TRUE;
}
if (!str_cmp(command, "rename"))
{
EXTRA_DESCR_DATA *ped = NULL;
if (IS_NULLSTR(keyword))
{
chprintln(ch, "Syntax: ed rename [old] [new]");
return FALSE;
}
for (ed = *pEd; ed; ed = ed->next)
{
if (is_name(keyword, ed->keyword))
break;
ped = ed;
}
if (!ed)
{
chprintln(ch, "ERROR : No such extra description");
return FALSE;
}
replace_string(ed->keyword, argument);
chprintln(ch, "Extra description renamed.");
return TRUE;
}
return olced_ed(n_fun, ch, "", arg, par);
}
ED_FUN_DEC(olced_direction)
{
return change_exit(ch, argument, (int) par);
}
ED_FUN_DEC(olced_docomm)
{
(*(DO_FUN *) par) (ch, argument);
return FALSE;
}
ED_FUN_DEC(olced_value)
{
return oedit_values(ch, argument, (int) par);
}
bool templookup(const char *n_fun, CHAR_DATA * ch, const char *argument,
void *arg, const void *par, int temp)
{
int value;
LOOKUP_F *blah = (LOOKUP_F *) par;
if (!emptystring(argument))
{
if ((value = ((*blah) (argument))) > temp)
{
*(int *) arg = value;
chprintf(ch, "%s set.\n\r", n_fun);
return TRUE;
}
else
{
chprintf(ch, "ERROR : %s doesn't exist.\n\r", n_fun);
return FALSE;
}
}
chprintf(ch, "Syntax : %s [%s]\n\r"
"Type '? %s' for a list of arguments.\n\r", n_fun, n_fun, n_fun);
return FALSE;
}
ED_FUN_DEC(olced_poslookup)
{
return templookup(n_fun, ch, argument, arg, par, 0);
}
ED_FUN_DEC(olced_neglookup)
{
return templookup(n_fun, ch, argument, arg, par, -1);
}
CEDIT(cedit_show)
{
CLAN_DATA *pClan;
int r;
EDIT_CLAN(ch, pClan);
chprintf(ch, "Name: %s\n\r", pClan->name);
chprintf(ch, "Who: %s\n\r", pClan->who_name);
chprintf(ch, "Hall: %ld\n\r", pClan->hall);
chprintf(ch, "Independant: %s\n\r", pClan->independent ? "TRUE" : "FALSE");
for (r = 0; r < MAX_RANK; r++)
chprintf(ch, "Rank %d: %s\n\r", r + 1, pClan->rank[r].rankname);
return TRUE;
}
CEDIT(cedit_rank)
{
CLAN_DATA *pClan;
char arg1[MIL];
EDIT_CLAN(ch, pClan);
argument = one_argument(argument, arg1);
if (is_number(arg1) && atoi(arg1) <= MAX_RANK && atoi(arg1) > 0)
{
int value;
value = atoi(arg1) - 1;
if (!IS_NULLSTR(argument))
{
replace_string(pClan->rank[value].rankname, argument);
chprintln(ch, "Rank name changed.");
return TRUE;
}
}
chprintln(ch, "Syntax: rank rank# newname");
return FALSE;
}
CEDIT(cedit_create)
{
CLAN_DATA *pClan;
char buf[MIL];
if (!IS_NULLSTR(argument) && clan_lookup(argument) == NULL)
sprintf(buf, argument);
else
sprintf(buf, "New Clan%d", maxClan + 1);
pClan = new_clan();
replace_string(pClan->name, buf);
replace_string(pClan->who_name, buf);
LINK(pClan, clan_first, clan_last, next, prev);
edit_start(ch, pClan, ED_CLAN);
chprintln(ch, "Clan created.");
return TRUE;
}
CEDIT(cedit_delete)
{
CLAN_DATA *pClan;
EDIT_CLAN(ch, pClan);
if (str_cmp(argument, "confirm"))
{
chprintln(ch,
"Typing 'delete confirm' again will permanetely remove this clan!\n\r"
"-or- 'delete cancel' will cancel the deletion.");
return FALSE;
}
else
{
CHAR_DATA *pch;
int hash;
ROOM_INDEX_DATA *pRoom;
MBR_DATA *pmbr, *next = NULL;
for (pmbr = mbr_first; pmbr != NULL; pmbr = next)
{
next = pmbr->next;
if (pmbr->clan == pClan)
{
UNLINK(pmbr, mbr_first, mbr_last, next, prev);
free_mbr(pmbr);
}
}
for (pch = char_first; pch != NULL; pch = pch->next)
{
if (pch->clan == pClan)
{
pch->clan = NULL;
pch->rank = 0;
}
}
for (hash = 0; hash < MAX_KEY_HASH; hash++)
{
for (pRoom = room_index_hash[hash]; pRoom; pRoom = pRoom->next)
{
if (pRoom->clan == pClan)
{
pRoom->clan = NULL;
SET_BIT(pRoom->area->area_flags, AREA_CHANGED);
}
}
}
UNLINK(pClan, clan_first, clan_last, next, prev);
free_clan(pClan);
pClan = clan_first;
edit_start(ch, pClan, ED_CLAN);
chprintln(ch, "Clan deleted.");
}
return TRUE;
}
OEDIT(oedit_autoweapon)
{
OBJ_INDEX_DATA *pObj;
EDIT_OBJ(ch, pObj);
if (pObj->item_type != ITEM_WEAPON)
{
chprintln(ch, " {rAutoweapon only works on weapons...{x");
return FALSE;
}
if (pObj->level < 1)
{
chprintlnf
(ch,
" {cAutoweapon requires a level to be set on the weapon first(vnum %ld).{x",
pObj->vnum);
return FALSE;
}
if (IS_OBJ_STAT(pObj, ITEM_QUEST))
{
chprintln(ch, "This weapon cannot be autoset.");
return FALSE;
}
autoweapon(pObj);
chprintln(ch, "Weapon set to default values., check for accuracy.");
return TRUE;
}
OEDIT(oedit_autoarmor)
{
OBJ_INDEX_DATA *pObj;
EDIT_OBJ(ch, pObj);
if (pObj->item_type != ITEM_ARMOR)
{
chprintln(ch, " {rAutoArmor only works on Armor ...{x");
return FALSE;
}
if (pObj->level < 1)
{
chprintlnf
(ch,
" {cAutoArmor requires a level to be set on the armor first.(vnum %ld){x",
pObj->vnum);
return FALSE;
}
if (IS_OBJ_STAT(pObj, ITEM_QUEST))
{
chprintln(ch, "This weapon cannot be autoset.");
return FALSE;
}
autoarmor(pObj);
chprintln(ch, "AutoArmor has set experimental values for AC.{x");
return TRUE;
}
MEDIT(medit_autoset)
{
MOB_INDEX_DATA *pMob;
EDIT_MOB(ch, pMob);
if (pMob->level < 1)
{
chprintlnf(ch, "Set a level on the mob first!!!(vnum %ld)", pMob->vnum);
return FALSE;
}
autoset(pMob);
chprintln(ch, " Values set, check for accuracy.");
return TRUE;
}
MEDIT(medit_autohard)
{
MOB_INDEX_DATA *pMob;
EDIT_MOB(ch, pMob);
if (pMob->level < 1)
{
chprintlnf(ch, "Set a level on the mob first!!!(vnum %ld)", pMob->vnum);
return FALSE;
}
autohard(pMob);
chprintln(ch, " Hard values set, check for accuracy.");
return TRUE;
}
MEDIT(medit_autoeasy)
{
MOB_INDEX_DATA *pMob;
EDIT_MOB(ch, pMob);
if (pMob->level < 1)
{
chprintlnf(ch, "Set a level on the mob first!!!(vnum %ld)", pMob->vnum);
return FALSE;
}
autoeasy(pMob);
chprintln(ch, " Easy values set, check for accuracy.");
return TRUE;
}