/*************************************************************************** * God Wars Mud originally written by KaVir aka Richard Woolcock. * * Changes done to the code done by Sage aka Walter Howard, this mud is * * for the public, however if you run this code it means you agree * * to the license.low, license.gw, and license.merc have fun. :) * ***************************************************************************/ #if defined(macintosh) #include <types.h> #else #include <sys/types.h> #endif #include <ctype.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <limits.h> /* OLC 1.1b */ #include <time.h> #include "merc.h" #include "commands.h" #include "build.h" char * spec_name args(( SPEC_FUN * spec )); SPEC_FUN * spec_lookup args(( const char *name )); bool show_help args(( CHAR_DATA *ch, char *argument )); /* * Globals */ extern int top_reset; extern int top_area; extern int top_exit; extern int top_ed; extern int top_room; struct item_spells spells[]; AREA_DATA * area_free; EXTRA_DESCR_DATA * extra_descr_free; EXIT_DATA * exit_free; ROOM_INDEX_DATA * room_index_free; OBJ_INDEX_DATA * obj_index_free; SHOP_DATA * shop_free; MOB_INDEX_DATA * mob_index_free; RESET_DATA * reset_free; extern HELP_AREA * had_list; const struct olc_cmd_type hedit_table[] = { /* { command function }, */ { "keyword", hedit_keyword }, { "text", hedit_text }, { "new", hedit_new }, { "level", hedit_level }, { "delete", hedit_delete }, { "list", hedit_list }, { "show", hedit_show }, { "commands", show_commands }, { "?", show_help }, { "", 0 } }; const struct olc_cmd_type medit_table[] = { /* { command function }, */ { "show", medit_show }, { "create", medit_create }, { "desc", medit_desc }, { "level", medit_level }, { "long", medit_long }, { "name", medit_name }, { "shop", medit_shop }, { "short", medit_short }, { "alignment", medit_align }, { "spec", medit_spec }, { "commands", show_commands }, { "?", show_help }, { "", 0, } }; const struct olc_cmd_type aedit_table[] = { { "age", aedit_age }, { "builders", aedit_builder }, { "create", aedit_create }, { "filename", aedit_filename }, { "name", aedit_name }, { "reset", aedit_reset }, { "security", aedit_security }, { "show", aedit_show }, { "vnum", aedit_vnum }, { "lvnum", aedit_lvnum }, { "uvnum", aedit_uvnum }, { "mod", aedit_mod }, { "connected", aedit_connected }, { "commands", show_commands }, { "?", show_help }, { "", 0, } }; const struct olc_cmd_type oedit_table[] = { { "addaffect", oedit_addaffect }, { "cost", oedit_cost }, { "create", oedit_create }, { "delaffect", oedit_delaffect }, { "ed", oedit_ed }, { "long", oedit_long }, { "name", oedit_name }, { "short", oedit_short }, { "show", oedit_show }, { "v0", oedit_value0 }, { "v1", oedit_value1 }, { "v2", oedit_value2 }, { "v3", oedit_value3 }, { "v4", oedit_value4 }, { "weight", oedit_weight }, { "artifact", oedit_artifact }, { "commands", show_commands }, { "?", show_help }, { "", 0, } }; const struct olc_cmd_type redit_table[] = { { "create", redit_create }, { "desc", redit_desc }, { "ed", redit_ed }, { "format", redit_format }, { "name", redit_name }, { "show", redit_show }, { "copy", redit_copy }, { "north", redit_north }, { "south", redit_south }, { "east", redit_east }, { "west", redit_west }, { "up", redit_up }, { "down", redit_down }, { "walk", redit_move }, { "roomtext", redit_roomtext }, { "mreset", redit_mreset }, { "oreset", redit_oreset }, { "findreset", redit_findreset }, { "?", show_help }, { "commands", show_commands }, { "", 0, } }; const struct olc_cmd_type cedit_table[] = { { "show", cedit_show }, { "savefreq", cedit_savefreq }, { "dodgemod", cedit_dodgemod }, { "parrymod", cedit_parrymod }, { "dam_pvp", cedit_dam_pvp }, { "dam_pvm", cedit_dam_pvm }, { "dam_mvp", cedit_dam_mvp }, { "dam_mvm", cedit_dam_mvm }, { "plr_mset", cedit_plr_mset }, { "forcepc", cedit_forcepc }, { "ban_clas", cedit_ban_class }, { "ban_site", cedit_ban_site }, { "cleanpfiles", cedit_pfiles }, { "newbie_purge", cedit_newbie_purge }, { "regular_purge",cedit_regular_purge }, { "?", show_help }, { "commands", show_commands }, { "", 0, } }; const struct olc_cmd_type cledit_table[] = { /* { command function }, */ { "create", cledit_create }, { "filename", cledit_filename }, { "description", cledit_desc }, { "display", cledit_display }, { "motto", cledit_motto }, { "name", cledit_name }, { "leader", cledit_leader }, { "recall", cledit_recall }, { "obj_1", cledit_obj1 }, { "obj_2", cledit_obj2 }, { "obj_3", cledit_obj3 }, { "recall", cledit_recall }, { "show", cledit_show }, { "story", cledit_desc }, { "?", show_help }, { "commands", show_commands }, { "", 0 } }; const struct olc_cmd_type rename_obj_table[] = { /* { command function }, */ { "keyword", rename_keyword }, { "short", rename_short }, { "long", rename_long }, { "show", rename_show }, { "1", rename_keyword }, { "2", rename_short }, { "3", rename_long }, { "commands", show_commands }, { "", 0, } }; /* * This table contains help commands and a brief description of each. * ------------------------------------------------------------------ */ const struct olc_help_type help_table[] = { { "area", area_flags, 8, "Area attributes." }, { "room", room_flags, 8, "Room attributes." }, { "sector", sector_flags, 8, "Sector types, terrain." }, { "exit", exit_flags, 8, "Exit types." }, { "type", type_flags, 8, "Types of objects." }, { "extra", extra_flags, 8, "Object attributes." }, { "wear", wear_flags, 8, "Where to wear object." }, { "spec", spec_table, 8, "Available special programs." }, { "sex", sex_flags, 8, "Sexes." }, { "act", act_flags, 8, "Mobile attributes." }, { "affect", affect_flags, 8, "Mobile affects." }, { "wear-loc", wear_loc_flags, 8, "Where mobile wears object." }, { "spells", skill_table, 8, "Names of current spells." }, { "weapon", weapon_flags, 8, "Type of weapon." }, { "container", container_flags, 8, "Container status." }, { "apply", apply_flags, 8, "Types of Obj applys." }, { "liquid", liquid_flags, 8, "Types of liquids." }, { "itemspells", spells, 8, "Different item affect spells" }, { "log", log_flags, 10, "Types of logs" }, { "newbits", newbit_flags, 10, "Types of NewBits" }, { "plr_flags", plr_flags, 10, "Player flags (ActBit)" }, { "immunties", imm_flags, 10, "Immunites" }, { "itemaflags", itema_flags, 10, "ItemAffects" }, { "position", position_flags, 10, "Position types" }, { "levels", level_flags, 10, "Levels" }, { "worldflags", world_flags, 9, "World Flags" }, { "cmd_show", show_flags, 10, "CmdShow" }, { "rt_types", rt_flags, 8, "RoomText Types - help 'type'" }, { "weap_flags", weap_flags, 10, "WeaponFlags" }, { "", 0, 0, "" } }; /* * Flag Tables */ struct item_spells spells[] = { { "Infared", 1, "%s allows the wearer to see in the dark." }, { "Dinvis", 2, "%s allows the wearer to see invisible things."}, { "Flying", 3, "%s grants the power of flight." }, { "Blind", 4, "%s radiates and aura of darkness." }, { "Invis", 5, "%s makes the owner invisible to the human eye." }, { "Pdoor", 6, "%s allows the wearer to walk through solid doors."}, { "Protect", 7, "%s protects the wearer from evil." }, { "Sanc", 8, "%s protects the wearer in combat." }, { "Sneak", 9, "%s allows the wearer to walk in complete silence." }, { "Shockshld", 10,"This powerful %s surrounds its wielder with a shield of lightning." }, { "Fireshld", 11,"This powerful %s surrounds its wielder with a shield of fire."}, { "Acidshld", 12,"This powerful %s surrounds its wielder with a shield of acid."}, { "Iceshld", 13,"This powerful %s surrounds its wielder with a shield of lightning."}, { "Dbpass", 14,"%s protects you from clan DarkBlade guardians." }, { "Chaos", 15,"This ancient %s is the wielder of chaos." }, { "Regen", 16,"This ancient %s regenerates the wounds of the wearer."}, { "Speed", 17,"This %s allows you to move increedibly fast."}, { "Vorpal", 18,"This %s sucks the blood from its victims."}, { "Peace", 19,"This ancient %s protects its wearer from player attacks." }, { "Reflect", 20,"This ancient %s surrounds its wielder with a shield of darkness."}, { "Resist", 21,"This ancient %s grants superior protection to its wielder."}, { "Vision", 22,"This ancient %s grants its wielder supernatural vision."}, { "Stalker", 23,"This ancient %s makes its wielder fleet-footed."}, { "Vanish", 24,"This ancient %s conceals its wielder from sight."}, { "Rager", 25,"This ancient %s invokes the power of the beast."}, { "Totalblind",26,"This %s causes you to be blind."}, { "criticals", 27,"This %s cause's you to find your opponents weakness." }, { "Dhid", 60,"This ancient %s hides you from sight."}, { NULL, -1,NULL} }; /* * Remove carriage returns from a line */ char *strip_cr( char *str ) { static char newstr[MAX_STRING_LENGTH]; int i, j; if( str == NULL ) return '\0'; for ( i=j=0; str[i] != '\0'; i++ ) if ( str[i] != '\r' || str[i] == '~') { newstr[j++] = str[i]; } newstr[j] = '\0'; return newstr; } /* * Removes the tildes from a line, except if it's the last character. */ void smush_tilde( char *str ) { int len; char last; char *strptr; strptr = str; len = strlen( str ); if ( len ) last = strptr[len-1]; else last = '\0'; for ( ; *str != '\0'; str++ ) { if ( *str == '~' ) *str = '-'; } if ( len ) strptr[len-1] = last; return; } HELP_AREA * had_lookup( char *arg ) { HELP_AREA * temp; for ( temp = had_list; temp; temp = temp->next ) if ( !str_cmp( arg, temp->filename ) ) return temp; return NULL; } CLAN_DATA *clan_vnum ( char *buf ) { CLAN_DATA *clan = NULL; int vnum; int x; if( buf[0] == '\0' || !is_number( buf ) ) return NULL; vnum = atoi( buf ); x = -1; for( clan = clan_first; clan; clan = clan->next ) { if( x == vnum ) return clan; x++; } return NULL; } CLAN_DATA *clan_lookup( const char *name ) { CLAN_DATA *clan = NULL; for( clan = clan_first; clan; clan = clan->next ) if( is_name( name, clan->name ) ) break; return clan; } void show_olc_cmds( CHAR_DATA *ch, const struct olc_cmd_type *olc_table ) { char buf [ MAX_STRING_LENGTH ]; char buf1 [ MAX_STRING_LENGTH ]; int cmd; int col; buf1[0] = '\0'; col = 0; for (cmd = 0; olc_table[cmd].name[0] != '\0'; cmd++) { sprintf( buf, "%-15.15s", olc_table[cmd].name ); strcat( buf1, buf ); if ( ++col % 5 == 0 ) strcat( buf1, "\n\r" ); } if ( col % 5 != 0 ) strcat( buf1, "\n\r" ); send_to_char( buf1, ch ); return; } bool show_commands( CHAR_DATA *ch, char *argument ) { switch (ch->desc->editor) { case ED_MOBILE: show_olc_cmds( ch, medit_table ); break; case ED_HELP: show_olc_cmds( ch, hedit_table ); break; case ED_AREA: show_olc_cmds( ch, aedit_table ); break; case ED_ROOM: show_olc_cmds( ch, redit_table ); break; case ED_OBJECT: show_olc_cmds( ch, oedit_table ); break; case ED_CMD: show_olc_cmds( ch, cmdedit_table ); break; case ED_SOCIAL: show_olc_cmds( ch, sedit_table ); break; case ED_CONTROL:show_olc_cmds( ch, cedit_table ); break; case ED_CLAN: show_olc_cmds( ch, cledit_table ); break; case ED_RENAME: show_olc_cmds( ch, rename_obj_table ); break; } return FALSE; } void show_spec_cmds( CHAR_DATA *ch ) { char buf [ MAX_STRING_LENGTH ]; char buf1 [ MAX_STRING_LENGTH ]; int spec; int col; extern const struct spec_type spec_table []; buf1[0] = '\0'; col = 0; send_to_char( "Preceed special functions with 'spec_'\n\r\n\r", ch ); for (spec = 0; *spec_table[spec].spec; 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" ); send_to_char( buf1, ch ); return; } /***************************************************************************** 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; 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" ); send_to_char( buf1, ch ); 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 < MAX_SKILL; 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" ); send_to_char( buf1, ch ); return; } void show_itemspells( CHAR_DATA *ch ) { char buf [ MSL ]; char buf1 [ MSL ]; int cnt; buf1[0] = '\0'; for( cnt = 0; spells[cnt].name; cnt++ ) { sprintf(buf, "%-15.15s",spells[cnt].name ); strcat( buf1, buf ); if( cnt % 5 == 0 ) strcat( buf1, "\n\r" ); else strcat( buf1, " "); } stc( buf1, ch ); }; /***************************************************************************** Name: do_qhelp Purpose: Displays help for many tables used in OLC. ****************************************************************************/ void do_qhelp( CHAR_DATA *ch, 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' ) { send_to_char( "Syntax: qhelp <command>\n\r", ch ); send_to_char( "\n\r", ch ); send_to_char( "Command being one of:\n\r", ch ); for (cnt = 0; help_table[cnt].command[0] != '\0'; cnt++) if( get_trust(ch) >= help_table[cnt].trust ) ch_printf( ch, "%-14.14s %s\n\r", capitalize( help_table[cnt].command ), help_table[cnt].desc ); return; } /* * Find the command, show changeable data. * --------------------------------------- */ for (cnt = 0; *help_table[cnt].command && help_table[cnt].trust <= get_trust(ch); 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; } else if ( help_table[cnt].structure == spells ) { show_itemspells( ch ); return; } if ( help_table[cnt].structure == skill_table ) { if ( spell[0] == '\0' ) { send_to_char( "Syntax: ? spells " "[ignore/attack/defend/self/object/all]\n\r", ch); return; } 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 send_to_char( "Syntax: ? spell " "[ignore/attack/defend/self/object/all]\n\r", ch); return; } else { show_flag_cmds( ch, help_table[cnt].structure ); return; } } } do_qhelp( ch, "" ); return; } /***************************************************************************** Name: show_help Purpose: Displays help for many tables used in OLC. Called by: olc interpreters. ****************************************************************************/ bool show_help( CHAR_DATA *ch, 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' ) { send_to_char( "Syntax: ? [command]\n\r\n\r", ch ); send_to_char( "[command] [description]\n\r", ch ); for (cnt = 0; help_table[cnt].command[0] != '\0'; cnt++) if( get_trust(ch) >= help_table[cnt].trust ) ch_printf( ch, "%-10.10s -%s\n\r", capitalize( help_table[cnt].command ), help_table[cnt].desc ); return FALSE; } /* * Find the command, show changeable data. * --------------------------------------- */ for (cnt = 0; *help_table[cnt].command && help_table[cnt].trust <= get_trust(ch); 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 == spells ) { show_itemspells( ch ); return FALSE; } if ( help_table[cnt].structure == skill_table ) { if ( spell[0] == '\0' ) { send_to_char( "Syntax: ? spells " "[ignore/attack/defend/self/object/all]\n\r", ch); 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 send_to_char( "Syntax: ? spell " "[ignore/attack/defend/self/object/all]\n\r", ch); return FALSE; } else { show_flag_cmds( ch, help_table[cnt].structure ); return FALSE; } } } show_help( ch, "" ); return FALSE; } /* Executed from comm.c. Minimizes compiling when changes are made. */ bool run_olc_editor( DESCRIPTOR_DATA *d ) { switch ( d->editor ) { case ED_AREA: aedit( d->character, d->incomm ); break; case ED_ROOM: redit( d->character, d->incomm ); break; case ED_OBJECT: oedit( d->character, d->incomm ); break; case ED_MOBILE: medit( d->character, d->incomm ); break; case ED_HELP: hedit( d->character, d->incomm ); break; case ED_CMD: cmdedit( d->character, d->incomm ); break; case ED_SOCIAL: sedit( d->character, d->incomm ); break; case ED_CONTROL: cedit( d->character, d->incomm ); break; case ED_CLAN: cledit( d->character, d->incomm ); break; case ED_RENAME: rename_object( d->character, d->incomm ); break; default: return FALSE; } return TRUE; } char *olc_ed_name( CHAR_DATA *ch ) { static char buf[10]; buf[0] = '\0'; switch (ch->desc->editor) { case ED_AREA: sprintf( buf, "AEdit" ); break; case ED_ROOM: sprintf( buf, "REdit" ); break; case ED_OBJECT: sprintf( buf, "OEdit" ); break; case ED_MOBILE: sprintf( buf, "MEdit" ); break; case ED_CONTROL: sprintf( buf, "CEdit" ); break; case ED_CLAN: sprintf( buf, "CLEdit" ); break; default: sprintf( buf, " " ); break; } return buf; } char *olc_ed_vnum( CHAR_DATA *ch ) { AREA_DATA *pArea; ROOM_INDEX_DATA *pRoom; OBJ_INDEX_DATA *pObj; MOB_INDEX_DATA *pMob; CLAN_DATA *pClan; static char buf[10]; buf[0] = '\0'; switch ( ch->desc->editor ) { case ED_AREA: pArea = (AREA_DATA *)ch->desc->pEdit; sprintf( buf, "%d", pArea ? pArea->vnum : 0 ); break; case ED_ROOM: pRoom = ch->in_room; sprintf( buf, "%d", pRoom ? pRoom->vnum : 0 ); break; case ED_OBJECT: pObj = (OBJ_INDEX_DATA *)ch->desc->pEdit; sprintf( buf, "%d", pObj ? pObj->vnum : 0 ); break; case ED_MOBILE: pMob = (MOB_INDEX_DATA *)ch->desc->pEdit; sprintf( buf, "%d", pMob ? pMob->vnum : 0 ); break; case ED_CLAN: pClan = (CLAN_DATA *)ch->desc->pEdit; sprintf( buf, "%s", pClan ? pClan->filename : ""); break; default: sprintf( buf, " " ); break; } return buf; } /* * Memory Recycling */ RESET_DATA *new_reset_data(void) { RESET_DATA *pReset; if (reset_free == NULL) { pReset = alloc_perm(sizeof(*pReset)); top_reset++; } else { pReset = reset_free; reset_free = reset_free->next; } pReset->next = NULL; pReset->command = 'X'; pReset->arg1 = 0; pReset->arg2 = 0; pReset->arg3 = 0; return pReset; } void free_reset_data(RESET_DATA *pReset) { pReset->next = reset_free; reset_free = pReset; return; } extern HELP_AREA * had_free; HELP_AREA * new_had args( ( void ) ); HELP_DATA * help_free; HELP_DATA * new_help ( void ) { HELP_DATA * help; if ( help_free ) { help = help_free; help_free = help_free->next; } else help = alloc_perm( sizeof( *help ) ); return help; } void free_help(HELP_DATA *help) { free_string(help->keyword); free_string(help->text); help->next = help_free; help_free = help; } AREA_DATA *new_area(void) { AREA_DATA *pArea; char buf[MAX_INPUT_LENGTH]; if (area_free == NULL) { pArea = alloc_perm(sizeof(*pArea)); top_area++; } else { pArea = area_free; area_free = area_free->next; } pArea->next = NULL; pArea->name = str_dup("New area"); pArea->area_flags = AREA_ADDED | AREA_UNLINKED; pArea->security = 1; pArea->builders = str_dup("None"); pArea->lvnum = 0; pArea->uvnum = 0; pArea->age = 0; pArea->nplayer = 0; sprintf(buf, "area%d.are", pArea->vnum); pArea->filename = str_dup(buf); pArea->vnum = top_area-1; pArea->mod = 0; pArea->bits = 0; return pArea; } void free_area(AREA_DATA *pArea) { free_string(pArea->name); free_string(pArea->filename); free_string(pArea->builders); pArea->next = area_free->next; area_free = pArea; return; } EXIT_DATA *new_exit(void) { EXIT_DATA *pExit; if (exit_free == NULL) { pExit = alloc_perm(sizeof(*pExit)); top_exit++; } else { pExit = exit_free; exit_free = exit_free->next; } pExit->to_room = NULL; pExit->next = NULL; pExit->vnum = 0; pExit->exit_info = 0; pExit->key = 0; free_string( pExit->keyword ); pExit->keyword = str_dup(""); free_string( pExit->description ); pExit->description = str_dup(""); pExit->rs_flags = 0; return pExit; } void free_exit(EXIT_DATA *pExit) { free_string(pExit->keyword); free_string(pExit->description); pExit->next = exit_free; exit_free = pExit; return; } EXTRA_DESCR_DATA *new_extra_descr(void) { EXTRA_DESCR_DATA *pExtra; if (extra_descr_free == NULL) { pExtra = alloc_perm(sizeof(*pExtra)); top_ed++; } else { pExtra = extra_descr_free; extra_descr_free = extra_descr_free->next; } pExtra->keyword = NULL; pExtra->description = NULL; pExtra->next = NULL; return pExtra; } void free_extra_descr(EXTRA_DESCR_DATA *pExtra) { free_string(pExtra->keyword); free_string(pExtra->description); pExtra->next = extra_descr_free; extra_descr_free = pExtra; return; } ROOM_INDEX_DATA *new_room_index(void) { ROOM_INDEX_DATA *pRoom; int i; if (room_index_free == NULL) { pRoom = alloc_perm(sizeof(*pRoom)); top_room++; } else { pRoom = room_index_free; room_index_free = room_index_free->next; } pRoom->next = NULL; pRoom->people = NULL; pRoom->contents = NULL; pRoom->extra_descr = NULL; pRoom->area = NULL; for (i = 0; i < MAX_DIR; i++) { pRoom->exit[i] = NULL; pRoom->track_dir[i] = 0; pRoom->track[i] = str_dup(""); } pRoom->name = &str_empty[0]; pRoom->description = &str_empty[0]; pRoom->vnum = 0; pRoom->room_flags = 0; pRoom->light = 0; pRoom->sector_type = 0; pRoom->roomtext = NULL; pRoom->affected = NULL; pRoom->affected_by = 0; return pRoom; } void free_room_index(ROOM_INDEX_DATA *pRoom) { int i; EXTRA_DESCR_DATA *pExtra; free_string(pRoom->name); free_string(pRoom->description); for (i = 0; i < MAX_DIR; i++) { if (pRoom->exit[i] != NULL) free_exit(pRoom->exit[i]); if (pRoom->track[i]) free_string( pRoom->track[i]); } for (pExtra = pRoom->extra_descr; pExtra != NULL; pExtra = pExtra->next) { free_extra_descr(pExtra); } pRoom->next = room_index_free; room_index_free = pRoom; return; } AFFECT_DATA *new_affect(void) { AFFECT_DATA *pAf; if (affect_free == NULL) { pAf = alloc_perm(sizeof(*pAf)); top_affect++; } else { pAf = affect_free; affect_free = affect_free->next; } pAf->next = NULL; pAf->location = 0; pAf->modifier = 0; pAf->type = 0; pAf->duration = 0; pAf->bitvector = 0; return pAf; } void free_affect(AFFECT_DATA* pAf) { pAf->next = affect_free; affect_free = pAf; return; } SHOP_DATA *new_shop(void) { SHOP_DATA *pShop; int buy; if (shop_free == NULL) { pShop = alloc_perm(sizeof(*pShop)); top_shop++; } else { pShop = shop_free; shop_free = shop_free->next; } pShop->next = NULL; pShop->keeper = 0; for (buy=0; buy<MAX_TRADE; buy++) pShop->buy_type[buy] = ITEM_NONE; pShop->profit_buy = 100; pShop->profit_sell = 100; pShop->open_hour = 0; pShop->close_hour = 23; return pShop; } void free_shop(SHOP_DATA *pShop) { pShop->next = shop_free; shop_free = pShop; return; } OBJ_INDEX_DATA *new_obj_index(void) { OBJ_INDEX_DATA *pObj; int value; if (obj_index_free == NULL) { pObj = alloc_perm(sizeof(*pObj)); top_obj_index++; } else { pObj = obj_index_free; obj_index_free = obj_index_free->next; } pObj->next = NULL; pObj->extra_descr = NULL; pObj->affected = NULL; pObj->area = NULL; pObj->name = str_dup("no name"); pObj->short_descr = str_dup("(no short description)"); pObj->description = str_dup("(no description)"); pObj->vnum = 0; pObj->item_type = ITEM_TRASH; pObj->extra_flags = 0; pObj->wear_flags = 0; pObj->count = 0; pObj->weight = 0; pObj->cost = 0; pObj->quest = 0; for (value=0; value<MAX_OVALUE; value++) pObj->value[value] = 0; return pObj; } void free_obj_index(OBJ_INDEX_DATA *pObj) { EXTRA_DESCR_DATA *pExtra; AFFECT_DATA *pAf; free_string(pObj->name); free_string(pObj->short_descr); free_string(pObj->description); for (pAf = pObj->affected; pAf != NULL; pAf = pAf->next) { free_affect(pAf); } for (pExtra = pObj->extra_descr; pExtra != NULL; pExtra = pExtra->next) { free_extra_descr(pExtra); } pObj->next = obj_index_free; obj_index_free = pObj; return; } MOB_INDEX_DATA *new_mob_index(void) { MOB_INDEX_DATA *pMob; if (mob_index_free == NULL) { pMob = alloc_perm(sizeof(*pMob)); top_mob_index++; } else { pMob = mob_index_free; mob_index_free = mob_index_free->next; } pMob->next = NULL; pMob->spec_fun = NULL; pMob->pShop = NULL; pMob->area = NULL; pMob->player_name = str_dup("no name"); pMob->short_descr = str_dup("(no short description)"); pMob->long_descr = str_dup("(no long description)"); pMob->description = str_dup(""); pMob->vnum = 0; pMob->count = 0; pMob->killed = 0; pMob->sex = 0; pMob->level = 0; pMob->act = 1; /* NPC */ pMob->affected_by = 0; pMob->alignment = 0; pMob->hitroll = 0; pMob->ac = 0; pMob->hitnodice = 0; pMob->hitsizedice = 0; pMob->hitplus = 0; pMob->damnodice = 0; pMob->damsizedice = 0; pMob->damplus = 0; pMob->gold = 0; return pMob; } void free_mob_index(MOB_INDEX_DATA *pMob) { free_string(pMob->player_name); free_string(pMob->short_descr); free_string(pMob->long_descr); free_string(pMob->description); free_shop(pMob->pShop); pMob->next = mob_index_free; mob_index_free = pMob; return; } /* * End Memory Recycling */ AREA_DATA *get_area_data(int vnum) { AREA_DATA *pArea; for (pArea = area_first; pArea != NULL; pArea = pArea->next) { if (pArea->vnum == vnum) return pArea; } return NULL; } bool check_range( int lower, int upper ) { AREA_DATA *pArea; int cnt = 0; for ( pArea = area_first; pArea; pArea = pArea->next ) { /* * lower < area < upper */ if ( ( lower <= pArea->lvnum && upper >= pArea->lvnum ) || ( upper >= pArea->uvnum && lower <= pArea->uvnum ) ) cnt++; if ( cnt > 1 ) return FALSE; } return TRUE; } AREA_DATA *get_vnum_area(int vnum) { AREA_DATA *pArea; for (pArea = area_first; pArea != NULL; pArea = pArea->next) { if (vnum >= pArea->lvnum && vnum <= pArea->uvnum) return pArea; } return NULL; } /************************************************************************ * Editors ************************************************************************/ bool edit_done (CHAR_DATA * ch) { if (ch->desc->editor != ED_NONE) send_to_char("You exit the editor.\n\r", ch); ch->desc->pEdit = NULL; ch->desc->editor = ED_NONE; return FALSE; } void set_editor( DESCRIPTOR_DATA *d, int editor, void * param ) { d->editor = editor; d->pEdit = param; } /* * Now for the prime editor functions */ AEDIT(aedit_mod) { AREA_DATA *pArea; EDIT_AREA( ch, pArea ); if( !argument || !is_number(argument)) { send_to_char("Syntax: mod [##]\n\r", ch ); return FALSE; } pArea->mod = atoi(argument); send_to_char("Area mod set.\n\r",ch); return TRUE; } bool aedit_reset( CHAR_DATA *ch, char *argument ) { AREA_DATA *pArea; EDIT_AREA(ch, pArea); reset_area( pArea ); send_to_char( "Area reset.\n\r", ch ); return FALSE; } AEDIT(aedit_show) { AREA_DATA *pArea; char buf [ MAX_STRING_LENGTH ]; EDIT_AREA( ch, pArea ); sprintf(buf, "%d", pArea->vnum); do_ashow(ch, buf); return FALSE; } AEDIT(aedit_connected) { AREA_DATA *pArea; ROOM_INDEX_DATA *pRoom; char buf [MAX_STRING_LENGTH]; int i; EDIT_AREA(ch, pArea); for( i = 0; i < MAX_KEY_HASH; i++ ) { for( pRoom = room_index_hash[i]; pRoom; pRoom = pRoom->next ) { checkexits( pRoom, pArea, buf); stc( buf, ch ); } } return FALSE; } AEDIT(aedit_create) { AREA_DATA *pArea; pArea = new_area(); area_last->next = pArea; send_to_char("Area created.\n\r", ch); set_editor( ch->desc, ED_AREA, pArea ); return TRUE; } AEDIT(aedit_name) { AREA_DATA *pArea; char arg2[MAX_INPUT_LENGTH]; EDIT_AREA( ch, pArea ); argument = one_argument( argument, arg2 ); if (arg2[0] == '\0') { send_to_char("Syntax: name [$name]\n\r", ch); return FALSE; } free_string(pArea->name); pArea->name = str_dup(arg2); send_to_char("Name set.\n\r", ch); return TRUE; } AEDIT( aedit_filename ) { 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' ) { send_to_char( "Syntax: filename [$file]\n\r", ch ); return FALSE; } /* * Simple Syntax Check. */ length = strlen( argument ); if ( length > 8 ) { send_to_char( "No more than eight characters allowed.\n\r", ch ); return FALSE; } /* * Allow only letters and numbers. */ for ( i = 0; i < length; i++ ) { if ( !isalnum( file[i] ) ) { send_to_char( "Only letters and numbers are valid.\n\r", ch ); return FALSE; } } free_string( pArea->filename ); strcat( file, ".are" ); pArea->filename = str_dup( file ); send_to_char( "Filename set.\n\r", ch ); return TRUE; } bool aedit_age( CHAR_DATA *ch, char *argument ) { AREA_DATA *pArea; char age[MAX_STRING_LENGTH]; EDIT_AREA(ch, pArea); one_argument( argument, age ); if ( !is_number( age ) || age[0] == '\0' ) { send_to_char( "Syntax: age [#age]\n\r", ch ); return FALSE; } pArea->age = atoi( age ); send_to_char( "Age set.\n\r", ch ); return TRUE; } bool aedit_security( CHAR_DATA *ch, char *argument ) { AREA_DATA *pArea; char sec[MAX_STRING_LENGTH]; char buf[MAX_STRING_LENGTH]; int value; EDIT_AREA(ch, pArea); one_argument( argument, sec ); if ( !is_number( sec ) || sec[0] == '\0' ) { send_to_char( "Syntax: security [#level]\n\r", ch ); return FALSE; } value = atoi( sec ); if ( value > ch->pcdata->security || value < 0 ) { if ( ch->pcdata->security != 0 ) { sprintf( buf, "Security is 0-%d.\n\r", ch->pcdata->security ); send_to_char( buf, ch ); } else send_to_char( "Security is 0 only.\n\r", ch ); return FALSE; } pArea->security = value; send_to_char( "Security set.\n\r", ch ); return TRUE; } bool aedit_builder( CHAR_DATA *ch, char *argument ) { 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' ) { send_to_char( "Syntax: builder [$name] -toggles builder\n\r", ch ); send_to_char( "Syntax: builder All -allows everyone\n\r", ch ); 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" ); } send_to_char( "Builder removed.\n\r", ch ); 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 ) ); send_to_char( "Builder added.\n\r", ch ); return TRUE; } return FALSE; } bool aedit_vnum( CHAR_DATA *ch, char *argument ) { AREA_DATA *pArea; char lower[MAX_STRING_LENGTH]; char upper[MAX_STRING_LENGTH]; int ilower; int 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' ) { send_to_char( "Syntax: vnum [#lower] [#upper]\n\r", ch ); return FALSE; } if ( ( ilower = atoi( lower ) ) > ( iupper = atoi( upper ) ) ) { send_to_char( "AEdit: Upper must be larger then lower.\n\r", ch ); return FALSE; } /* OLC 1.1b */ if ( ilower <= 0 || ilower >= INT_MAX || iupper <= 0 || iupper >= INT_MAX ) { char output[MAX_STRING_LENGTH]; sprintf( output, "AEdit: vnum must be between 0 and %d.\n\r", INT_MAX ); send_to_char( output, ch ); return FALSE; } if ( !check_range( ilower, iupper ) ) { send_to_char( "AEdit: Range must include only this area.\n\r", ch ); return FALSE; } if ( get_vnum_area( ilower ) && get_vnum_area( ilower ) != pArea ) { send_to_char( "AEdit: Lower vnum already assigned.\n\r", ch ); return FALSE; } pArea->lvnum = ilower; send_to_char( "Lower vnum set.\n\r", ch ); if ( get_vnum_area( iupper ) && get_vnum_area( iupper ) != pArea ) { send_to_char( "AEdit: Upper vnum already assigned.\n\r", ch ); return TRUE; /* The lower value has been set. */ } pArea->uvnum = iupper; send_to_char( "Upper vnum set.\n\r", ch ); return TRUE; } bool aedit_lvnum( CHAR_DATA *ch, char *argument ) { AREA_DATA *pArea; char lower[MAX_STRING_LENGTH]; int ilower; int iupper; EDIT_AREA(ch, pArea); one_argument( argument, lower ); if ( !is_number( lower ) || lower[0] == '\0' ) { send_to_char( "Syntax: lvnum [#lower]\n\r", ch ); return FALSE; } if ( ( ilower = atoi( lower ) ) > ( iupper = pArea->uvnum ) ) { send_to_char( "AEdit: Value must be less than the uvnum.\n\r", ch ); return FALSE; } /* OLC 1.1b */ if ( ilower <= 0 || ilower >= INT_MAX || iupper <= 0 || iupper >= INT_MAX ) { char output[MAX_STRING_LENGTH]; sprintf( output, "AEdit: vnum must be between 0 and %d.\n\r", INT_MAX ); send_to_char( output, ch ); return FALSE; } if ( !check_range( ilower, iupper ) ) { send_to_char( "AEdit: Range must include only this area.\n\r", ch ); return FALSE; } if ( get_vnum_area( ilower ) && get_vnum_area( ilower ) != pArea ) { send_to_char( "AEdit: Lower vnum already assigned.\n\r", ch ); return FALSE; } pArea->lvnum = ilower; send_to_char( "Lower vnum set.\n\r", ch ); return TRUE; } bool aedit_uvnum( CHAR_DATA *ch, char *argument ) { AREA_DATA *pArea; char upper[MAX_STRING_LENGTH]; int ilower; int iupper; EDIT_AREA(ch, pArea); one_argument( argument, upper ); if ( !is_number( upper ) || upper[0] == '\0' ) { send_to_char( "Syntax: uvnum [#upper]\n\r", ch ); return FALSE; } if ( ( ilower = pArea->lvnum ) > ( iupper = atoi( upper ) ) ) { send_to_char( "AEdit: Upper must be larger then lower.\n\r", ch ); return FALSE; } /* OLC 1.1b */ if ( ilower <= 0 || ilower >= INT_MAX || iupper <= 0 || iupper >= INT_MAX ) { char output[MAX_STRING_LENGTH]; sprintf( output, "AEdit: vnum must be between 0 and %d.\n\r", INT_MAX ); send_to_char( output, ch ); return FALSE; } if ( !check_range( ilower, iupper ) ) { send_to_char( "AEdit: Range must include only this area.\n\r", ch ); return FALSE; } if ( get_vnum_area( iupper ) && get_vnum_area( iupper ) != pArea ) { send_to_char( "AEdit: Upper vnum already assigned.\n\r", ch ); return FALSE; } pArea->uvnum = iupper; send_to_char( "Upper vnum set.\n\r", ch ); return TRUE; } void aedit(CHAR_DATA *ch, char *argument) { AREA_DATA *pArea; char arg[MAX_STRING_LENGTH]; char arg1[MAX_STRING_LENGTH]; char arg2[MAX_STRING_LENGTH]; char buf [MAX_STRING_LENGTH]; int value, cmd; EDIT_AREA(ch,pArea); strcpy(arg, argument); smash_tilde(argument); argument = one_argument(argument, arg1); strcpy(arg2, argument); if (!IS_BUILDER(ch, pArea)) { send_to_char("AEdit: Insufficient security to modify area.\n\r", ch); } if (arg1[0] == '\0') { sprintf(buf, "%d", pArea->vnum); do_ashow(ch, buf); return; } if (!str_cmp(arg1, "done")) { edit_done( ch ); return; } if (!IS_BUILDER(ch, pArea)) { edit_done(ch); interpret(ch, arg); return; } for ( cmd = 0; *aedit_table[cmd].name; cmd++ ) { if ( !str_prefix( arg1, aedit_table[cmd].name ) ) { if ( (*aedit_table[cmd].olc_fun) ( ch, argument ) ) SET_BIT( pArea->area_flags, AREA_CHANGED ); return; } } /* Take care of flags. */ if ( ( value = flag_value( area_flags, arg ) ) != NO_FLAG ) { TOGGLE_BIT(pArea->area_flags, value); SET_BIT( pArea->area_flags, AREA_CHANGED ); send_to_char( "Flag toggled.\n\r", ch ); return; } interpret(ch, arg); return; } void do_rlist( CHAR_DATA *ch, char *argument ) { ROOM_INDEX_DATA *room; int vnum; char arg1[MAX_INPUT_LENGTH]; char arg2[MAX_INPUT_LENGTH]; AREA_DATA *tarea; int lrange; int trange; if ( IS_NPC(ch) || !ch->pcdata || !IS_BUILDER_HERE(ch)) { stc( "{YYou don't have an assigned area.\n\r", ch ); return; } tarea = ch->in_room->area; argument = one_argument( argument, arg1 ); argument = one_argument( argument, arg2 ); if ( arg1[0]!='\0' && !is_number(arg1) ) return; if ( arg2[0]!='\0' && !is_number(arg2) ) return; if ( tarea ) { if ( arg1[0] == '\0' ) /* cleaned a big scary mess */ lrange = tarea->lvnum; /* here. -Thoric */ else lrange = atoi( arg1 ); if ( arg2[0] == '\0' ) trange = tarea->uvnum; else trange = atoi(arg2); if ((lrange < tarea->lvnum || trange > tarea->uvnum) && get_trust( ch ) < MAX_LEVEL-2 ) { stc("{YThat is out of your vnum range.\n\r", ch); return; } } else { lrange = ( is_number( arg1 ) ? atoi( arg1 ) : 1 ); trange = ( is_number( arg2 ) ? atoi( arg2 ) : 1 ); } for ( vnum = lrange; vnum <= trange; vnum++ ) { if ( (room = get_room_index( vnum )) == NULL ) continue; ch_printf( ch, "{W%5d{C) {c%s\n\r", vnum, room->name ); } return; } void do_olist( CHAR_DATA *ch, char *argument ) { OBJ_INDEX_DATA *obj; int vnum; AREA_DATA *tarea; char arg1[MAX_INPUT_LENGTH]; char arg2[MAX_INPUT_LENGTH]; int lrange; int trange; /* * Greater+ can list out of assigned range - Tri (mlist/rlist as well) */ if ( !IS_BUILDER_HERE(ch) ) { stc( "{YYou don't have an assigned area.\n\r", ch ); return; } tarea = ch->in_room->area; argument = one_argument( argument, arg1 ); argument = one_argument( argument, arg2 ); if ( tarea ) { if ( arg1[0] == '\0' ) /* cleaned a big scary mess */ lrange = tarea->lvnum; /* here. -Thoric */ else lrange = atoi( arg1 ); if ( arg2[0] == '\0' ) trange = tarea->uvnum; else trange = atoi(arg2); if ((lrange < tarea->lvnum || trange > tarea->uvnum) && get_trust( ch ) < MAX_LEVEL-2 ) { stc("{YThat is out of your vnum range.\n\r", ch); return; } } else { lrange = ( is_number( arg1 ) ? atoi( arg1 ) : 1 ); trange = ( is_number( arg2 ) ? atoi( arg2 ) : 3 ); } for ( vnum = lrange; vnum <= trange; vnum++ ) { if ( (obj = get_obj_index( vnum )) == NULL ) continue; ch_printf( ch, "{W%5d{C) {c%-20s {C({D%s{C)\n\r", vnum, obj->name, obj->short_descr ); } return; } void do_mlist( CHAR_DATA *ch, char *argument ) { MOB_INDEX_DATA *mob; int vnum; AREA_DATA *tarea; char arg1[MAX_INPUT_LENGTH]; char arg2[MAX_INPUT_LENGTH]; int lrange; int trange; if ( IS_BUILDER_HERE(ch) ) { stc( "{YYou don't have an assigned area.\n\r", ch ); return; } tarea = ch->in_room->area; argument = one_argument( argument, arg1 ); argument = one_argument( argument, arg2 ); if ( tarea ) { if ( arg1[0] == '\0' ) /* cleaned a big scary mess */ lrange = tarea->lvnum; /* here. -Thoric */ else lrange = atoi( arg1 ); if ( arg2[0] == '\0' ) trange = tarea->uvnum; else trange = atoi(arg2); if ((lrange < tarea->lvnum || trange > tarea->uvnum) && get_trust( ch ) < MAX_LEVEL-2 ) { stc("{YThat is out of your vnum range.\n\r", ch); return; } } else { lrange = ( is_number( arg1 ) ? atoi( arg1 ) : 1 ); trange = ( is_number( arg2 ) ? atoi( arg2 ) : 1 ); } for ( vnum = lrange; vnum <= trange; vnum++ ) { if ( (mob = get_mob_index( vnum )) == NULL ) continue; ch_printf( ch, "{W%5d{C) {c%-20s{C ({D%s{C)\n\r", vnum, mob->player_name, mob->short_descr ); } } /* Entry point for editing area_data. */ void do_aedit (CHAR_DATA * ch, char *argument) { AREA_DATA *pArea; int value; char arg[MAX_STRING_LENGTH]; pArea = ch->in_room->area; argument = one_argument (argument, arg); if (is_number (arg)) { value = atoi (arg); if (!(pArea = get_area_data (value))) { send_to_char ("{YThat area vnum does not exist.\n\r", ch); return; } } else if (!str_cmp (arg, "create")) { pArea = new_area(); area_last->next = pArea; ch->desc->pEdit = (void *)pArea; send_to_char("{YArea created.\n\r", ch); } if (!IS_BUILDER (ch, pArea) || ch->pcdata->security < 9) { send_to_char ("{YInsufficant security to modify this area.\n\r", ch); return; } set_editor(ch->desc, ED_AREA, pArea); return; } REDIT(redit_findreset) { OBJ_INDEX_DATA *pObj; AREA_DATA *pArea; ROOM_INDEX_DATA *pRoom; RESET_DATA *pReset; MOB_INDEX_DATA *pMob; int room; char mobs [ MSL ]; char objs [ MSL ]; char buf [ MSL ]; EDIT_ROOM(ch, pRoom); pArea = pRoom->area; mobs[0] = '\0'; objs[0] = '\0'; if( argument[0] == '\0') { stc("Find mobs/objects with which keyword?\n\r", ch); return FALSE; } for( room = pArea->lvnum; room < pArea->uvnum; room++ ) { pRoom = get_room_index( room ); if( !pRoom ) continue; if( pRoom->area != pArea ) continue; for( pReset = pRoom->reset_first; pReset; pReset = pReset->next ) { switch( pReset->command ) { default: break; case 'M': if( !(pMob = get_mob_index( pReset->arg1 ) ) ) break; if( !is_name( argument, pMob->player_name ) ) break; sprintf( buf, "[%5d] %-13.13s in room %-23.23s [%5d]\n\r", pReset->arg1, pMob->short_descr, pRoom->name, pRoom->vnum ); strcat( mobs, buf ); break; case 'O': case 'P': case 'G': case 'E': if( !(pObj = get_obj_index( pReset->arg1 ) ) ) break; if( !is_name( argument, pObj->name ) ) break; sprintf( buf, "[%5d] %-13.13s in room %-23.23s [%5d]\n\r", pReset->arg1, pObj->short_descr, pRoom->name, pRoom->vnum ); strcat( objs, buf ); break; } } } stc( "----------------------------------[{CMobiles{n]----------------------------------\n\r",ch); stc( mobs, ch ); stc( "----------------------------------[{CObjects{n]----------------------------------\n\r",ch); stc( objs, ch ); return FALSE; } REDIT( redit_create ) { AREA_DATA *pArea; ROOM_INDEX_DATA *pRoom; char arg [ MAX_INPUT_LENGTH ]; int value, iHash; argument = one_argument( argument, arg ); value = atoi(arg); if (arg[0] == '\0' || value == 0) { send_to_char("{YSyntax: create [vnum]\n\r", ch); return FALSE; } pArea = get_vnum_area(value); if (pArea == NULL) { send_to_char("{YREdit: That vnum is not assigned an area.\n\r", ch); return FALSE; } if (!IS_BUILDER(ch, pArea)) { send_to_char("{YREdit: Vnum in an area you cannot build in.\n\r", ch); return FALSE; } if (get_room_index(value) != NULL) { send_to_char("{YREdit: Room vnum already exists.\n\r", ch); 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; pRoom->next = room_index_hash[iHash]; room_index_hash[iHash] = pRoom; // ch->desc->pEdit = (void *)pRoom; set_editor( ch->desc, ED_ROOM, pRoom ); SET_BIT(pArea->area_flags, AREA_CHANGED); send_to_char("Room created.\n\r", ch); return TRUE; } REDIT(redit_show) { ROOM_INDEX_DATA *pRoom; char buf [ 50 ]; EDIT_ROOM( ch, pRoom ); sprintf( buf, "%d", pRoom->vnum ); do_rshow( ch, buf ); return FALSE; } /* OLC 1.1b */ /***************************************************************************** Name: change_exit Purpose: Command interpreter for changing exits. Called by: redit_<dir>. This is a local function. ****************************************************************************/ bool change_exit( CHAR_DATA *ch, char *argument, int door ) { ROOM_INDEX_DATA *pRoom; char command[MAX_INPUT_LENGTH]; char arg[MAX_INPUT_LENGTH]; char total_arg[MAX_STRING_LENGTH]; int rev; int value = 0; EDIT_ROOM(ch, pRoom); /* Often used data. */ rev = rev_dir[door]; if ( argument[0] == '\0' ) { do_help( ch, "EXIT" ); return FALSE; } /* * Now parse the arguments. */ strcpy( total_arg, argument ); argument = one_argument( argument, command ); one_argument( argument, arg ); if ( !str_cmp( command, "delete" ) ) { if ( !pRoom->exit[door] ) { send_to_char( "REdit: Exit does not exist.\n\r", ch ); return FALSE; } /* * Remove To Room Exit. */ if ( pRoom->exit[door]->to_room && pRoom->exit[door]->to_room->exit[rev] ) { free_exit( pRoom->exit[door]->to_room->exit[rev] ); pRoom->exit[door]->to_room->exit[rev] = NULL; } /* * Remove this exit. */ free_exit( pRoom->exit[door] ); pRoom->exit[door] = NULL; send_to_char( "Exit unlinked.\n\r", ch ); return TRUE; } /* * Create a two-way exit. */ if ( !str_cmp( command, "link" ) ) { EXIT_DATA *pExit; ROOM_INDEX_DATA *pLinkRoom; if ( arg[0] == '\0' || !is_number( arg ) ) { send_to_char( "Syntax: [direction] link [vnum]\n\r", ch ); return FALSE; } if ( !( pLinkRoom = get_room_index( atoi(arg) ) ) ) { send_to_char( "REdit: Non-existant room.\n\r", ch ); return FALSE; } if ( !IS_BUILDER( ch, pLinkRoom->area ) ) { send_to_char( "REdit: Cannot link to that area.\n\r", ch ); return FALSE; } if ( pLinkRoom->exit[rev] ) { send_to_char( "REdit: Remote side's exit exists.\n\r", ch ); return FALSE; } if ( !pRoom->exit[door] ) /* No exit. */ pRoom->exit[door] = new_exit(); pRoom->exit[door]->to_room = pLinkRoom; /* Assign data. */ pRoom->exit[door]->vnum = value; pExit = new_exit(); /* No remote exit. */ pExit->to_room = ch->in_room; /* Assign data. */ pExit->vnum = ch->in_room->vnum; pLinkRoom->exit[rev] = pExit; /* Link exit to room. */ send_to_char( "Two-way link established.\n\r", ch ); return TRUE; } /* * Create room and make two-way exit. */ if ( !str_cmp( command, "dig" ) ) { char buf[MAX_INPUT_LENGTH]; if ( arg[0] == '\0' || !is_number( arg ) ) { send_to_char( "Syntax: [direction] dig <vnum>\n\r", ch ); return FALSE; } redit_create( ch, arg ); /* Create the room. */ sprintf( buf, "link %s", arg ); change_exit( ch, buf, door); /* Create the exits. */ return TRUE; } /* * Create one-way exit. */ if ( !str_cmp( command, "room" ) ) { ROOM_INDEX_DATA *pLinkRoom; if ( arg[0] == '\0' || !is_number( arg ) ) { send_to_char( "Syntax: [direction] room [vnum]\n\r", ch ); return FALSE; } if ( !( pLinkRoom = get_room_index( atoi( arg ) ) ) ) { send_to_char( "REdit: Non-existant room.\n\r", ch ); return FALSE; } if ( !pRoom->exit[door] ) pRoom->exit[door] = new_exit(); pRoom->exit[door]->to_room = pLinkRoom; pRoom->exit[door]->vnum = value; send_to_char( "One-way link established.\n\r", ch ); return TRUE; } if ( !str_cmp( command, "remove" ) ) { if ( arg[0] == '\0' ) { send_to_char( "Syntax: [direction] remove [key/name/desc]\n\r", ch ); return FALSE; } if ( !pRoom->exit[door] ) { send_to_char( "REdit: Exit does not exist.\n\r", ch ); return FALSE; } if ( !str_cmp( argument, "key" ) ) { pRoom->exit[door]->key = 0; send_to_char( "Exit key removed.\n\r", ch ); return TRUE; } if ( !str_cmp( argument, "name" ) ) { free_string( pRoom->exit[door]->keyword ); pRoom->exit[door]->keyword = &str_empty[0]; send_to_char( "Exit name removed.\n\r", ch ); return TRUE; } if ( argument[0] == 'd' && !str_prefix( argument, "description" ) ) { free_string( pRoom->exit[door]->description ); pRoom->exit[door]->description = &str_empty[0]; send_to_char( "Exit description removed.\n\r", ch ); return TRUE; } send_to_char( "Syntax: [direction] remove [key/name/desc]\n\r", ch ); return FALSE; } if ( !str_cmp( command, "key" ) ) { OBJ_INDEX_DATA *pObjIndex; if ( arg[0] == '\0' || !is_number( arg ) ) { send_to_char( "Syntax: [direction] key [vnum]\n\r", ch ); return FALSE; } if ( !( pObjIndex = get_obj_index( atoi( arg ) ) ) ) { send_to_char( "REdit: Item does not exist.\n\r", ch ); return FALSE; } if ( pObjIndex->item_type != ITEM_KEY ) { send_to_char( "REdit: Item is not a key.\n\r", ch ); return FALSE; } if ( !pRoom->exit[door] ) pRoom->exit[door] = new_exit(); pRoom->exit[door]->key = pObjIndex->vnum; send_to_char( "Exit key set.\n\r", ch ); return TRUE; } if ( !str_cmp( command, "name" ) ) { if ( arg[0] == '\0' ) { send_to_char( "Syntax: [direction] name [string]\n\r", ch ); return FALSE; } if ( !pRoom->exit[door] ) pRoom->exit[door] = new_exit(); free_string( pRoom->exit[door]->keyword ); pRoom->exit[door]->keyword = str_dup( argument ); send_to_char( "Exit name set.\n\r", ch ); return TRUE; } if ( command[0] == 'd' && !str_prefix( command, "description" ) ) { if ( arg[0] == '\0' ) { if ( !pRoom->exit[door] ) pRoom->exit[door] = new_exit(); string_append( ch, &pRoom->exit[door]->description ); return TRUE; } send_to_char( "Syntax: [direction] desc\n\r", ch ); return FALSE; } /* * Set the exit flags, needs full argument. * ---------------------------------------- */ if ( ( value = flag_value( exit_flags, total_arg ) ) != NO_FLAG ) { ROOM_INDEX_DATA *pToRoom; /* * Create an exit if none exists. */ if ( !pRoom->exit[door] ) pRoom->exit[door] = new_exit(); /* * Set door bits for this room. */ TOGGLE_BIT(pRoom->exit[door]->rs_flags, value); pRoom->exit[door]->exit_info = pRoom->exit[door]->rs_flags; /* * Set door bits of wconnected room. * Skip one-way exits and non-existant rooms. */ if ( ( pToRoom = pRoom->exit[door]->to_room ) && pToRoom->exit[rev] ) { TOGGLE_BIT(pToRoom->exit[rev]->rs_flags, value); pToRoom->exit[rev]->exit_info = pToRoom->exit[rev]->rs_flags; } send_to_char( "Exit flag toggled.\n\r", ch ); return TRUE; } return FALSE; } REDIT( redit_north ) { if ( change_exit( ch, argument, DIR_NORTH ) ) return TRUE; return FALSE; } REDIT( redit_south ) { if ( change_exit( ch, argument, DIR_SOUTH ) ) return TRUE; return FALSE; } REDIT( redit_east ) { if ( change_exit( ch, argument, DIR_EAST ) ) return TRUE; return FALSE; } REDIT( redit_west ) { if ( change_exit( ch, argument, DIR_WEST ) ) return TRUE; return FALSE; } REDIT( redit_up) { if ( change_exit( ch, argument, DIR_UP ) ) return TRUE; return FALSE; } REDIT( redit_down ) { if ( change_exit( ch, argument, DIR_DOWN ) ) return TRUE; return FALSE; } /* OLC 1.1b */ REDIT( redit_move ) { interpret( ch, argument ); return FALSE; } REDIT( redit_roomtext ) { ROOM_INDEX_DATA *pRoom; ROOMTEXT_DATA *rt; char command[MAX_INPUT_LENGTH]; char keyword[MAX_INPUT_LENGTH]; int r; EDIT_ROOM(ch, pRoom); argument = one_argument( argument, command ); one_argument( argument, keyword ); if ( command[0] == '\0' || keyword[0] == '\0' ) { send_to_char( "Syntax: roomtext add [$keyword]\n\r", ch ); send_to_char( " roomtext show [$keyword]\n\r", ch ); send_to_char( "Keyword is the ## of the one you wish to edit.\n\r",ch ); return FALSE; } for( r=1,rt = pRoom->roomtext;rt; rt = rt->next,r++ ) { if( is_number(keyword) && r == atoi(keyword) ) break; else if ( is_name( rt->input, keyword ) ) break; } if( !rt ) { send_to_char( "That room_text does not exhist.\n\r", ch ); return FALSE; } if( !str_cmp( command, "show" ) ) { ch_printf( ch, "{cType: {C%s ", flag_string( rt_flags, rt->type ) ); ch_printf( ch, "{cPower: {n%d ", rt->power ); ch_printf( ch, "{cMob: {n%d\n\r", rt->mob ); ch_printf( ch, "{cInput: {n%s\n\r", rt->input ); ch_printf( ch, "{cName: {n%s\n\r", rt->name ); ch_printf( ch, "{cOutput: {n%s\n\r", rt->output ); ch_printf( ch, "{cChOutput: {n%s\n\r", rt->choutput ); return FALSE; } return FALSE; } REDIT( redit_ed ) { ROOM_INDEX_DATA *pRoom; EXTRA_DESCR_DATA *ed; char command[MAX_INPUT_LENGTH]; char keyword[MAX_INPUT_LENGTH]; EDIT_ROOM(ch, pRoom); argument = one_argument( argument, command ); one_argument( argument, keyword ); if ( command[0] == '\0' || keyword[0] == '\0' ) { send_to_char( "Syntax: ed add [keyword]\n\r", ch ); send_to_char( " ed edit [keyword]\n\r", ch ); send_to_char( " ed delete [keyword]\n\r", ch ); send_to_char( " ed format [keyword]\n\r", ch ); return FALSE; } if ( !str_cmp( command, "add" ) ) { if ( keyword[0] == '\0' ) { send_to_char( "Syntax: ed add [keyword]\n\r", ch ); return FALSE; } ed = new_extra_descr(); ed->keyword = str_dup( keyword ); ed->description = str_dup( "" ); ed->next = pRoom->extra_descr; pRoom->extra_descr = ed; string_append( ch, &ed->description ); return TRUE; } if ( !str_cmp( command, "edit" ) ) { if ( keyword[0] == '\0' ) { send_to_char( "Syntax: ed edit [keyword]\n\r", ch ); return FALSE; } for ( ed = pRoom->extra_descr; ed; ed = ed->next ) { if ( is_name( keyword, ed->keyword ) ) break; } if ( !ed ) { send_to_char( "REdit: Extra description keyword not found.\n\r", ch ); return FALSE; } string_append( ch, &ed->description ); return TRUE; } if ( !str_cmp( command, "delete" ) ) { EXTRA_DESCR_DATA *ped = NULL; if ( keyword[0] == '\0' ) { send_to_char( "Syntax: ed delete [keyword]\n\r", ch ); return FALSE; } for ( ed = pRoom->extra_descr; ed; ed = ed->next ) { if ( is_name( keyword, ed->keyword ) ) break; ped = ed; } if ( !ed ) { send_to_char( "REdit: Extra description keyword not found.\n\r", ch ); return FALSE; } if ( !ped ) pRoom->extra_descr = ed->next; else ped->next = ed->next; free_extra_descr( ed ); send_to_char( "Extra description deleted.\n\r", ch ); return TRUE; } if ( !str_cmp( command, "format" ) ) { if ( keyword[0] == '\0' ) { send_to_char( "Syntax: ed format [keyword]\n\r", ch ); return FALSE; } for ( ed = pRoom->extra_descr; ed; ed = ed->next ) { if ( is_name( keyword, ed->keyword ) ) break; } if ( !ed ) { send_to_char( "REdit: Extra description keyword not found.\n\r", ch ); return FALSE; } /* OLC 1.1b */ if ( strlen(ed->description) >= (MAX_STRING_LENGTH - 4) ) { send_to_char( "String too long to be formatted.\n\r", ch ); return FALSE; } ed->description = format_string( ed->description ); send_to_char( "Extra description formatted.\n\r", ch ); return TRUE; } redit_ed( ch, "" ); return FALSE; } REDIT( redit_name ) { ROOM_INDEX_DATA *pRoom; EDIT_ROOM(ch, pRoom); if ( argument[0] == '\0' ) { send_to_char( "Syntax: name [name]\n\r", ch ); return FALSE; } free_string( pRoom->name ); pRoom->name = str_dup( argument ); send_to_char( "Name set.\n\r", ch ); return TRUE; } REDIT( redit_desc ) { ROOM_INDEX_DATA *pRoom; EDIT_ROOM(ch, pRoom); if ( argument[0] == '\0' ) { string_append( ch, &pRoom->description ); return TRUE; } send_to_char( "Syntax: desc\n\r", ch ); return FALSE; } REDIT( redit_format ) { ROOM_INDEX_DATA *pRoom; EDIT_ROOM(ch, pRoom); /* OLC 1.1b */ if ( strlen(pRoom->description) >= (MAX_STRING_LENGTH - 4) ) { send_to_char( "String too long to be formatted.\n\r", ch ); return FALSE; } pRoom->description = format_string( pRoom->description ); send_to_char( "String formatted.\n\r", ch ); return TRUE; } REDIT( redit_mreset ) { ROOM_INDEX_DATA *pRoom; MOB_INDEX_DATA *pMobIndex; CHAR_DATA *newmob; char arg [ MAX_INPUT_LENGTH ]; RESET_DATA *pReset; char output [ MAX_STRING_LENGTH ]; EDIT_ROOM(ch, pRoom); argument = one_argument( argument, arg ); if ( arg[0] == '\0' || !is_number( arg ) ) { send_to_char ( "Syntax: mreset <vnum> <max #>\n\r", ch ); return FALSE; } if ( !( pMobIndex = get_mob_index( atoi( arg ) ) ) ) { send_to_char( "REdit: No mobile has that vnum.\n\r", ch ); return FALSE; } if ( pMobIndex->area != pRoom->area ) { send_to_char( "REdit: No such mobile in this area.\n\r", ch ); return FALSE; } /* * Create the mobile reset. */ pReset = new_reset_data(); pReset->command = 'M'; pReset->arg1 = pMobIndex->vnum; pReset->arg2 = is_number( argument ) ? atoi( argument ) : MAX_MOB; pReset->arg3 = pRoom->vnum; add_reset( pRoom, pReset, 0/* Last slot*/ ); /* * Create the mobile. */ newmob = create_mobile( pMobIndex ); char_to_room( newmob, pRoom ); sprintf( output, "%s (%d) has been loaded and added to resets.\n\r" "There will be a maximum of %d loaded to this room.\n\r", capitalize( pMobIndex->short_descr ), pMobIndex->vnum, pReset->arg2 ); send_to_char( output, ch ); act( "$n has created $N!", ch, NULL, newmob, TO_ROOM ); return TRUE; } /* * redit_copy function thanks to Zanthras of Mystical Realities MUD. */ REDIT( redit_copy ) { ROOM_INDEX_DATA *pRoom; ROOM_INDEX_DATA *pRoom2; /* Room to copy */ int vnum; if ( argument[0] == '\0' ) { send_to_char("Syntax: copy <vnum> \n\r",ch); return FALSE; } if ( !is_number(argument) ) { send_to_char("REdit: You must enter a number (vnum).\n\r",ch); return FALSE; } else /* argument is a number */ { vnum = atoi(argument); if( !( pRoom2 = get_room_index(vnum) ) ) { send_to_char("REdit: That room does not exist.\n\r",ch); return FALSE; } } EDIT_ROOM(ch, pRoom); free_string( pRoom->description ); pRoom->description = str_dup( pRoom2->description ); free_string( pRoom->name ); pRoom->name = str_dup( pRoom2->name ); /* sector flags */ pRoom->sector_type = pRoom2->sector_type; /* room flags */ pRoom->room_flags = pRoom2->room_flags; pRoom->extra_descr = pRoom2->extra_descr; send_to_char( "Room info copied.", ch ); 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 }, { WEAR_FACE, ITEM_WEAR_FACE }, { WEAR_EAR_L, ITEM_WEAR_EAR }, { WEAR_EAR_R, ITEM_WEAR_EAR }, { WEAR_NOSE, ITEM_WEAR_NOSE }, { WEAR_ANKLE_L, ITEM_WEAR_ANKLE }, { WEAR_ANKLE_R, ITEM_WEAR_ANKLE }, { NO_FLAG, NO_FLAG } }; /***************************************************************************** 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(int bits, int count) { int flag; for (flag = 0; wear_table[flag].wear_bit != NO_FLAG; flag++) { if ( IS_SET(bits, wear_table[flag].wear_bit) && --count < 1) return wear_table[flag].wear_loc; } return NO_FLAG; } /***************************************************************************** Name: wear_bit Purpose: Converts a wear_loc into a bit. Called by: redit_oreset(olc_act.c). ****************************************************************************/ int wear_bit(int loc) { int flag; for (flag = 0; wear_table[flag].wear_loc != NO_FLAG; 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; char output [ MAX_STRING_LENGTH ]; EDIT_ROOM(ch, pRoom); argument = one_argument( argument, arg1 ); argument = one_argument( argument, arg2 ); if ( arg1[0] == '\0' || !is_number( arg1 ) ) { send_to_char ( "Syntax: oreset <vnum> <args>\n\r", ch ); send_to_char ( " -no_args = into room\n\r", ch ); send_to_char ( " -<obj_name> = into obj\n\r", ch ); send_to_char ( " -<mob_name> <wear_loc> = into mob\n\r", ch ); return FALSE; } if ( !( pObjIndex = get_obj_index( atoi( arg1 ) ) ) ) { send_to_char( "REdit: No object has that vnum.\n\r", ch ); return FALSE; } if ( pObjIndex->area != pRoom->area ) { send_to_char( "REdit: No such object in this area.\n\r", ch ); 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; add_reset( pRoom, pReset, 0/* Last slot*/ ); newobj = create_object( pObjIndex, number_fuzzy( olevel ) ); obj_to_room( newobj, pRoom ); sprintf( output, "%s (%d) has been loaded and added to resets.\n\r", capitalize( pObjIndex->short_descr ), pObjIndex->vnum ); send_to_char( output, ch ); } else /* * Load into object's inventory. */ if ( argument[0] == '\0' && ( ( to_obj = get_obj_list( ch, arg2, pRoom->contents ) ) != NULL ) ) { pReset = new_reset_data(); pReset->command = 'P'; pReset->arg1 = pObjIndex->vnum; pReset->arg2 = pObjIndex->vnum; pReset->arg3 = to_obj->pIndexData->vnum; add_reset( pRoom, pReset, 0/* Last slot*/ ); newobj = create_object( pObjIndex, number_fuzzy( olevel ) ); newobj->cost = 0; obj_to_obj( newobj, to_obj ); sprintf( output, "%s (%d) has been loaded into " "%s (%d) and added to resets.\n\r", capitalize( newobj->short_descr ), newobj->pIndexData->vnum, to_obj->short_descr, to_obj->pIndexData->vnum ); send_to_char( output, ch ); } else /* * Load into mobile's inventory. */ if ( ( to_mob = get_char_room( ch, arg2 ) ) != NULL ) { int wear_loc; /* * Make sure the location on mobile is valid. */ if ( (wear_loc = flag_value( wear_loc_flags, argument )) == NO_FLAG ) { send_to_char( "REdit: Invalid wear_loc. '? wear-loc'\n\r", ch ); return FALSE; } /* * Disallow loading a sword(WEAR_WIELD) into WEAR_HEAD. */ if ( !IS_SET( pObjIndex->wear_flags, wear_bit(wear_loc) ) ) { sprintf( output, "%s (%d) has wear flags: %d '%s'\n\r" " You choose: %d '%s'\n\r", capitalize( pObjIndex->short_descr ), pObjIndex->vnum, pObjIndex->wear_flags, flag_string( wear_flags, pObjIndex->wear_flags ), wear_bit(wear_loc), flag_string( wear_flags, wear_bit(wear_loc))); send_to_char( output, ch ); return FALSE; } /* * Can't load into same position. */ if ( get_eq_char( to_mob, wear_loc ) && wear_loc != WEAR_NONE ) { send_to_char( "REdit: Object already equipped.\n\r", ch ); return FALSE; } pReset = new_reset_data(); pReset->arg1 = pObjIndex->vnum; pReset->arg2 = wear_loc; if ( pReset->arg2 == WEAR_NONE ) pReset->command = 'G'; else pReset->command = 'E'; pReset->arg3 = wear_loc; 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 ); sprintf( output, "%s (%d) has been loaded " "%s of %s (%d) and added to resets.\n\r", capitalize( pObjIndex->short_descr ), pObjIndex->vnum, flag_string( wear_loc_strings, pReset->arg3 ), to_mob->short_descr, to_mob->pIndexData->vnum ); send_to_char( output, ch ); } else /* Display Syntax */ { send_to_char( "REdit: That mobile isn't here.\n\r", ch ); return FALSE; } act( "$n has created $p!", ch, newobj, NULL, TO_ROOM ); return TRUE; } /* Room Interpreter, called by do_redit. */ void redit( CHAR_DATA *ch, char *argument ) { ROOM_INDEX_DATA *pRoom; AREA_DATA *pArea; char arg[MAX_STRING_LENGTH]; char command[MAX_INPUT_LENGTH]; int cmd; int value; EDIT_ROOM(ch, pRoom); pArea = pRoom->area; smash_tilde( argument ); strcpy( arg, argument ); argument = one_argument( argument, command ); if ( command[0] == '\0' ) { redit_show( ch, argument ); return; } if ( !str_cmp(command, "done") ) { edit_done( ch ); return; } if ( !IS_BUILDER( ch, pArea ) ) { send_to_char( "REdit: Insufficient security to modify room.\n\r", ch ); interpret( ch, arg ); edit_done(ch); return; } /* Search Table and Dispatch Command. */ for ( cmd = 0; *redit_table[cmd].name; cmd++ ) { if ( !str_prefix( command, redit_table[cmd].name ) ) { if ( (*redit_table[cmd].olc_fun) ( ch, argument ) ) SET_BIT( pArea->area_flags, AREA_CHANGED ); return; } } /* Take care of flags. */ if ( ( value = flag_value( room_flags, arg ) ) != NO_FLAG ) { TOGGLE_BIT(pRoom->room_flags, value); SET_BIT( pArea->area_flags, AREA_CHANGED ); send_to_char( "Room flag toggled.\n\r", ch ); return; } if ( ( value = flag_value( sector_flags, arg ) ) != NO_FLAG ) { pRoom->sector_type = value; SET_BIT( pArea->area_flags, AREA_CHANGED ); send_to_char( "Sector type set.\n\r", ch ); return; } /* Default to Standard Interpreter. */ interpret( ch, arg ); return; } /* Entry point for editing room_index_data. */ void do_redit (CHAR_DATA * ch, char *argument) { ROOM_INDEX_DATA *pRoom; char arg1[MIL]; argument = one_argument (argument, arg1); pRoom = ch->in_room; if (!str_cmp (arg1, "reset")) { if (!IS_BUILDER (ch, pRoom->area)) { send_to_char ("{yInsufficant security to modify room.\n\r", ch); return; } reset_room (pRoom); send_to_char ("Room reset.\n\r", ch); return; } else if (!str_cmp (arg1, "create")) { if (argument[0] == '\0' || atoi (argument) == 0) { send_to_char ("{ySyntax : redit room create [vnum]\n\r", ch); return; } if (redit_create (ch, argument)) { char_from_room (ch); char_to_room (ch, ch->desc->pEdit); SET_BIT (pRoom->area->area_flags, AREA_CHANGED); pRoom = ch->in_room; } } else if ( arg1[0] != '\0' ) { pRoom = get_room_index (atoi (arg1)); if ( pRoom == NULL ) { send_to_char( "{yRoom inexsistant.\n\r", ch ); return; } } if (!IS_BUILDER (ch, pRoom->area)) { send_to_char ("{yInsufficiant security to edit this area.\n\r",ch); return; } if ( pRoom == NULL ) bugf( "do_redit : NULL pRoom, ch %s!", ch->name ); if (ch->in_room != pRoom) { char_from_room(ch); char_to_room(ch, pRoom); } set_editor(ch->desc, ED_ROOM, pRoom); return; } bool oedit_create( CHAR_DATA *ch, char *argument ) { OBJ_INDEX_DATA *pObj; AREA_DATA *pArea; int value; int iHash; value = atoi( argument ); if ( argument[0] == '\0' || value == 0 ) { send_to_char( "Syntax: oedit create [vnum]\n\r", ch ); return FALSE; } pArea = get_vnum_area( value ); if ( !pArea ) { send_to_char( "OEdit: That vnum is not assigned an area.\n\r", ch ); return FALSE; } if ( !IS_BUILDER( ch, pArea ) ) { send_to_char( "OEdit: Vnum in an area you cannot build in.\n\r", ch ); return FALSE; } if ( get_obj_index( value ) ) { send_to_char( "OEdit: Object vnum already exists.\n\r", ch ); return FALSE; } pObj = new_obj_index(); pObj->vnum = value; pObj->area = pArea; pObj->extra_flags = 0; if ( value > top_vnum_obj ) top_vnum_obj = value; iHash = value % MAX_KEY_HASH; pObj->next = obj_index_hash[iHash]; obj_index_hash[iHash] = pObj; set_editor(ch->desc, ED_OBJECT, pObj); send_to_char( "Object Created.\n\r", ch ); return TRUE; } char * spell_name( int x ) { int cnt; if( x < 1 || x > MAX_SKILL ) return "None"; for( cnt = 0; spells[cnt].name; cnt++ ) if( spells[cnt].num == x ) return spells[cnt].name; return "None"; }; int get_spell_item( char *argument ) { int sn; if( argument[0] == '\0' ) return -1; if( is_number( argument ) ) { sn = atoi( argument ); if( sn > MAX_SKILL ) return -1; else return sn; } else { int cnt; for( cnt = 0; spells[cnt].name;cnt++ ) if( !str_cmp(argument,spells[cnt].name) ) return spells[cnt].num; } return -1; } void show_obj_values(CHAR_DATA *ch, OBJ_INDEX_DATA *obj) { char buf[MAX_STRING_LENGTH]; switch(obj->item_type) { default: sprintf(buf, "This object has no values.\n\r"); send_to_char(buf, ch); break; case ITEM_LIGHT: if (obj->value[2] == -1) sprintf(buf, "Hours of light(v2): Infinite(-1)\n\r"); else sprintf(buf, "Hours of light(v2): %d\n\r", obj->value[2]); send_to_char(buf, ch); break; case ITEM_WAND: case ITEM_STAFF: sprintf(buf, "(v3) %s\n\rLevel (v0): %d\n\rCharges (v2)/(v1): %d / %d\n\r", obj->value[3] != -1 ? capitalize(skill_table[obj->value[3]].name) : "!NO SPELL!", obj->value[0], obj->value[2], obj->value[1]); send_to_char(buf, ch); break; case ITEM_SCROLL: case ITEM_POTION: case ITEM_PILL: sprintf(buf, "(v1) %s\n\r(v2) %s\n\r(v3) %s\n\rLevel (v0): %d\n\r", obj->value[1] != -1 ? capitalize(skill_table[obj->value[1]].name) : "!NO SPELL!", obj->value[2] != -1 ? skill_table[obj->value[2]].name : "!NO SPELL!", obj->value[3] != -1 ? skill_table[obj->value[3]].name : "!NO SPELL!", obj->value[0]); send_to_char(buf, ch); break; case ITEM_ARMOR: sprintf(buf, "Spell(v4): %s\n\r", spell_name( obj->value[4] ) ); send_to_char( buf, ch ); break; case ITEM_WEAPON: sprintf(buf, "Type(v3): %s\n\r" "Min dam(v1): %d\n\r" "Max dam(v2): %d\n\r" "Spell(v4): %s\n\r" "FSpell(v0): %s\n\r", flag_string( weapon_flags, obj->value[3] ), obj->value[1], obj->value[2], spell_name(obj->value[4]), (obj->value[0] >=1 && obj->value[0] <= MAX_SKILL) ? skill_table[obj->value[0]].name : "None" ); send_to_char(buf, ch); break; case ITEM_CONTAINER: sprintf(buf, "Weight (v0): %d \n\rFlags (v1): %s\nrKey (v2): %s (%d)\n\r", 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]); send_to_char(buf, ch); break; case ITEM_FOUNTAIN: case ITEM_DRINK_CON: sprintf(buf, "Contains (v1)/(v0): %d/%d\n\rLiquid (v2): %s\n\rPoisoned? (v3): %s\n\r", obj->value[1], obj->value[0], flag_string( liquid_flags, obj->value[2] ), obj->value[3] != 0 ? "Yes" : "No"); send_to_char(buf, ch); break; case ITEM_FOOD: sprintf(buf, "Hours of food (v0): %d\n\rPoisoned? (v3): %s\n\r", obj->value[0], obj->value[3] != 0 ? "Yes" : "No"); send_to_char(buf, ch); break; case ITEM_GRENADE: sprintf(buf, "G.Timer (v0) %d\n\rG.Damage (v2): %d\n\r", obj->value[0], obj->value[2]); send_to_char(buf, ch); break; case ITEM_MONEY: sprintf(buf, "Amount of Gold (v0): %d\n\r", obj->value[0]); send_to_char(buf, ch); break; case ITEM_PORTAL: case ITEM_WGATE: sprintf( buf,"To Room (v0): %d\n\r" "From Room (v3): %d\n\r", obj->value[0],obj->value[3] ); stc( buf, ch ); break; } return; } bool set_obj_values(CHAR_DATA *ch, OBJ_INDEX_DATA *pObj, int value_num,char *argument) { switch(pObj->item_type) { default: break; case ITEM_LIGHT: switch (value_num) { default: do_help(ch, "b_ref item_light"); break; case 2: send_to_char("HOURS OF LIGHT SET.\n\r\n\r", ch); pObj->value[2] = atoi(argument); break; } break; case ITEM_WAND: case ITEM_STAFF: switch (value_num) { default: do_help(ch, "b_ref item_staff_wand"); break; case 0: send_to_char("SPELL LEVEL SET.\n\r\n\r", ch); pObj->value[0] = atoi(argument); break; case 1: send_to_char("TOTAL NUMBER OF CHARGES SET.\n\r\n\r", ch); pObj->value[1] = atoi(argument); break; case 2: send_to_char("CURRENT NUMBER OF CHARGES SET.\n\r\n\r", ch); pObj->value[2] = atoi(argument); break; case 3: send_to_char("SPELL TYPE SET.\n\r", ch); pObj->value[3] = skill_lookup(argument); break; } break; case ITEM_SCROLL: case ITEM_POTION: case ITEM_PILL: switch (value_num) { default: do_help(ch, "b_ref item_scroll_potion_pill"); break; case 0: send_to_char("SPELL LEVEL SET.\n\r\n\r", ch); pObj->value[0] = atoi(argument); break; case 1: send_to_char("SPELL TYPE 1 SET.\n\r\n\r", ch); pObj->value[1] = skill_lookup(argument); break; case 2: send_to_char("SPELL TYPE 2 SET.\n\r\n\r", ch); pObj->value[2] = skill_lookup(argument); break; case 3: send_to_char("SPELL TYPE 3 SET.\n\r\n\r", ch); pObj->value[3] = skill_lookup(argument); break; } break; case ITEM_WEAPON: switch (value_num) { default: do_help(ch, "b_ref item_weapon"); break; case 0: pObj->value[0] = skill_lookup(argument); send_to_char("WEAPON SPELL SET.\n\r\n\r", ch); break; case 1: send_to_char("MINIMUM DAMAGE SET.\n\r\n\r", ch); pObj->value[1] = atoi(argument); break; case 2: send_to_char("MAXIMUM DAMAGE SET.\n\r\n\r", ch); pObj->value[2] = atoi(argument); break; case 3: send_to_char("WEAPON TYPE SET.\n\r\n\r", ch); pObj->value[3] = flag_value( weapon_flags, argument ); break; case 4: send_to_char("SPELL SET.\n\r\n\r", ch ); pObj->value[4] = get_spell_item( argument ); break; } break; case ITEM_ARMOR: switch (value_num) { default: do_help(ch, "b_ref item_armor"); break; case 4: send_to_char("SPELL SET.\n\r\n\r", ch ); pObj->value[4] = get_spell_item( argument ); break; } break; case ITEM_CONTAINER: switch (value_num) { default: do_help(ch, "b_ref item_container"); break; case 0: send_to_char("WEIGHT CAPACITY SET.\n\r\n\r", ch); pObj->value[0] = atoi(argument); break; case 1: send_to_char("CONTAINER TYPE SET.\n\r\n\r", ch); pObj->value[1] = flag_value(container_flags,argument); break; case 2: if (atoi(argument) != 0) { if (!get_obj_index(atoi(argument))) { send_to_char("THERE IS NO SUCH KEY.\n\r\n\r", ch); break; } if (get_obj_index(atoi(argument))->item_type != ITEM_KEY) { send_to_char("THAT ITEM IS NOT A KEY.\n\r\n\r", ch); break; } } send_to_char("CONTAINER KEY SET.\n\r\n\r", ch); pObj->value[2] = atoi(argument); break; } break; case ITEM_FOUNTAIN: case ITEM_DRINK_CON: switch (value_num) { default: do_help(ch, "b_ref item_drink_con"); do_help(ch, "liquids"); break; case 0: send_to_char("MAXIMUM AMOUT OF LIQUID HOURS SET.\n\r\n\r", ch); pObj->value[0] = atoi(argument); break; case 1: send_to_char("CURRENT AMOUNT OF LIQUID HOURS SET.\n\r\n\r", ch); pObj->value[1] = atoi(argument); break; case 2: send_to_char("LIQUID TYPE SET.\n\r\n\r", ch); pObj->value[2] = flag_value( liquid_flags, argument ); break; case 3: send_to_char("POISON VALUE TOGGLED.\n\r\n\r", ch); pObj->value[3] = (pObj->value[3] == 0) ? 1 : 0; break; } break; case ITEM_FOOD: switch (value_num) { default: do_help(ch, "b_ref item_food"); break; case 0: send_to_char("HOURS OF FOOD SET.\n\r\n\r", ch); pObj->value[0] = atoi(argument); break; case 3: send_to_char("POISON VALUE TOGGLED.\n\r\n\r", ch); pObj->value[3] = (pObj->value[3] == 0) ? 1 : 0; break; } break; case ITEM_GRENADE: switch ( value_num ) { default: do_help( ch, "ITEM_GRENADE" ); break; case 0: send_to_char( "TIMER SET.\n\r\n\r", ch); pObj->value[0] = atoi( argument ); break; case 2: send_to_char( "DAMAGE SET.\n\r\n\r", ch ); pObj->value[2] = atoi( argument ); break; } break; case ITEM_MONEY: switch (value_num) { default: do_help(ch, "b_ref item_money"); break; case 0: send_to_char("GOLD AMOUNT SET.\n\r\n\r", ch); pObj->value[0] = atoi(argument); break; } break; case ITEM_PORTAL: case ITEM_WGATE: switch( value_num ) { default: do_help( ch, "b_ref ITEM_PORTAL" ); break; case 0: send_to_char( "TO ROOM SET.\n\r\n\r", ch ); pObj->value[0] = atoi( argument ); break; case 3: send_to_char( "FROM ROOM SET.\n\r\n\r", ch ); pObj->value[3] = atoi( argument ); break; } break; } show_obj_values(ch, pObj); return TRUE; } /* * Need to issue warning if flag isn't valid. */ bool oedit_addaffect( CHAR_DATA *ch, char *argument ) { 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 ); argument = one_argument( argument, mod ); if ( loc[0] == '\0' || mod[0] == '\0' || !is_number( mod ) ) { send_to_char( "Syntax: addaffect [location] [##mod] [minus]\n\r", ch ); return FALSE; } pAf = new_affect(); pAf->location = flag_value( apply_flags, loc ); pAf->modifier = atoi( mod ); pAf->type = -1; pAf->duration = -1; pAf->bitvector = 0; if( argument[0] != '\0' && !str_cmp( argument, "minus" ) ) pAf->modifier *= -1; pAf->next = pObj->affected; pObj->affected = pAf; send_to_char( "Affect added.\n\r", ch); return TRUE; } /* * My thanks to Hans Hvidsten Birkeland and Noam Krendel(Walker) * for really teaching me how to manipulate pointers. */ bool oedit_delaffect( CHAR_DATA *ch, char *argument ) { OBJ_INDEX_DATA *pObj; AFFECT_DATA *pAf; AFFECT_DATA *pAf_next; 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' ) { send_to_char( "Syntax: delaffect [#xaffect]\n\r", ch ); return FALSE; } value = atoi( affect ); if ( value < 0 ) { send_to_char( "Only non-negative affect-numbers allowed.\n\r", ch ); return FALSE; } if ( !( pAf = pObj->affected ) ) { send_to_char( "OEdit: Non-existant affect.\n\r", ch ); return FALSE; } if( value == 0 ) /* First case: Remove first affect */ { pAf = pObj->affected; pObj->affected = pAf->next; free_affect( pAf ); } else /* Affect to remove is not the first */ { while ( ( pAf_next = pAf->next ) && ( ++cnt < value ) ) pAf = pAf_next; if( pAf_next ) /* See if it's the next affect */ { pAf->next = pAf_next->next; free_affect( pAf_next ); } else /* Doesn't exist */ { send_to_char( "No such affect.\n\r", ch ); return FALSE; } } send_to_char( "Affect removed.\n\r", ch); return TRUE; } bool oedit_name( CHAR_DATA *ch, char *argument ) { OBJ_INDEX_DATA *pObj; EDIT_OBJ(ch, pObj); if ( argument[0] == '\0' ) { send_to_char( "Syntax: name [string]\n\r", ch ); return FALSE; } free_string( pObj->name ); pObj->name = str_dup( argument ); send_to_char( "Name set.\n\r", ch); return TRUE; } OEDIT( oedit_artifact ) { OBJ_INDEX_DATA *pObj; EDIT_OBJ(ch, pObj); if ( get_trust(ch) < 10 ) { send_to_char( "You do not have enough trust to make this object an artifact.\n\r", ch ); return FALSE; } SET_BIT(pObj->quest, QUEST_ARTIFACT); return TRUE; } /*bool oedit_action( CHAR_DATA *ch, char *argument ) { OBJ_INDEX_DATA *pObj; EDIT_OBJ(ch, pObj); if ( argument[0] == '\0' ) { send_to_char( "Syntax: action [string]\n\r", ch ); return FALSE; } free_string( pObj->action ); pObj->action = str_dup( argument ); pObj->action[0] = LOWER( pObj->action[0] ); send_to_char( "Action description set.\n\r", ch); return TRUE; }*/ bool oedit_short( CHAR_DATA *ch, char *argument ) { OBJ_INDEX_DATA *pObj; EDIT_OBJ(ch, pObj); if ( argument[0] == '\0' ) { send_to_char( "Syntax: short [string]\n\r", ch ); return FALSE; } free_string( pObj->short_descr ); pObj->short_descr = str_dup( argument ); send_to_char( "Short description set.\n\r", ch); return TRUE; } bool oedit_long( CHAR_DATA *ch, char *argument ) { OBJ_INDEX_DATA *pObj; EDIT_OBJ(ch, pObj); if ( argument[0] == '\0' ) { send_to_char( "Syntax: long [string]\n\r", ch ); send_to_char( " long none\n\r", ch); return FALSE; } if( !str_cmp( argument, "none" ) ) { free_string( pObj->description ); pObj->description = str_dup( "" ); send_to_char( "Long description is now none.\n\r",ch); return TRUE; } free_string( pObj->description ); pObj->description = str_dup( argument ); pObj->description[0] = UPPER( pObj->description[0] ); send_to_char( "Long description set.\n\r", ch); return TRUE; } bool set_value( CHAR_DATA *ch, OBJ_INDEX_DATA *pObj, char *argument, int value ) { if ( argument[0] == '\0' ) { set_obj_values( ch, pObj, -1, '\0' ); 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. ****************************************************************************/ bool oedit_values( CHAR_DATA *ch, char *argument, int value ) { OBJ_INDEX_DATA *pObj; EDIT_OBJ(ch, pObj); if ( set_value( ch, pObj, argument, value ) ) return TRUE; return FALSE; } bool oedit_value0( CHAR_DATA *ch, char *argument ) { if ( oedit_values( ch, argument, 0 ) ) return TRUE; return FALSE; } bool oedit_value1( CHAR_DATA *ch, char *argument ) { if ( oedit_values( ch, argument, 1 ) ) return TRUE; return FALSE; } bool oedit_value2( CHAR_DATA *ch, char *argument ) { if ( oedit_values( ch, argument, 2 ) ) return TRUE; return FALSE; } bool oedit_value3( CHAR_DATA *ch, char *argument ) { if ( oedit_values( ch, argument, 3 ) ) return TRUE; return FALSE; } bool oedit_value4( CHAR_DATA *ch, char *argument ) { if ( oedit_values( ch, argument, 4 ) ) return TRUE; return FALSE; } bool oedit_weight( CHAR_DATA *ch, char *argument ) { OBJ_INDEX_DATA *pObj; EDIT_OBJ(ch, pObj); if ( argument[0] == '\0' || !is_number( argument ) ) { send_to_char( "Syntax: weight [number]\n\r", ch ); return FALSE; } pObj->weight = atoi( argument ); send_to_char( "Weight set.\n\r", ch); return TRUE; } bool oedit_cost( CHAR_DATA *ch, char *argument ) { OBJ_INDEX_DATA *pObj; EDIT_OBJ(ch, pObj); if ( argument[0] == '\0' || !is_number( argument ) ) { send_to_char( "Syntax: cost [number]\n\r", ch ); return FALSE; } pObj->cost = atoi( argument ); send_to_char( "Cost set.\n\r", ch); return TRUE; } bool oedit_ed( CHAR_DATA *ch, char *argument ) { OBJ_INDEX_DATA *pObj; EXTRA_DESCR_DATA *ed; char command[MAX_INPUT_LENGTH]; char keyword[MAX_INPUT_LENGTH]; EDIT_OBJ(ch, pObj); argument = one_argument( argument, command ); one_argument( argument, keyword ); if ( command[0] == '\0' ) { send_to_char( "Syntax: ed add [keyword]\n\r", ch ); send_to_char( " ed delete [keyword]\n\r", ch ); send_to_char( " ed edit [keyword]\n\r", ch ); send_to_char( " ed format [keyword]\n\r", ch ); return FALSE; } if ( !str_cmp( command, "add" ) ) { if ( keyword[0] == '\0' ) { send_to_char( "Syntax: ed add [keyword]\n\r", ch ); return FALSE; } ed = new_extra_descr(); ed->keyword = str_dup( keyword ); ed->next = pObj->extra_descr; pObj->extra_descr = ed; string_append( ch, &ed->description ); return TRUE; } if ( !str_cmp( command, "edit" ) ) { if ( keyword[0] == '\0' ) { send_to_char( "Syntax: ed edit [keyword]\n\r", ch ); return FALSE; } for ( ed = pObj->extra_descr; ed; ed = ed->next ) { if ( is_name( keyword, ed->keyword ) ) break; } if ( !ed ) { send_to_char( "OEdit: Extra description keyword not found.\n\r", ch ); return FALSE; } string_append( ch, &ed->description ); return TRUE; } if ( !str_cmp( command, "delete" ) ) { EXTRA_DESCR_DATA *ped = NULL; if ( keyword[0] == '\0' ) { send_to_char( "Syntax: ed delete [keyword]\n\r", ch ); return FALSE; } for ( ed = pObj->extra_descr; ed; ed = ed->next ) { if ( is_name( keyword, ed->keyword ) ) break; ped = ed; } if ( !ed ) { send_to_char( "OEdit: Extra description keyword not found.\n\r", ch ); return FALSE; } if ( !ped ) pObj->extra_descr = ed->next; else ped->next = ed->next; free_extra_descr( ed ); send_to_char( "Extra description deleted.\n\r", ch ); return TRUE; } if ( !str_cmp( command, "format" ) ) { EXTRA_DESCR_DATA *ped = NULL; if ( keyword[0] == '\0' ) { send_to_char( "Syntax: ed format [keyword]\n\r", ch ); return FALSE; } for ( ed = pObj->extra_descr; ed; ed = ed->next ) { if ( is_name( keyword, ed->keyword ) ) break; ped = ed; } if ( !ed ) { send_to_char( "OEdit: Extra description keyword not found.\n\r", ch ); return FALSE; } /* OLC 1.1b */ if ( strlen(ed->description) >= (MAX_STRING_LENGTH - 4) ) { send_to_char( "String too long to be formatted.\n\r", ch ); return FALSE; } ed->description = format_string( ed->description ); send_to_char( "Extra description formatted.\n\r", ch ); return TRUE; } oedit_ed( ch, "" ); return FALSE; } OEDIT( oedit_show ) { char buf [ MAX_INPUT_LENGTH ]; OBJ_INDEX_DATA *pObj; EDIT_OBJ( ch, pObj ); sprintf( buf, "%d", pObj->vnum ); do_oshow( ch, buf ); return FALSE; } void oedit(CHAR_DATA *ch, char *argument) { AREA_DATA *pArea; OBJ_INDEX_DATA *pObj; char arg[MAX_STRING_LENGTH]; char command[MAX_INPUT_LENGTH]; int cmd; int value; smash_tilde( argument ); strcpy( arg, argument ); argument = one_argument( argument, command ); EDIT_OBJ( ch, pObj ); pArea = pObj->area; if (command[0] == '\0') { sprintf(arg, "%d", pObj->vnum); do_oshow(ch, arg); return; } if (!str_cmp(command, "done")) { edit_done(ch); return; } if ( !IS_BUILDER( ch, pArea ) ) { interpret( ch, arg ); edit_done(ch); return; } for ( cmd = 0; *oedit_table[cmd].name; cmd++ ) { if ( !str_prefix( command, oedit_table[cmd].name ) ) { if ( (*oedit_table[cmd].olc_fun) ( ch, argument ) ) SET_BIT( pArea->area_flags, AREA_CHANGED ); return; } } /* Take care of flags. */ if ( ( value = flag_value( type_flags, arg ) ) != NO_FLAG ) { pObj->item_type = value; SET_BIT( pArea->area_flags, AREA_CHANGED ); send_to_char( "Type set.\n\r", ch); /* * Clear the values. */ pObj->value[0] = 0; pObj->value[1] = 0; pObj->value[2] = 0; pObj->value[3] = 0; return; } /* * Satanic piece's can only be made with oset * or on the gypsy - Dreimas */ if ( str_prefix( arg, "satanic" ) && ( value = flag_value( extra_flags, arg ) ) != NO_FLAG ) { TOGGLE_BIT(pObj->extra_flags, value); SET_BIT( pArea->area_flags, AREA_CHANGED ); send_to_char( "Extra flag toggled.\n\r", ch); return; } if ( ( value = flag_value( wear_flags, arg ) ) != NO_FLAG ) { TOGGLE_BIT(pObj->wear_flags, value); SET_BIT( pArea->area_flags, AREA_CHANGED ); send_to_char( "Wear flag toggled.\n\r", ch); return; } interpret(ch, arg); return; } /* Entry point for editing obj_index_data. */ void do_oedit (CHAR_DATA * ch, char *argument) { OBJ_INDEX_DATA *pObj; AREA_DATA *pArea; char arg1[MAX_STRING_LENGTH]; int value; if (IS_NPC (ch)) return; argument = one_argument (argument, arg1); if (is_number (arg1)) { value = atoi (arg1); if (!(pObj = get_obj_index (value))) { send_to_char ("{yOEdit: That vnum does not exist.\n\r", ch); return; } if (!IS_BUILDER (ch, pObj->area)) { send_to_char ("{yInsufficant security to modify objects.\n\r",ch); return; } set_editor(ch->desc, ED_OBJECT, pObj); return; } else { if (!str_cmp (arg1, "create")) { value = atoi (argument); if (argument[0] == '\0' || value == 0) { send_to_char ("{ySyntax: edit object create [vnum]\n\r", ch); return; } pArea = get_vnum_area (value); if (!pArea) { send_to_char ("{yOEdit: That vnum is not assigned an area.\n\r", ch); return; } if (!IS_BUILDER (ch, pArea)) { send_to_char ("{yInsufficant security to modify objects.\n\r", ch); return; } if (oedit_create (ch, argument)) { SET_BIT (pArea->area_flags, AREA_CHANGED); } return; } } send_to_char ("{yOEdit: There is no default object to edit.\n\r", ch); return; } bool medit_create( CHAR_DATA *ch, char *argument ) { int value; AREA_DATA *pArea; MOB_INDEX_DATA *pMob; int iHash; value = atoi(argument); if (argument[0] == '\0' || value == 0) { send_to_char("{ySyntax: medit create [vnum]\n\r", ch); return FALSE; } pArea = get_vnum_area(value); if (pArea == NULL) { send_to_char("{yMEdit: That vnum is not assigned an area.\n\r", ch); return FALSE; } if (!IS_BUILDER(ch, pArea)) { send_to_char("{yMEdit: Vnum in an area you cannot build in.\n\r", ch); return FALSE; } if (get_mob_index(value) != NULL) { send_to_char("{yMEdit: Mobile vnum already exists.\n\r", ch); 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; pMob->next = mob_index_hash[iHash]; mob_index_hash[iHash] = pMob; set_editor( ch->desc, ED_MOBILE, pMob ); send_to_char("Mobile Created.\n\r", ch); return TRUE; } MEDIT(medit_show) { MOB_INDEX_DATA *pMob; char buf [ MAX_STRING_LENGTH ]; EDIT_MOB( ch, pMob ); sprintf(buf, "%d", pMob->vnum); do_mshow(ch, buf); return FALSE; } MEDIT(medit_shop) { char arg1[MAX_INPUT_LENGTH]; char arg2[MAX_INPUT_LENGTH]; MOB_INDEX_DATA *pMob; char buf [MAX_STRING_LENGTH]; int value; argument = one_argument(argument, arg1); strcpy(arg2, argument); EDIT_MOB(ch,pMob); if (arg1[0] == '\0') { send_to_char("{YSyntax: shop hours [##opening] [##closing]\n\r", ch); send_to_char("{Y shop profit [##buying%] [##selling%]\n\r", ch); send_to_char("{Y shop type [##1-5] [item type]\n\r", ch); send_to_char("{Y shop delete\n\r", ch); return FALSE; } if (!str_cmp(arg1, "hours")) { argument = one_argument(argument, arg1); strcpy(arg2, argument); if (arg1[0] == '\0' || !is_number(arg1) || arg2[0] == '\0' || !is_number(arg2)) { send_to_char("{YSyntax: shop hours [#opening] [#closing]\n\r", ch); return FALSE; } if (pMob->pShop == NULL) { pMob->pShop = new_shop(); pMob->pShop->keeper = pMob->vnum; shop_last->next = pMob->pShop; } pMob->pShop->open_hour = atoi(arg1); pMob->pShop->close_hour = atoi(arg2); send_to_char("Shop hours set.\n\r", ch); return TRUE; } if (!str_cmp(arg1, "profit")) { argument = one_argument(argument, arg1); strcpy(arg2, argument); if (arg1[0] == '\0' || !is_number(arg1) || arg2[0] == '\0' || !is_number(arg2)) { send_to_char("{YSyntax: shop profit [#buying%] [#selling%]\n\r", ch); return FALSE; } if (pMob->pShop == NULL) { pMob->pShop = new_shop(); pMob->pShop->keeper = pMob->vnum; shop_last->next = pMob->pShop; } pMob->pShop->profit_buy = atoi(arg1); pMob->pShop->profit_sell = atoi(arg2); send_to_char("Shop profit set.\n\r", ch); return TRUE; } if (!str_cmp(arg1, "type")) { argument = one_argument(argument, arg1); strcpy(arg2, argument); if (arg1[0] == '\0' || !is_number(arg1) || arg2[0] == '\0') { send_to_char("{YSyntax: shop type [#] [item type]\n\r", ch); return FALSE; } if (atoi(arg1) > MAX_TRADE) { sprintf(buf, "%d", MAX_TRADE); send_to_char("{YREdit: Shop keepers may only sell ", ch); send_to_char(buf, ch); send_to_char(" items max.\n\r", ch); return FALSE; } if ( ( value = flag_value( type_flags, argument ) ) == NO_FLAG ) { send_to_char("{YREdit: That type of item is not known.\n\r", ch); return FALSE; } if (pMob->pShop == NULL) { pMob->pShop = new_shop(); pMob->pShop->keeper = pMob->vnum; shop_last->next = pMob->pShop; } pMob->pShop->buy_type[atoi(arg1)] = value; send_to_char("Shop type set.\n\r", ch); return TRUE; } if (!str_cmp(arg1, "delete")) { if (pMob->pShop == NULL) { send_to_char("{YREdit: Cannot delete a shop that is non-existant.\n\r", ch); return FALSE; } free_shop(pMob->pShop); pMob->pShop = NULL; send_to_char("Shop deleted.\n\r", ch); return TRUE; } send_to_char("{YSyntax: shop hours [##opening] [##closing]\n\r", ch); send_to_char("{Y shop profit [##buying%] [##selling%]\n\r", ch); send_to_char("{Y shop type [##] [item type]\n\r", ch); send_to_char("{Y shop delete\n\r", ch); return FALSE; } MEDIT( medit_name ) { MOB_INDEX_DATA *pMob; EDIT_MOB(ch,pMob); if (argument[0] == '\0') { send_to_char("{YSyntax: name [string]\n\r", ch); return FALSE; } free_string(pMob->player_name); pMob->player_name = str_dup(argument); send_to_char("Name set.\n\r", ch); return TRUE; } MEDIT( medit_short ) { MOB_INDEX_DATA *pMob; EDIT_MOB(ch,pMob); if (argument[0] == '\0') { send_to_char("{YSyntax: short [string]\n\r", ch); return FALSE; } free_string(pMob->short_descr); pMob->short_descr = str_dup(argument); send_to_char("Short description set.\n\r", ch); return TRUE; } MEDIT( medit_long ) { MOB_INDEX_DATA *pMob; EDIT_MOB(ch,pMob); if (argument[0] == '\0') { send_to_char("{YSyntax: long [string]\n\r", ch); return FALSE; } free_string(pMob->long_descr); strcat( argument, "\n\r" ); pMob->long_descr = str_dup(argument); pMob->long_descr[0] = UPPER( pMob->long_descr[0] ); send_to_char("Long description set.\n\r", ch); return TRUE; } MEDIT( medit_desc ) { MOB_INDEX_DATA *pMob; EDIT_MOB(ch,pMob); if (argument[0] == '\0') { string_append(ch, &pMob->description); return TRUE; } send_to_char("Syntax: desc - line edit\n\r", ch); return FALSE; } MEDIT(medit_level) { char arg2[MAX_STRING_LENGTH]; MOB_INDEX_DATA *pMob; argument = one_argument(argument, arg2); EDIT_MOB(ch,pMob); if (arg2[0] == '\0' || !is_number(arg2)) { send_to_char("Syntax: level [number]\n\r", ch); return FALSE; } pMob->level = atoi(arg2); send_to_char("Level set.\n\r", ch); return TRUE; } MEDIT( medit_align ) { char arg2[MAX_STRING_LENGTH]; MOB_INDEX_DATA *pMob; argument = one_argument(argument, arg2); EDIT_MOB(ch,pMob); if (arg2[0] == '\0' || !is_number(arg2)) { send_to_char("Syntax: alignment [number]\n\r", ch); return FALSE; } pMob->alignment = atoi(arg2); send_to_char("Alignment set.\n\r", ch); return TRUE; } MEDIT( medit_spec ) { char arg[MAX_STRING_LENGTH]; MOB_INDEX_DATA *pMob; argument = one_argument(argument, arg); EDIT_MOB(ch,pMob); if (!str_cmp(arg, "none")) { pMob->spec_fun = NULL; send_to_char("Spec removed.\n\r", ch); return TRUE; } if (spec_lookup(arg) != NULL) { pMob->spec_fun = spec_lookup(arg); send_to_char("Spec set.\n\r", ch); return TRUE; } send_to_char("{yInvalid Special. Use ? special to see a list of them.\n\r", ch ); return FALSE; } void medit(CHAR_DATA *ch, char *argument) { AREA_DATA *pArea; MOB_INDEX_DATA *pMob; char arg[MAX_STRING_LENGTH]; char arg1[MAX_STRING_LENGTH]; char arg2[MAX_STRING_LENGTH]; char buf[MAX_STRING_LENGTH]; int value ,cmd; strcpy(arg, argument); smash_tilde(argument); argument = one_argument(argument, arg1); strcpy(arg2, argument); EDIT_MOB( ch,pMob ); pArea = pMob->area; if (arg1[0] == '\0') { sprintf(buf, "%d", pMob->vnum); do_mshow(ch, buf); return; } if (!str_cmp(arg1, "done")) { edit_done(ch); return; } /* Search Table and Dispatch Command. */ for ( cmd = 0; *medit_table[cmd].name; cmd++ ) { if ( !str_prefix( arg1, medit_table[cmd].name ) ) { if ( (*medit_table[cmd].olc_fun) ( ch, argument ) ) SET_BIT( pArea->area_flags, AREA_CHANGED ); return; } } /* Take care of flags. */ if ( ( value = flag_value( sex_flags, arg ) ) != NO_FLAG ) { pMob->sex = value; SET_BIT( pArea->area_flags, AREA_CHANGED ); send_to_char( "Sex set.\n\r", ch); return; } if ( ( value = flag_value( act_flags, arg ) ) != NO_FLAG ) { TOGGLE_BIT(pMob->act, value); SET_BIT( pArea->area_flags, AREA_CHANGED ); send_to_char( "Act flag toggled.\n\r", ch); return; } if ( ( value = flag_value( affect_flags, arg ) ) != NO_FLAG ) { TOGGLE_BIT(pMob->affected_by, value); SET_BIT( pArea->area_flags, AREA_CHANGED ); send_to_char( "Affect flag toggled.\n\r", ch); return; } interpret(ch, arg); return; } /* Entry point for editing mob_index_data. */ void do_medit (CHAR_DATA * ch, char *argument) { MOB_INDEX_DATA *pMob; AREA_DATA *pArea; int value; char arg1[MAX_STRING_LENGTH]; argument = one_argument (argument, arg1); if (is_number (arg1)) { value = atoi (arg1); if (!(pMob = get_mob_index (value))) { send_to_char ("{YMEdit: That vnum does not exist.\n\r", ch); return; } if (!IS_BUILDER (ch, pMob->area)) { send_to_char ("{YInsufficant security to edit mobs.\n\r", ch); return; } set_editor(ch->desc, ED_MOBILE, pMob); return; } else { if (!str_cmp (arg1, "create")) { value = atoi (argument); if (arg1[0] == '\0' || value == 0) { send_to_char ("{ySyntax: edit mobile create [vnum]\n\r",ch); return; } pArea = get_vnum_area (value); if (!pArea) { send_to_char ("{yMEdit: That vnum is not assigned an area.\n\r", ch); return; } if (!IS_BUILDER (ch, pArea)) { send_to_char ("{YInsuffiant security to edit mobs.\n\r",ch); return; } if ( medit_create( ch, argument ) ) SET_BIT (pArea->area_flags, AREA_CHANGED); return; } } send_to_char ("{YMEdit: There is no default mobile to edit.\n\r",ch); return; } void do_ashow(CHAR_DATA *ch, char *argument) { AREA_DATA *pArea; char arg1 [MAX_INPUT_LENGTH]; char buf [MAX_STRING_LENGTH]; int pdeaths = 0, pkills = 0, mdeaths = 0, mkills = 0; if( !str_cmp( "summary", argument ) ) { for ( pArea = area_first; pArea; pArea = pArea->next ) { pdeaths += pArea->pdeaths; mdeaths += pArea->mdeaths; pkills += pArea->pkills; mkills += pArea->mkills; } ch_printf( ch, "{WTotal pdeaths: {x%d\n\r", pdeaths ); ch_printf( ch, "{WTotal pkills: {x%d\n\r", pkills ); ch_printf( ch, "{WTotal mdeaths: {x%d\n\r", mdeaths ); ch_printf( ch, "{WTotal mkills: {x%d\n\r", mkills ); return; } smash_tilde(argument); strcpy(arg1, argument); if (is_number(arg1)) pArea = get_area_data(atoi(arg1)); else pArea = ch->in_room->area; if (!pArea) pArea = ch->in_room->area; sprintf(buf, "{cName: {n%s\n\r", pArea->name); send_to_char(buf, ch); sprintf(buf, "{cFile: {n%s\n\r", pArea->filename); send_to_char(buf, ch); sprintf(buf, "{cAge: {n%d\n\r{cPlayers: {n%d\n\r", pArea->age, pArea->nplayer); send_to_char(buf, ch); sprintf(buf, "{cMod: {n%d\n\r", pArea->mod ); stc( buf, ch ); sprintf(buf, "{cSecurity: {n%d\n\r{cBuilders {n%s\n\r", pArea->security, pArea->builders); send_to_char(buf, ch); ch_printf( ch, "{cMdeaths: {n%d {cMkills: {n%d {cPdeaths: {n%d {cPkills: {n%d\n\r", pArea->mdeaths, pArea->mkills, pArea->pdeaths, pArea->pkills ); sprintf(buf, "{cVnums: {n%d{c-{n%d\n\r", pArea->lvnum, pArea->uvnum); send_to_char(buf, ch); sprintf(buf, "{cFlags: {n%s\n\r", flag_string( area_flags, pArea->area_flags )); send_to_char(buf, ch); return; } void rtext_show( CHAR_DATA *ch, ROOMTEXT_DATA * rt ) { ch_printf( ch, "{cType: {C%s ", flag_string( rt_flags, rt->type ) ); ch_printf( ch, "{cPower: {n%d ", rt->power ); ch_printf( ch, "{cMob: {n%d\n\r", rt->mob ); ch_printf( ch, "{cInput: {n%s\n\r", rt->input ); ch_printf( ch, "{cName: {n%s\n\r", rt->name ); ch_printf( ch, "{cOutput: {n%s\n\r", rt->output ); ch_printf( ch, "{cChOutput: {n%s\n\r", rt->choutput ); }; void do_rshow(CHAR_DATA *ch, char *argument) { OBJ_DATA *obj; CHAR_DATA *rch; ROOM_INDEX_DATA *location; char buf [ MAX_STRING_LENGTH ]; char arg [ MAX_INPUT_LENGTH ]; int door; rch = get_char(ch); one_argument(argument, arg); location = (arg[0] == '\0') ? ch->in_room : find_location(ch, arg); if (!location) { send_to_char("No such location.\n\r", ch); return; } if (ch->in_room != location && room_is_private(location)) { send_to_char("That room is private right now.\n\r", ch); return; } ch_printf(ch, "{cName: {n%s\n\r{cArea: {n%3d %s {cFile {n%s\n\r", location->name, location->area ? location->area->vnum : 0, location->area ? location->area->name : "None????", location->area ? location->area->filename : "None????" ); ch_printf(ch, "{cVnum: {n%d\n\r{cSector: {n(%d) %s\n\r{cLight: {n%d\n\r", location->vnum, location->sector_type, flag_string( sector_flags, location->sector_type), location->light); ch_printf(ch, "{cRoom flags: {n%s\n\r{cDescription:\n\r{n%s", flag_string(room_flags, location->room_flags), location->description); if (location->extra_descr) { EXTRA_DESCR_DATA *ed; stc( "{cExtra description keywords: {n'", ch); for (ed = location->extra_descr; ed; ed = ed->next) { stc( ed->keyword, ch ); if (ed->next) stc( " ", ch ); } stc("'\n\r", ch); } if (location->roomtext ) { ROOMTEXT_DATA * rt; stc( "{cRoom Text triggers:{n\n\r", ch ); for( door=1,rt = location->roomtext; rt; rt = rt->next,door++ ) { ch_printf( ch, "{C%d{n: %s", door, rt->input); if( rt->next ) stc(" ", ch ); } stc( "\n\r", ch ); } stc("{cCharacters:{n", ch); for (rch = location->people; rch; rch = rch->next_in_room) { stc(" ",ch); one_argument(rch->name, buf); stc(buf,ch); } stc("\n\r{cObjects:{n ",ch); for (obj = location->contents; obj; obj = obj->next_content) { stc(" ",ch); one_argument(STR(obj, name), buf); stc(buf,ch); } stc("\n\r",ch); send_to_char( "{cTracking: {n",ch); for ( door = 0; door < 4; door ++ ) ch_printf( ch, "%d)%s ", door, location->track[door][0] == '\0' ? " " : location->track[door] ); send_to_char("\n\r", ch ); for (door = 0; door < MAX_DIR; door++) { EXIT_DATA *pexit; int cnt = 0; if ((pexit = location->exit[door])) { if( door == 0 ) stc( "{c------------------- {nEXITS {c-------------------\n\r", ch ); ch_printf(ch, "{W%2d) {n%2s to %-5d {cKey: {n%d {cKeywords: '{n%s{c' Flags: (%d) '%s'\n\r" " {cExdesc: {n%s\n\r", ++cnt, dir_name[door], pexit->to_room ? pexit->to_room->vnum : 0, pexit->key, pexit->keyword, pexit->exit_info, flag_string( exit_flags, pexit->exit_info), pexit->description[0] != '\0' ? pexit->description : "(none)\n\r" ); } } if ( location->affected ) { ROOM_AFFECT_DATA * raf; for ( raf = location->affected; raf; raf = raf->next ) { ch_printf( ch,"{cRoom_Affect: {w'%s', {ccaster {w%s{c, duration {w%d\n\r", room_aff_table[raf->type].name, raf->caster ? raf->caster->name : "none", raf->duration ); } } stc( "\n\r", ch ); return; } void do_mshow(CHAR_DATA *ch, char *argument) { char buf[MAX_STRING_LENGTH]; char arg[MAX_INPUT_LENGTH]; MOB_INDEX_DATA *victim; one_argument(argument, arg); if (arg[0] == '\0') { send_to_char("MShow whom?\n\r", ch); return; } if ((victim = get_mob_index(atoi(arg))) == NULL) { send_to_char("Invalid mob index VNUM.\n\r", ch); return; } sprintf(buf, "Name: '%s'\n\rArea %d: '%s'\n\r", victim->player_name, victim->area == NULL ? -1 : victim->area->vnum, victim->area == NULL ? "No Area" : victim->area->name); send_to_char(buf, ch); sprintf(buf, "Act: %s\n\r", flag_string( act_flags, victim->act)); send_to_char(buf, ch); sprintf(buf, "Vnum: %d\n\rSex: %s\n\r", victim->vnum, victim->sex == SEX_MALE ? "male" : victim->sex == SEX_FEMALE ? "female" : "neutral"); send_to_char(buf, ch); sprintf(buf, "Level: %d\n\rAlign: %d\n\r", victim->level, victim->alignment); send_to_char(buf, ch); sprintf(buf, "Affected by: %s\n\r", flag_string(affect_flags, victim->affected_by )); send_to_char(buf, ch); sprintf(buf, "Short description: %s\n\rLong description:\n\r%s", victim->short_descr, victim->long_descr); send_to_char(buf, ch); sprintf(buf, "Description:\n\r%s", victim->description); if (victim->spec_fun != NULL) { sprintf(buf, "Spec fun: %s\n\r", spec_name(victim->spec_fun)); send_to_char(buf, ch); } if (victim->pShop != NULL) { SHOP_DATA *pShop; int iTrade; pShop = victim->pShop; sprintf(buf, "Shop data (for %d):\n\r Will buy at %d%%, and sell at %d%%.\n\r", pShop->keeper, pShop->profit_buy, pShop->profit_sell); send_to_char(buf, ch); sprintf(buf, " Opens at %d, closes at %d.\n\r", pShop->open_hour, pShop->close_hour); send_to_char(buf, ch); for (iTrade = 0; iTrade < MAX_TRADE; iTrade++) { if (pShop->buy_type[iTrade] != ITEM_NONE) { sprintf(buf, " Buys %ss (#%d)\n\r", flag_string( type_flags, pShop->buy_type[iTrade]), iTrade); send_to_char(buf, ch); } } } return; } void do_oshow(CHAR_DATA *ch, char *argument) { char buf[MAX_STRING_LENGTH]; char arg[MAX_INPUT_LENGTH]; AFFECT_DATA *paf; OBJ_INDEX_DATA *obj; int cnt; one_argument(argument, arg); if (arg[0] == '\0') { send_to_char("OShow what?\n\r", ch); return; } if ((obj = get_obj_index(atoi(arg))) == NULL) { send_to_char("Invalid VNUM reference.\n\r", ch); return; } sprintf(buf, "Name: '%s'\n\rArea %d: '%s'\n\r", obj->name, obj->area == NULL ? -1 : obj->area->vnum, obj->area == NULL ? "No Area" : obj->area->name); send_to_char(buf, ch); sprintf(buf, "Vnum: %d\n\rType: %s\n\r", obj->vnum, flag_string(type_flags, obj->item_type)); send_to_char(buf, ch); sprintf(buf, "Short description: %s\n\rLong description: %s\n\r", obj->short_descr, obj->description); send_to_char(buf, ch); sprintf(buf, "Wear flags: %s\n\r", flag_string( wear_flags, obj->wear_flags )); send_to_char(buf,ch); sprintf(buf, "Extra flags: %s\n\r", flag_string( extra_flags, obj->extra_flags )); send_to_char(buf, ch); sprintf(buf, "Quest flags: %s\n\r", flag_string(quest_flags, obj->quest ) ); send_to_char( buf, ch ); sprintf(buf, "Weight: %d\n\rCost: %d\n\r", obj->weight, obj->cost); send_to_char(buf, ch); show_obj_values(ch, obj); if (obj->extra_descr != NULL) { EXTRA_DESCR_DATA *ed; send_to_char("Extra description keywords: ", ch); for (ed = obj->extra_descr; ed != NULL; ed = ed->next) { send_to_char("'", ch); send_to_char(ed->keyword, ch); send_to_char("'", ch); } send_to_char("\n\r", ch); } for (cnt=0,paf = obj->affected; paf != NULL; paf = paf->next, cnt++) { sprintf(buf, "%d) Affects %s by %d.\n\r", cnt, affect_loc_name(paf->location), paf->modifier); send_to_char(buf, ch); } return; } void display_resets(CHAR_DATA *ch, ROOM_INDEX_DATA *pRoomIndex) { char buf[MAX_STRING_LENGTH]; char final[MAX_STRING_LENGTH]; int iReset = 0; RESET_DATA *pReset; MOB_INDEX_DATA *pMob = NULL; OBJ_INDEX_DATA *pObj; MOB_INDEX_DATA *pMobIndex; OBJ_INDEX_DATA *pObjIndex; OBJ_INDEX_DATA *pObjToIndex; final[0] = '\0'; stc( " {wNo. Loads Description Location Vnum Ar Rm Description" "\n\r" "{B==== ======== ============= =================== ======== ===== ===========" "\n\r", ch); for (pReset = pRoomIndex->reset_first; pReset; pReset = pReset->next) { final[0] = '\0'; sprintf (final, "{B[{w%2d{B] ", ++iReset); switch ( pReset->command ) { default: sprintf( buf, "Bad reset command: %c.", pReset->command ); strcat( final, buf ); break; case 'M': if ( !( pMobIndex = get_mob_index( pReset->arg1 ) ) ) { sprintf( buf, "{bLoad Mobile - Bad Mob {w%d\n\r",pReset->arg1 ); strcat( final, buf ); continue; } pMob = pMobIndex; sprintf( buf, "{bM{B[{w%5d{b] {w%-13.13s {Bin room {bR{B[{w%5d{B] [{w%3d{B] {w%-15.15s\n\r", pReset->arg1, pMob->short_descr, pReset->arg3, pReset->arg2, pRoomIndex->name ); strcat( final, buf ); /* * Check for pet shop. * ------------------- */ { ROOM_INDEX_DATA *pRoomIndexPrev; pRoomIndexPrev = get_room_index( pRoomIndex->vnum - 1 ); if ( pRoomIndexPrev && IS_SET( pRoomIndexPrev->room_flags, ROOM_PET_SHOP ) ) final[5] = 'P'; } break; case 'O': if ( !( pObjIndex = get_obj_index( pReset->arg1 ) ) ) { sprintf( buf, "{bLoad Object - Bad Object {w%d\n\r", pReset->arg1 ); strcat( final, buf ); continue; } pObj = pObjIndex; sprintf( buf, "{bO{B[{w%5d{B] {w%-13.13s {Bin room" " {bR{B[{w%5d{B] {w%-15.15s\n\r", pReset->arg1, pObj->short_descr, pReset->arg3, pRoomIndex->name ); strcat( final, buf ); break; case 'P': if ( !( pObjIndex = get_obj_index( pReset->arg1 ) ) ) { sprintf( buf, "{bPut Object - Bad Object {w%d\n\r", pReset->arg1 ); strcat( final, buf ); continue; } pObj = pObjIndex; if ( !( pObjToIndex = get_obj_index( pReset->arg3 ) ) ) { sprintf( buf, "{bPut Object - Bad To Object {w%d\n\r", pReset->arg3 ); strcat( final, buf ); continue; } sprintf( buf, "{bO{B[{w%5d{B] {w%-13.13s {Binside {bO{B[{w%5d{B] {w%-15.15s\n\r", pReset->arg1, pObj->short_descr, pReset->arg3, pObjToIndex->short_descr ); strcat( final, buf ); break; case 'G': case 'E': if ( !( pObjIndex = get_obj_index( pReset->arg1 ) ) ) { sprintf( buf, "{bGive/Equip Object - Bad Object {w%d\n\r", pReset->arg1 ); strcat( final, buf ); continue; } pObj = pObjIndex; if ( !pMob ) { sprintf( buf, "{bGive/Equip Object - No Previous Mobile\n\r" ); strcat( final, buf ); break; } if ( pMob->pShop ) { sprintf( buf, "{bO{B[{w%5d{B] {w%-13.13s {Bin the inventory of {bS{B[{w%5d{B] %-15.15s\n\r", pReset->arg1, pObj->short_descr, pMob->vnum, pMob->short_descr ); } else sprintf( buf, "{bO{B[{w%5d{B] {w%-13.13s {B%-19.19s {bM{B[{w%5d{B] {w%-15.15s\n\r", pReset->arg1, pObj->short_descr, (pReset->command == 'G') ? flag_string( wear_loc_strings, WEAR_NONE ) : flag_string( wear_loc_strings, pReset->arg3 ), pMob->vnum, pMob->short_descr ); strcat( final, buf ); break; /* * Doors are set in rs_flags don't need to be displayed. * If you want to display them then uncomment the new_reset * line in the case 'D' in load_resets in db.c and here. */ case 'D': pRoomIndex = get_room_index( pReset->arg1 ); sprintf( buf, "{bR{B[{b%5d{B] {w%s {Bdoor of &w%-19.19s {Breset to {b%s\n\r", pReset->arg1, capitalize( dir_name[ pReset->arg2 ] ), pRoomIndex->name, flag_string( exit_flags, pReset->arg3 ) ); strcat( final, buf ); break; case 'R': if ( !( pRoomIndex = get_room_index( pReset->arg1 ) ) ) { sprintf( buf, "{bRandomize Exits - Bad Room {w%d\n\r", pReset->arg1 ); strcat( final, buf ); continue; } sprintf( buf, "{bR{B[{w%5d{B] {bExits are randomized in {w%s\n\r", pReset->arg1, pRoomIndex->name ); strcat( final, buf ); break; } send_to_char( final, ch ); } return; } void add_reset(ROOM_INDEX_DATA *room, RESET_DATA *pReset, int index) { RESET_DATA *reset; int iReset = 0; if ( !room->reset_first ) { room->reset_first = pReset; room->reset_last = pReset; pReset->next = NULL; return; } index--; if ( index == 0 ) /* First slot (1) selected. */ { pReset->next = room->reset_first; room->reset_first = pReset; return; } /* * If negative slot( <= 0 selected) then this will find the last. */ for ( reset = room->reset_first; reset->next; reset = reset->next ) { if ( ++iReset == index ) break; } pReset->next = reset->next; reset->next = pReset; if ( !pReset->next ) room->reset_last = pReset; return; } int get_max_dir(CHAR_DATA *ch, int arg) { char buf[MAX_INPUT_LENGTH]; if (arg < 0 || arg >= MAX_DIR) { sprintf(buf, "Doors range from 0 to %d.\n\r", MAX_DIR-1); send_to_char(buf, ch); return -1; } else return arg; } void do_resets(CHAR_DATA *ch, char *argument) { char arg1[MAX_INPUT_LENGTH]; char arg2[MAX_INPUT_LENGTH]; char arg3[MAX_INPUT_LENGTH]; char arg4[MAX_INPUT_LENGTH]; char arg5[MAX_INPUT_LENGTH]; RESET_DATA *pReset = NULL; argument = one_argument(argument, arg1); argument = one_argument(argument, arg2); argument = one_argument(argument, arg3); argument = one_argument(argument, arg4); argument = one_argument(argument, arg5); if (arg1[0] == '\0') { if (ch->in_room->reset_first != NULL) { display_resets(ch,ch->in_room); } else send_to_char("No resets in this area.\n\r", ch); } if (!IS_BUILDER(ch, ch->in_room->area)) { send_to_char("Resets: Invalid security for editing this area.\n\r", ch); return; } /* * Take index number and search for commands. * ------------------------------------------ */ if ( is_number( arg1 ) ) { ROOM_INDEX_DATA *pRoom = ch->in_room; /* * Delete a reset. * --------------- */ if ( !str_cmp( arg2, "delete" ) ) { int insert_loc = atoi( arg1 ); if ( !ch->in_room->reset_first ) { send_to_char( "No resets in this room.\n\r", ch ); return; } if ( insert_loc-1 <= 0 ) { pReset = pRoom->reset_first; pRoom->reset_first = pRoom->reset_first->next; if ( !pRoom->reset_first ) pRoom->reset_last = NULL; } else { int iReset = 0; RESET_DATA *prev = NULL; for ( pReset = pRoom->reset_first; pReset; pReset = pReset->next ) { if ( ++iReset == insert_loc ) break; prev = pReset; } if ( !pReset ) { send_to_char( "Reset not found.\n\r", ch ); return; } if ( prev ) prev->next = prev->next->next; else pRoom->reset_first = pRoom->reset_first->next; for ( pRoom->reset_last = pRoom->reset_first; pRoom->reset_last->next; pRoom->reset_last = pRoom->reset_last->next ); } free_reset_data( pReset ); send_to_char( "Reset deleted.\n\r", ch ); } else if( !str_cmp( arg2, "maze") && is_number( arg3 ) ) { int doors = 0; int door = 0; for( door = 0; door < MAX_DIR; door++ ) { if( ch->in_room->exit[door] ) doors++; } door = atoi( arg3 ); if( door == 4 ) { if( doors != 4 ) { send_to_char("You must have 4 exits in the room.\n\r",ch); return; } } else if( door == 6 ) { if( doors != 6 ) { send_to_char( "You must have 6 exits in the room.\n\r",ch); return; } } else { send_to_char("You must use either 4 or 6 for thedoors.\n\r",ch); return; } pReset = new_reset_data(); pReset->command = 'R'; pReset->arg1 = ch->in_room->vnum; pReset->arg2 = doors; pReset->arg3 = 0; add_reset( ch->in_room, pReset, atoi( arg1 ) ); ch_printf(ch,"%d doors will now be shoufled in this room.\n\r",doors); } else { send_to_char( "Syntax: RESET\n\r",ch ); send_to_char( " RESET <number> MAZE <doors> \n\r", ch ); send_to_char( " RESET <number> DELETE\n\r", ch ); } } return; } void save_helps( FILE *fp, HELP_AREA *ha ) { HELP_DATA *help = ha->first; fprintf( fp, "#HELPS\n" ); for ( ; help; help = help->next_area ) { fprintf( fp, "%d %s~\n", help->level, help->keyword ); fprintf( fp, "%s~\n\n", strip_cr( help->text ) ); } fprintf( fp, "-1 $~\n\n" ); ha->changed = FALSE; return; } void save_other_helps( CHAR_DATA *ch ) { extern HELP_AREA * had_list; HELP_AREA *ha; FILE *fp; char buf[MIL]; for ( ha = had_list; ha; ha = ha->next ) if ( ha->changed == TRUE && ha->area == NULL ) { sprintf( buf, "%s", ha->filename ); fp = fopen( buf, "w" ); if ( !fp ) { perror( ha->filename ); return; } save_helps( fp, ha ); if ( ch ) ch_printf( ch, "%s\n\r", ha->filename); fprintf( fp, "#$\n" ); fclose( fp ); } return; } void fold_area( AREA_DATA *tarea, char *filename ) { ROOM_INDEX_DATA *pRoomIndex; MOB_INDEX_DATA *pMobIndex; OBJ_INDEX_DATA *pObjIndex; EXTRA_DESCR_DATA *pEd; RESET_DATA *pReset; EXIT_DATA *pExit; AFFECT_DATA *pAf; ROOMTEXT_DATA *pRt; FILE *fp; int iHash; int door,x =0; int vnum; if ( ( fp = fopen( filename, "w" ) ) == NULL ) { bug( "fold_area: fopen", 0 ); perror( filename ); return; } if( IS_SET(tarea->area_flags, AREA_ADDED ) ) REMOVE_BIT( tarea->area_flags, AREA_ADDED ); fprintf(fp, "#ADAREA\n"); fprintf(fp, "N %s~\n", strip_cr(tarea->name)); fprintf(fp, "B %s~\n", strip_cr(tarea->builders)); fprintf(fp, "V %d %d\n", tarea->lvnum, tarea->uvnum); fprintf(fp, "S %d\n", tarea->security); fprintf(fp, "F %d\n", tarea->area_flags); fprintf(fp, "M %d\n", tarea->mod ); fprintf(fp, "End\n\n\n"); if ( tarea->helps && tarea->helps->first ) save_helps( fp, tarea->helps ); fprintf(fp, "#ADMOBS\n"); for(iHash = 0; iHash < MAX_KEY_HASH; iHash++) { for( pMobIndex = mob_index_hash[iHash]; pMobIndex; pMobIndex = pMobIndex->next ) { if (pMobIndex == NULL || pMobIndex->area != tarea) continue; fprintf(fp, "#%d\n", pMobIndex->vnum); fprintf(fp, "N %s~\n", strip_cr(pMobIndex->player_name)); fprintf(fp, "S %s~\n", strip_cr(pMobIndex->short_descr)); fprintf(fp, "L %s~\n", strip_cr(pMobIndex->long_descr)); fprintf(fp, "D %s~\n", strip_cr(pMobIndex->description)); fprintf(fp, "A %d\n", pMobIndex->act); fprintf(fp, "Af %d\n", pMobIndex->affected_by); fprintf(fp, "Al %d\n", pMobIndex->alignment); fprintf(fp, "Lv %d\n", pMobIndex->level); fprintf(fp, "G %d\n", pMobIndex->gold); fprintf(fp, "Sx %d\n", pMobIndex->sex); if( pMobIndex->spec_fun ) fprintf(fp, "Sp %s\n", spec_name(pMobIndex->spec_fun) ); if ( pMobIndex->pShop != NULL ) { int iTrade; fprintf( fp, "Shop\n" ); fprintf( fp, " P %d %d\n", pMobIndex->pShop->profit_buy, pMobIndex->pShop->profit_sell ); fprintf( fp, " H %d %d\n", pMobIndex->pShop->open_hour, pMobIndex->pShop->close_hour ); for( iTrade = 0; iTrade < MAX_TRADE; iTrade++ ) { if( pMobIndex->pShop->buy_type[iTrade] > 0 ) fprintf( fp, "T %d %d\n", iTrade, pMobIndex->pShop->buy_type[iTrade] ); } fprintf( fp, "EndShop\n" ); } fprintf(fp, "End\n"); } } fprintf(fp, "#0\n\n\n\n"); fprintf( fp, "#ADOBJ\n" ); for(iHash = 0; iHash < MAX_KEY_HASH; iHash++) { for( pObjIndex = obj_index_hash[iHash]; pObjIndex; pObjIndex = pObjIndex->next ) { if (pObjIndex == NULL || pObjIndex->area != tarea) continue; fprintf(fp, "#%d\n", pObjIndex->vnum); fprintf(fp, "N %s~\n", strip_cr(pObjIndex->name)); fprintf(fp, "S %s~\n", strip_cr(pObjIndex->short_descr)); fprintf(fp, "D %s~\n", strip_cr(pObjIndex->description)); fprintf(fp, "T %d\n", pObjIndex->item_type); fprintf(fp, "E %d\n", pObjIndex->extra_flags); fprintf(fp, "W %d\n", pObjIndex->wear_flags); if( pObjIndex->quest != 0 ) fprintf(fp, "Qf %d\n", pObjIndex->quest ); for( x = 0; x < MAX_OVALUE; x++ ) { fprintf( fp, "V %d ",x); switch (pObjIndex->item_type) { default: fprintf(fp, "%d\n", pObjIndex->value[x] ); break; case ITEM_PILL: case ITEM_POTION: case ITEM_SCROLL: if( x > 0 ) fprintf(fp, "%d\n", sn_lookup(pObjIndex->value[x])); else fprintf(fp, "%d\n", pObjIndex->value[x] ); break; case ITEM_STAFF: case ITEM_WAND: fprintf(fp, "%d\n", (x > 2) ? sn_lookup(pObjIndex->value[x]) : pObjIndex->value[x] ); break; } } fprintf(fp, "Wg %d\n", pObjIndex->weight); fprintf(fp, "C %d\n", pObjIndex->cost); for(pAf = pObjIndex->affected; pAf ; pAf = pAf->next) { fprintf(fp, "A\n%d %d\n", pAf->location, pAf->modifier); } for(pEd = pObjIndex->extra_descr; pEd ; pEd = pEd->next) { fprintf(fp, "ED\n%s~\n%s~\n", pEd->keyword, strip_cr(pEd->description)); } if (pObjIndex->spectype > 0) { fprintf(fp, "Q\n%s~\n%s~\n%s~\n%s~\n%s~\n%s~\n%d %d\n", strip_cr(pObjIndex->chpoweron), strip_cr(pObjIndex->chpoweroff), strip_cr(pObjIndex->chpoweruse), strip_cr(pObjIndex->victpoweron), strip_cr(pObjIndex->victpoweroff), strip_cr(pObjIndex->victpoweruse), pObjIndex->spectype, pObjIndex->specpower); } fprintf(fp, "End\n"); } } fprintf( fp, "#0\n\n\n\n" ); /* save rooms */ fprintf( fp, "#ADROOMS\n" ); for ( vnum = tarea->lvnum; vnum <= tarea->uvnum; vnum++ ) { if ( (pRoomIndex = get_room_index( vnum )) == NULL ) continue; if( pRoomIndex->area != tarea ) continue; fprintf(fp, "#%d\n", pRoomIndex->vnum); fprintf(fp, "N %s~\n", strip_cr(pRoomIndex->name)); fprintf(fp, "D %s~\n", strip_cr(pRoomIndex->description)); fprintf(fp, "F %d\n", pRoomIndex->room_flags); fprintf(fp, "S %d\n", pRoomIndex->sector_type); for (pEd = pRoomIndex->extra_descr; pEd; pEd = pEd->next) fprintf(fp, "ED\n%s~\n%s~\n", pEd->keyword, strip_cr(pEd->description)); for( pReset = pRoomIndex->reset_first; pReset; pReset = pReset->next ) fprintf( fp, "R %c %d %d %d\n", pReset->command, pReset->arg1, pReset->arg2, pReset->arg3 ); for(door = 0; door < MAX_DIR; door++) { if ( (pExit = pRoomIndex->exit[door] ) != NULL && pExit->to_room && pExit->to_room->vnum > 0 ) { fprintf( fp, "Dr %d %d %d %d\n", door, pExit->rs_flags, pExit->key, pExit->to_room->vnum ); fprintf( fp, "%s~\n", strip_cr( pExit->description ) ); if ( pExit->keyword != NULL ) fprintf( fp, "%s~\n", strip_cr( pExit->keyword ) ); else fprintf( fp, "~\n" ); } } for (pRt = pRoomIndex->roomtext; pRt; pRt = pRt->next) { fprintf(fp, "T\n%s~\n%s~\n%s~\n%s~\n%d %d %d\n", pRt->input, pRt->output, pRt->choutput, pRt->name, pRt->type, pRt->power, pRt->mob); } fprintf(fp, "End\n"); } fprintf( fp, "#0\n\n\n" ); fprintf( fp, "#$\n" ); fclose( fp ); return; } /***************************************************************************** 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( bool build ) { FILE *fp; AREA_DATA *pArea; extern HELP_AREA * had_list; HELP_AREA * ha; char buf[MAX_STRING_LENGTH]; sprintf( buf, "%s", build ? BUILD_DIR BUILD_LIST : AREA_LIST ); // sprintf( buf, "%s", BUILD_DIR BUILD_LIST ); if ( ( fp = fopen( buf, "w" ) ) == NULL ) { bug( "Save_area_list: fopen", 0 ); perror( buf ); } else { if( !build ) { for ( ha = had_list; ha; ha = ha->next ) if ( ha->area == NULL ) fprintf( fp, "%s\n", ha->filename ); for( pArea = area_first; pArea; pArea = pArea->next ) { fprintf( fp, "%s\n", pArea->filename ); } } else { #ifdef BUILD_AREAS for( pArea = build_first; pArea; pArea = pArea->next ) fprintf( fp, "%s\n", pArea->filename ); #endif } fprintf( fp, "$\n" ); fclose( fp ); } return; } void do_asave(CHAR_DATA *ch, char *argument) { char arg1 [MAX_INPUT_LENGTH]; AREA_DATA *pArea; FILE *fp; int value; fp = NULL; if (ch == NULL) /* Do an autosave */ { // save_area_list( FALSE ); for(pArea = area_first; pArea != NULL; pArea = pArea->next) { if( !IS_SET(pArea->area_flags, AREA_CHANGED ) ) continue; REMOVE_BIT(pArea->area_flags, AREA_CHANGED); fold_area( pArea , pArea->filename ); } save_other_helps(NULL); return; } smash_tilde(argument); strcpy(arg1, argument); if (arg1[0] == '\0') { send_to_char("Syntax:\n\r", ch); send_to_char(" asave list - saves the area.lst file\n\r", ch); send_to_char(" asave zone - saves the zone you're in\n\r", ch); send_to_char(" asave changed - saves all changed zones\n\r", ch); send_to_char(" asave world - saves the world! (db dump)\n\r", ch); send_to_char(" asave helps - saves the helps\n\r", ch ); send_to_char("\n\r", ch); return; } /* * Snarf the value (which need not be numeric). */ value = atoi(arg1); if ((pArea = get_area_data(value)) == '\0' && is_number(arg1)) { send_to_char("That area does not exist.\n\r", ch); return; } if (is_number(arg1)) { save_area_list( FALSE ); fold_area(pArea, pArea->filename); return; } if (!str_cmp("world", arg1) || !str_cmp("all", arg1)) { save_area_list( FALSE ); for(pArea = area_first; pArea != '\0'; pArea = pArea->next) { fold_area( pArea,pArea->filename ); REMOVE_BIT(pArea->area_flags, AREA_CHANGED); } save_other_helps(ch); send_to_char("You saved the world.\n\r", ch); send_to_all_char("Database saved.\n\r"); return; } if (!str_cmp("changed", arg1)) { char buf[MAX_INPUT_LENGTH]; save_area_list( FALSE ); send_to_char("Saved zones:\n\r", ch); sprintf(buf, "None.\n\r"); for(pArea = area_first; pArea != '\0'; pArea = pArea->next) { if (IS_SET(pArea->area_flags, AREA_CHANGED)) { REMOVE_BIT(pArea->area_flags, AREA_CHANGED); fold_area(pArea,pArea->filename); sprintf(buf, "%24s - '%s'\n\r", pArea->name, pArea->filename); send_to_char(buf, ch); } } save_other_helps(ch); if (!str_cmp(buf, "None.\n\r")) send_to_char(buf, ch); return; } if (!str_cmp(arg1, "list")) { save_area_list( FALSE ); return; } if (!str_cmp(arg1, "zone") || !str_cmp( arg1, "area") ) { do_savearea( ch, "" ); return; } if( !str_cmp( arg1, "helps" ) ) { save_other_helps(ch); send_to_char("Done.\n\r",ch); return; } do_asave(ch, ""); return; } void do_savearea( CHAR_DATA *ch, char *argument ) { AREA_DATA *tarea; char filename[256]; if( !IS_BUILDER_HERE(ch) ) { send_to_char( "You don't have an assigned area to save.\n\r", ch ); return; } tarea = ch->in_room->area; if ( !tarea ) { send_to_char( "No area to save.\n\r", ch ); return; } sprintf( filename, "%s", tarea->filename ); send_to_char( "Saving area...\n\r", ch ); sprintf( log_buf, "Saving %s by %s...", filename, ch->name ); logfl( LOG_OLC, log_buf); REMOVE_BIT(tarea->area_flags, AREA_CHANGED); fold_area( tarea, filename ); send_to_char( "Done.\n\r", ch ); } /***************************************************************************** Name: do_alist Purpose: Normal command to list areas and display area information. Called by: interpreter(interp.c) ****************************************************************************/ void do_arealist (CHAR_DATA * ch, char *argument) { char result[MAX_STRING_LENGTH]; /* May need tweaking. */ char buf[MAX_STRING_LENGTH]; /* May need tweaking. */ AREA_DATA *pArea; sprintf (result, "{c[{C%3s{c] [{C%-27s{c] ({C%-5s-%5s{c) [{C%-13.13s{c] {W%3s {c[{C%-10s{c]\n\r", "Num", "Area Name", "lvnum", "uvnum", "Filename", "Sec", "Builders"); for (pArea = area_first; pArea; pArea = pArea->next) { sprintf (buf, "{c[{C%3d{c] [{C%-27.27s{c] ({C%-5d-%5d{c) [{C%-13.13s{c] {W%3d {c[{C%-10.10s{c]\n\r", pArea->vnum, pArea->name, pArea->lvnum, pArea->uvnum, pArea->filename, pArea->security, pArea->builders); stc (buf, ch); } return; } HELP_DATA * help_lookup( char *keyword ) { HELP_DATA *pHelp; char temp[MIL], argall[MIL]; argall[0] = '\0'; while (keyword[0] != '\0' ) { keyword = one_argument(keyword, temp); if (argall[0] != '\0') strcat(argall," "); strcat(argall, temp); } for ( pHelp = help_first; pHelp != NULL; pHelp = pHelp->next ) if ( is_name( argall, pHelp->keyword ) ) return pHelp; return NULL; } HELP_AREA * get_help_area( HELP_DATA *help ) { HELP_AREA * temp; HELP_DATA * thelp; for ( temp = had_list; temp; temp = temp->next ) for ( thelp = temp->first; thelp; thelp = thelp->next_area ) if ( thelp == help ) return temp; return NULL; } bool hedit_show ( CHAR_DATA *ch, char *argument ) { HELP_DATA * help; char buf[MSL*2]; EDIT_HELP(ch, help); sprintf( buf, "{CKeyword : {n%s\n\r" "{CLevel : {n%d\n\r" "{CText :\n\r" "{n%s\n\r", help->keyword, help->level, help->text ); send_to_char( buf, ch ); return FALSE; } bool hedit_level ( CHAR_DATA *ch, char *argument ) { HELP_DATA *help; int lev; EDIT_HELP(ch, help); if ( !argument || !is_number(argument) ) { send_to_char( "Syntax : level [-1..MAX_LEVEL]\n\r", ch ); return FALSE; } lev = atoi(argument); if ( lev < -1 || lev > MAX_LEVEL ) { ch_printf( ch, "HEdit : Level from -1 to %d only.\n\r", MAX_LEVEL ); return FALSE; } help->level = lev; send_to_char( "Ok.\n\r", ch ); return TRUE; } bool hedit_keyword ( CHAR_DATA *ch, char *argument ) { HELP_DATA *help; EDIT_HELP(ch, help); if ( !(argument) ) { send_to_char( "Syntax : keyword [keywords]\n\r", ch ); return FALSE; } free_string(help->keyword); help->keyword = str_dup(argument); send_to_char( "Ok.\n\r", ch ); return TRUE; } bool hedit_new ( CHAR_DATA *ch, char *argument ) { char arg[MIL], fullarg[MIL]; HELP_AREA *had; HELP_DATA *help; extern HELP_DATA *help_last; if ( !(argument) ) { send_to_char( "Syntax : new [help]\n\r", ch ); send_to_char( " new [area] [help]\n\r", ch ); return FALSE; } strcpy( fullarg, argument ); argument = one_argument( argument, arg ); if ( !(had = had_lookup(arg)) ) { had = ch->in_room->area->helps; argument = fullarg; } if ( help_lookup(argument) ) { send_to_char( "HEdit : Help already exhists.\n\r", ch ); return FALSE; } if (!had) { had = new_had(); had->filename = str_dup(ch->in_room->area->filename); had->area = ch->in_room->area; had->first = NULL; had->last = NULL; had->changed = TRUE; had->next = had_list; had_list = had; ch->in_room->area->helps = had; SET_BIT(ch->in_room->area->area_flags, AREA_CHANGED); } help = new_help(); help->level = 0; help->keyword = str_dup(argument); help->text = str_dup( "" ); if (help_last) help_last->next = help; if (help_first == NULL) help_first = help; help_last = help; help->next = NULL; if ( !had->first ) had->first = help; if ( !had->last ) had->last = help; had->last->next_area = help; had->last = help; help->next_area = NULL; set_editor( ch->desc, ED_HELP, help ); send_to_char( "Ok.\n\r", ch ); return FALSE; } bool hedit_text ( CHAR_DATA *ch, char *argument ) { HELP_DATA *help; EDIT_HELP(ch, help); if ( !(argument) ) { send_to_char( "Syntax : text\n\r", ch ); return FALSE; } string_append( ch, &help->text ); return TRUE; } bool hedit_delete ( CHAR_DATA *ch, char *argument ) { HELP_DATA * pHelp, * temp; HELP_AREA * had; DESCRIPTOR_DATA *d; bool found = FALSE; EDIT_HELP(ch, pHelp); for ( d = descriptor_list; d; d = d->next ) if ( d->editor == ED_HELP && pHelp == (HELP_DATA *) d->pEdit ) edit_done(d->character); if (help_first == pHelp) help_first = help_first->next; else { for ( temp = help_first; temp; temp = temp->next ) if ( temp->next == pHelp ) break; if ( !temp ) { bugf( "hedit_delete : help %s not on help_first", pHelp->keyword ); return FALSE; } temp->next = pHelp->next; } for ( had = had_list; had; had = had->next ) if ( pHelp == had->first ) { found = TRUE; had->first = had->first->next_area; } else { for ( temp = had->first; temp; temp = temp->next_area ) if ( temp->next_area == pHelp ) break; if ( temp ) { temp->next_area = pHelp->next_area; found = TRUE; break; } } if ( !found ) { bugf( "hedit_delete : help %s not on had_list", pHelp->keyword ); return FALSE; } free_help(pHelp); send_to_char( "Ok.\n\r", ch ); return TRUE; } bool hedit_list ( CHAR_DATA *ch, char *argument ) { char buf[MIL]; int cnt = 0; HELP_DATA *pHelp; EDIT_HELP(ch, pHelp); if ( !str_cmp( argument, "all" ) ) { for ( pHelp = help_first; pHelp; pHelp = pHelp->next ) { sprintf( buf, "%3d. %-14.14s%s", cnt, pHelp->keyword, cnt % 4 == 3 ? "\n\r" : " " ); stc( buf , ch); cnt++; } if ( cnt % 4 ) stc( "\n\r",ch ); return FALSE; } if ( !str_cmp( argument, "area" ) ) { if ( ch->in_room->area->helps == NULL ) { send_to_char( "No hay helps en esta area.\n\r", ch ); return FALSE; } for ( pHelp = ch->in_room->area->helps->first; pHelp; pHelp = pHelp->next_area ) { sprintf( buf, "%3d. %-14.14s%s", cnt, pHelp->keyword, cnt % 4 == 3 ? "\n\r" : " " ); stc( buf, ch ); cnt++; } if ( cnt % 4 ) stc( "\n\r", ch ); return FALSE; } if ( !(argument) ) { send_to_char( "Syntax : list all\n\r", ch ); send_to_char( " list area\n\r", ch ); return FALSE; } return FALSE; } void hedit( CHAR_DATA *ch, char *argument) { HELP_DATA * pHelp; HELP_AREA *had; char arg[MAX_INPUT_LENGTH]; char command[MAX_INPUT_LENGTH]; int cmd; smash_tilde(argument); strcpy(arg, argument); argument = one_argument( argument, command); EDIT_HELP(ch, pHelp); had = get_help_area(pHelp); if (had == NULL) { bugf( "hedit : Help you are editing (%s) is NULL", pHelp->keyword ); edit_done(ch); return; } if (ch->pcdata->security < 9) { send_to_char("HEdit: Insuficient security to edit helps.\n\r",ch); edit_done(ch); return; } if (command[0] == '\0') { hedit_show(ch, argument); return; } if (!str_cmp(command, "done") ) { edit_done(ch); return; } for (cmd = 0; *hedit_table[cmd].name; cmd++) { if (!str_cmp(command, hedit_table[cmd].name) ) { if ((*hedit_table[cmd].olc_fun) (ch, argument)) had->changed = TRUE; return; } } interpret(ch, arg); return; } void do_hedit(CHAR_DATA *ch, char *argument) { HELP_DATA * pHelp; char arg[MIL]; char arg2[MIL]; if ( IS_NPC(ch) ) return; strcpy( arg, argument ); argument = one_argument( argument, arg2 ); if( arg2[0] != '\0' && !str_cmp( arg2, "create" ) ) { if( hedit_new( ch, argument ) ) return; } if ( (pHelp = help_lookup( arg )) == NULL ) { send_to_char( "HEdit : Help non-exhistant\n\r", ch ); return; } set_editor( ch->desc, ED_HELP, pHelp ); return; } CEDIT(cedit_show) { ch_printf(ch, "\n\r{WMud_name: {R%s\n\r", "Acension to Darkness" ); ch_printf(ch, "{WPlayers:\n\r" " {nMax: {W%d {nTime of Max: {W%s\n\r", sysdata.maxplayers, sysdata.time_of_max ); ch_printf(ch, " {nAll Time max: {W%d\n\r", sysdata.alltimemax ); ch_printf(ch, "{WChannels:\n\r" " {nLog: {W%d\n\r", sysdata.log_level ); ch_printf(ch, "{WBuilding:\n\r" " {nDefault Security: {W%d {nPlayer msetting: {W%d\n\r", 0, sysdata.level_mset_player ); ch_printf(ch, "{WBan Data:\n\r" " {nBan Site Level: {W%d {nBan Class Level: {W%d\n\r", sysdata.ban_site_level, sysdata.ban_class_level ); ch_printf(ch, "{WCombat:\n\r" " {nPlr vs. Plr: {W%d {nPlr vs. Mob: {W%d\n\r", sysdata.dam_plr_vs_plr,sysdata.dam_plr_vs_mob ); ch_printf(ch, " {nMob vs. Plr: {W%d {nMob vs. Mob: {W%d\n\r", sysdata.dam_mob_vs_plr,sysdata.dam_mob_vs_mob ); ch_printf(ch, "{WDefenses:\n\r" " {nDodge_mod: {W%d {nParry_mod: {W%d\n\r", sysdata.dodge_mod, sysdata.parry_mod ); ch_printf(ch, "{WClass:\n\r" " {nDrows: {W%3.3d {nMonks: {W%3.3d {nMages: {W%3.3d {nNinjas: {W%3.3d\n\r" " {nPriests: {W%3.3d {nAngels: {W%3.3d {nDemons: {W%3.3d {nVampires: {W%3.3d\n\r" " {nWerewolfs: {W%3.3d\n\r", sysdata.drows, sysdata.monks, sysdata.mages, sysdata.ninjas, sysdata.priests, sysdata.angels, sysdata.demons, sysdata.vampires, sysdata.werewolfs ); ch_printf(ch, "{WPfile autocleanup status: %s\n\r" " {nDays before purging newbies: {W%d\n\r", sysdata.CLEANPFILES ? "{COn" : "{cOff", sysdata.newbie_purge ); ch_printf(ch, " {nDays before purging regular players: {W%d\n\r", sysdata.regular_purge ); ch_printf(ch, "{WOther:\n\r" " {nForce on players: {W%-2d\n\r", sysdata.level_forcepc); ch_printf(ch, " {nPrivate room override: {W%-2d\n\r", sysdata.level_override_private); ch_printf(ch, " {nGet object without take flag: {W%-7d\n\r", sysdata.level_getobjnotake); ch_printf(ch, " {nAutosave frequency (minutes): {W%d\n\r", sysdata.save_frequency ); ch_printf(ch, " {nHostname resolving: {W%s\n\r", sysdata.NO_NAME_RESOLVING ? "OFF" : "ON" ); ch_printf(ch, " {nWorld flags: {W%s\n\r", flag_string( world_flags, sysdata.world ) ); return FALSE; } bool cedit_change( CHAR_DATA *ch, char *argument, char *type, sh_int * num ) { if ( argument[0] == '\0' || !is_number( argument ) ) { ch_printf(ch, "Syntax: %s [number]\n\r", type); return FALSE; } *num = atoi(argument); stc("Ok.\n\r",ch); return TRUE; }; CEDIT( cedit_savefreq ) { return cedit_change( ch, argument, "save frequency", &sysdata.save_frequency ); } CEDIT( cedit_dodgemod ) { return cedit_change( ch, argument, "dodge mod", &sysdata.dodge_mod ); } CEDIT( cedit_parrymod ) { return cedit_change( ch, argument, "parry mod", &sysdata.parry_mod ); } CEDIT( cedit_dam_pvp ) { return cedit_change( ch, argument, "plr vs plr damage", &sysdata.dam_plr_vs_plr ); } CEDIT( cedit_dam_pvm ) { return cedit_change( ch, argument, "plr vs mob damage", &sysdata.dam_plr_vs_mob ); } CEDIT( cedit_dam_mvp ) { return cedit_change( ch, argument, "mob vs plr damage", &sysdata.dam_mob_vs_plr ); } CEDIT( cedit_dam_mvm ) { return cedit_change( ch, argument, "mob vs mob damage", &sysdata.dam_mob_vs_mob ); } CEDIT( cedit_plr_mset ) { return cedit_change( ch, argument, "mset pc", &sysdata.level_mset_player ); } CEDIT( cedit_forcepc ) { return cedit_change( ch, argument, "force player", &sysdata.level_forcepc ); } CEDIT( cedit_ban_site ) { return cedit_change( ch, argument, "ban site", &sysdata.ban_site_level ); } CEDIT( cedit_newbie_purge ) { return cedit_change( ch, argument, "newbie_purge", &sysdata.newbie_purge ); } CEDIT( cedit_regular_purge ) { return cedit_change( ch, argument, "regular_purge", &sysdata.regular_purge ); } CEDIT( cedit_ban_class ) { return cedit_change( ch, argument, "ban class", &sysdata.ban_class_level ); } CEDIT( cedit_pfiles ) { sysdata.CLEANPFILES = !sysdata.CLEANPFILES; if ( sysdata.CLEANPFILES ) send_to_char( "Pfile autocleanup enabled.\n\r", ch ); else send_to_char( "Pfile autocleanup disabled.\n\r", ch ); return TRUE; } void cedit( CHAR_DATA *ch, char *argument ) { char arg[MAX_INPUT_LENGTH]; char command[MAX_INPUT_LENGTH]; int cmd; int value; smash_tilde(argument); strcpy(arg, argument); argument = one_argument( argument, command); if (command[0] == '\0') { cedit_show(ch, argument); return; } if (!str_cmp(command, "done") ) { edit_done(ch); return; } for (cmd = 0; *cedit_table[cmd].name; cmd++) { if (!str_cmp(command, cedit_table[cmd].name) ) { if ((*cedit_table[cmd].olc_fun) (ch, argument)) { save_sysdata(sysdata); send_to_char( "\n\r{YControl panel saved.{n\n\r", ch ); } return; } } if ( ( value = flag_value( world_flags, arg ) ) != NO_FLAG ) { TOGGLE_BIT(sysdata.world, value); save_sysdata(sysdata); send_to_char( "{YWorld flag changed.{n\n\r", ch ); send_to_char( "\n\r{YControl panel saved.{n\n\r", ch ); return; } interpret(ch, arg); return; } void do_cedit(CHAR_DATA *ch, char *argument) { if ( IS_NPC(ch) ) return; set_editor( ch->desc, ED_CONTROL, NULL ); do_cshow(ch,""); return; } void do_cshow( CHAR_DATA *ch, char *argument ) { cedit_show(ch,""); return; } CLEDIT( cledit_create ) { CLAN_DATA *pClan; if( argument[0] == '\0' ) { stc("Syntax: create <filename>\n\r", ch ); return FALSE; } pClan = new_clan_data( ); free_string( pClan->filename ); pClan->filename = str_dup( argument ); set_editor( ch->desc, ED_CLAN, pClan ); logf( NULL, "%s has just created a new clan!", ch->name ); stc( "Clan created.\n\r", ch ); return TRUE; } CLEDIT( cledit_filename ) { CLAN_DATA *pClan; EDIT_CLAN( ch, pClan ); if( argument[0] == '\0' ) { send_to_char( "Syntax: filename <$name>\n\r", ch ); return FALSE; } free_string( pClan->filename ); pClan->filename = str_dup( argument ); send_to_char( "Name set.\n\r", ch ); return TRUE; } CLEDIT( cledit_name ) { CLAN_DATA *pClan; EDIT_CLAN( ch, pClan ); if( argument[0] == '\0' ) { send_to_char( "Syntax: name <$name>\n\r", ch ); return FALSE; } free_string( pClan->name ); pClan->name = str_dup( argument ); send_to_char( "Name set.\n\r", ch ); return TRUE; } CLEDIT( cledit_display ) { CLAN_DATA *pClan; EDIT_CLAN( ch, pClan ); if( argument[0] == '\0' ) { send_to_char( "Syntax: display <$name>\n\r", ch ); return FALSE; } free_string( pClan->who_name ); pClan->who_name = str_dup( argument ); send_to_char( "Display name set.\n\r", ch ); return TRUE; } CLEDIT( cledit_show ) { CLAN_DATA *pClan; EDIT_CLAN( ch, pClan ); show_clan( ch, pClan ); return FALSE; } CLEDIT( cledit_motto ) { CLAN_DATA *pClan; EDIT_CLAN( ch, pClan ); if( argument[0] == '\0' ) { send_to_char( "Syntax: motto <$motto>\n\r", ch ); return FALSE; } free_string( pClan->motto ); pClan->motto = str_dup( argument ); pClan->motto[0] = UPPER( pClan->motto[0] ); send_to_char( "Clan motto set.\n\r", ch ); return TRUE; } CLEDIT( cledit_desc ) { CLAN_DATA *pClan; EDIT_CLAN( ch, pClan ); if( argument[0] == '\0' ) { string_edit( ch, &pClan->description ); return TRUE; } send_to_char( "Syntax: desc - line editor\n\r", ch ); return FALSE; } CLEDIT( cledit_recall ) { CLAN_DATA *pClan; char room[MAX_STRING_LENGTH]; int value; EDIT_CLAN( ch, pClan ); one_argument( argument, room ); if( !is_number( argument ) || argument[0] == '\0' ) { send_to_char( "Syntax: recall <##rvnum>\n\r", ch ); return FALSE; } value = atoi( room ); if( !get_room_index( value ) ) { send_to_char( "CEdit: Room vnum does not exist.\n\r", ch ); return FALSE; } pClan->recall = value; send_to_char( "Recall set.\n\r", ch ); return TRUE; } CLEDIT( cledit_leader ) { CLAN_DATA *pClan; CHAR_DATA *victim, *oldleader = NULL; OBJ_DATA *ring; EDIT_CLAN( ch, pClan ); if( argument[0] == '\0' ) { send_to_char( "Syntax: leader <$name>\n\r", ch ); return FALSE; } if( !( victim = get_char_world( ch, argument ) ) || IS_NPC( victim ) ) { send_to_char( "You can't find them.\n\r", ch ); return FALSE; } if( pClan->overlord && pClan->overlord[0] && ( !( oldleader = get_char_world( ch, pClan->overlord ) ) || IS_NPC( oldleader ) ) ) { send_to_char( "You must have the old leader logged on (use pload).\n\r", ch ); return FALSE; } /* * Demote the old leader, no message. */ if( oldleader ) { oldleader->pcdata->clan_rank = RANK_CHIEFTAIN; free_string( pClan->chieftain ); pClan->chieftain = str_dup( oldleader->name ); } /* * change new leader's clan and make him appropriate rank. */ if( victim->pcdata->clan ) remove_from_clan( victim ); free_string( pClan->overlord ); victim->pcdata->clan = pClan; victim->pcdata->clan_rank = RANK_CLANSMAN; pClan->members++; ring = create_object( get_obj_index( pClan->clanobj1 ), victim->level); if ( ring ) obj_to_char( ring, victim ); send_to_char( "Leader set.\n\r", ch ); return TRUE; } bool cledit_obj( CHAR_DATA *ch, char *argument, char * obj_num, int * clan_obj ) { int vnum; if( argument[0] == '\0' || !is_number(argument)) { ch_printf( ch, "Syntax: %s <##ovnum>\n\r", obj_num ); return FALSE; } vnum = atoi( argument ); if( vnum < 1 ) { ch_printf( ch, "Syntax: %s <##ovnum>\n\r", obj_num ); return FALSE; } if( !get_obj_index( vnum ) ) { ch_printf( ch, "Vnum: %d - No such object.\n\r", vnum ); return FALSE; } *clan_obj = vnum; stc( "Done.\n\r", ch ); return TRUE; } CLEDIT( cledit_obj1 ) { CLAN_DATA *pClan; EDIT_CLAN( ch, pClan ); return cledit_obj( ch, argument, "obj_1", &pClan->clanobj1 ); } CLEDIT( cledit_obj2 ) { CLAN_DATA *pClan; EDIT_CLAN( ch, pClan ); return cledit_obj( ch, argument, "obj_2", &pClan->clanobj2 ); } CLEDIT( cledit_obj3 ) { CLAN_DATA *pClan; EDIT_CLAN( ch, pClan ); return cledit_obj( ch, argument, "obj_3", &pClan->clanobj3 ); } void cledit( CHAR_DATA *ch, char *argument ) { CLAN_DATA *pClan; char command[MAX_INPUT_LENGTH]; char arg[MAX_STRING_LENGTH]; int cmd; EDIT_CLAN( ch, pClan ); strcpy( arg, argument ); argument = one_argument( arg, command ); if( command[0] == '\0' ) { cledit_show( ch, argument ); return; } if( !str_cmp( command, "done" ) ) { edit_done( ch ); return; } /* Search Table and Dispatch Command. */ for( cmd = 0; *cledit_table[cmd].name; cmd++ ) { if( !str_prefix( command, cledit_table[cmd].name ) ) { (*cledit_table[cmd].olc_fun) ( ch, argument ); save_clan( pClan ); return; } } /* Default to Standard Interpreter. */ interpret( ch, arg ); return; } void do_cledit( CHAR_DATA *ch, char *argument ) { CLAN_DATA *pClan; char buf[MAX_INPUT_LENGTH]; argument = one_argument( argument, buf ); if( !str_cmp( buf, "create" ) ) { if( cledit_create( ch, argument ) ) save_clan_list(); return; } if( !( pClan = clan_lookup( buf )) ) { int cln; send_to_char( "CEdit: There is no clan to edit.\n\r", ch ); ch_printf( ch, "## ][ Clan Name\n\r", ch ); ch_printf( ch, "---------------------------------------\n\r" ); for( cln = 0, pClan = clan_first; pClan; pClan = pClan->next, cln++ ) ch_printf( ch, "%2.2d %s\n\r", cln, pClan->name ); return; } set_editor( ch->desc, ED_CLAN, pClan ); cledit_show( ch, "" ); return; } bool rename_show(CHAR_DATA *ch, char *argument) { OBJ_DATA *pObj; RENAME_OBJ( ch, pObj ); send_to_char("{YREMAKE AN ITEM: {cType {Rdone{x when finished.{x\n\r", ch ); send_to_char("{nType '{Cshow{n' to see the item so far.{x\n\r\n\r", ch ); ch_printf(ch,"1) Keyword(s): Syntax: 1 <new keyword>\n\r" ); ch_printf(ch," %s\n\r", pObj->name ); ch_printf(ch,"2) Short: Syntax: 2 <Looks in inv or equiped.>\n\r" ); ch_printf(ch," %s{x\n\r", pObj->short_descr ); ch_printf(ch,"3) Long: Syntax: 3 <Looks when on the ground or looked at.>\n\r"); ch_printf(ch," %s{x\n\r", pObj->description ); return FALSE; } bool rename_keyword( CHAR_DATA *ch, char *argument ) { OBJ_DATA *pObj; RENAME_OBJ(ch, pObj); if ( argument[0] == '\0' ) { send_to_char("Syntax: keyword [string]\n\r", ch ); return FALSE; } free_string( pObj->name ); pObj->name = str_dup( argument ); send_to_char("Keyword set.\n\r", ch); return TRUE; } bool rename_short( CHAR_DATA *ch, char *argument ) { OBJ_DATA *pObj; RENAME_OBJ(ch, pObj); if ( argument[0] == '\0' ) { send_to_char("Syntax: short [string]\n\r", ch ); return FALSE; } free_string( pObj->short_descr ); pObj->short_descr = str_dup( argument ); send_to_char( "Short description set.\n\r", ch); return TRUE; } bool rename_long( CHAR_DATA *ch, char *argument ) { OBJ_DATA *pObj; RENAME_OBJ(ch, pObj); if ( argument[0] == '\0' ) { send_to_char("Syntax: long [$string]\n\r", ch ); return FALSE; } free_string( pObj->description ); pObj->description = str_dup( argument ); pObj->description[0] = UPPER( pObj->description[0] ); send_to_char( "Long description set.\n\r", ch); return TRUE; } void rename_object(CHAR_DATA *ch, char *argument) { char command[MAX_INPUT_LENGTH]; char arg[MAX_STRING_LENGTH]; int cmd; smash_tilde(argument); strcpy(arg, argument); argument = one_argument(argument, command); if(command[0] == '\0') { rename_show(ch, argument); return; } if(!str_cmp(command, "done")) { edit_done( ch ); if( !IS_IMMORTAL(ch) ) PC(ch,stats[DEMON_CURRENT]) -= 2000; save_char_obj( ch ); return; } /* Call editor function */ for(cmd = 0;*rename_obj_table[cmd].name;cmd++) { if(!str_prefix(command, rename_obj_table[cmd].name)) { (*rename_obj_table[cmd].olc_fun) (ch, argument); return; } } /* Default to Standard Interpreter. */ interpret(ch, arg); return; } /* * This is called from different commands like vamp vtwist */ void do_rename_obj( CHAR_DATA *ch, char *argument, char *cmd ) { OBJ_DATA *pObj; char command[MAX_INPUT_LENGTH]; argument = one_argument( argument, command ); if( IS_NPC(ch) ) return; if ( command[0] == '\0' ) { ch_printf( ch, "Syntax: %s <obj name>.\n\r", cmd ); return; } if (!IS_IMMORTAL(ch) && PC(ch,stats[DEMON_CURRENT]) < 2000) { ch_printf(ch,"You need 2000 cps to %s an object.\n\r", cmd ); return; } if ( !( pObj = get_obj_carry( ch, command ) ) ) { send_to_char("You don't have that obj.\n\r", ch ); return; } if ( !IS_IMMORTAL(ch) && IS_SET(pObj->quest, QUEST_RELIC)) { send_to_char("Not on a relic.\n\r",ch); return; } if ( !IS_IMMORTAL(ch) && IS_SET(pObj->quest, QUEST_ARTIFACT)) { send_to_char("Not on an Artifact.\n\r",ch); return; } ch->desc->pEdit = (void *)pObj; ch->desc->editor = ED_RENAME; rename_show( ch, "" ); send_to_char( "Type 'commands' to get help.\n\r",ch); return; }