/*___________________________________________________________________________* )()( DalekenMUD 1.12 (C) 2000 )()( `][' by Martin Thomson, Lee Brooks, `][' || Ken Herbert and David Jacques || || ----------------------------------------------------------------- || || Envy Diku Mud improvements copyright (C) 1994 by Michael Quan, || || David Love, Guilherme 'Willie' Arnold, and Mitchell Tse. || || Merc Diku Mud improvments copyright (C) 1992, 1993 by Michael || || Chastain, Michael Quan, and Mitchell Tse. || || Original Diku Mud copyright (C) 1990, 1991 || || by Sebastian Hammer, Michael Seifert, Hans Henrik St{rfeldt, || || Tom Madsen, and Katja Nyboe. || || ----------------------------------------------------------------- || || Any use of this software must follow the licenses of the || || creators. Much time and thought has gone into this software and || || you are benefitting. We hope that you share your changes too. || || What goes around, comes around. || || ----------------------------------------------------------------- || || olc_misc.c || || Miscellaneous OLC code. || *_/<>\_________________________________________________________________/<>\_*/ #include <limits.h> /* OLC 1.1b */ #include "mud.h" #include "olc.h" #if defined( unix ) #include <unistd.h> #endif #ifndef INT_MAX #define INT_MAX 65536 #endif void show_liqlist args( ( CHAR_DATA *ch ) ); bool show_version( CHAR_DATA *ch, const char *argument ) { send_to_char( VERSION, ch ); send_to_char( "\n\r", ch ); send_to_char( AUTHOR, ch ); send_to_char( "\n\r", ch ); send_to_char( DATE, ch ); send_to_char( "\n\r", ch ); send_to_char( CREDITS, ch ); send_to_char( "\n\r", ch ); return FALSE; } /***************************************************************************** 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; } /***************************************************************************** Name: show_spec_cmds Purpose: Displays settable special functions. Called by: show_help( olc_act.c ). ****************************************************************************/ void show_spec_cmds( CHAR_DATA *ch ) { char buf[MAX_STRING_LENGTH]; char buf1[MAX_STRING_LENGTH]; int spec; int col; buf1[0] = '\0'; col = 0; send_to_char( "Preceed special functions with 'spec_'\n\r\n\r", ch ); for( spec = 0; *spec_table[spec].spec_fun; spec++ ) { if( !str_prefix( "spec_", spec_table[spec].spec_name ) ) sprintf( buf, "%-25.24s", &spec_table[spec].spec_name[5] ); else sprintf( buf, "%-25.24s", spec_table[spec].spec_name ); strcat( buf1, buf ); if( ++col % 3 == 0 ) strcat( buf1, "\n\r" ); } if( col % 3 != 0 ) strcat( buf1, "\n\r" ); send_to_char( buf1, ch ); return; } void show_liqlist( CHAR_DATA *ch ) { int liq; BUFFER *buf = buffer_new( MAX_INPUT_LENGTH ); char tmp[MAX_INPUT_LENGTH]; for( liq = 0; liq_table[liq].liq_name != NULL; liq++ ) { if( liq == 0 ) buffer_strcat( buf, "&bName Color Proof Full Thirst&n\n\r" ); bprintf( buf, "&g%-20.20s %s&g %4d %4d %5d&n\n\r", liq_table[liq].liq_name, colour_strpad( tmp, liq_table[liq].liq_color, 14 ), liq_table[liq].liq_affect[0], liq_table[liq].liq_affect[1], liq_table[liq].liq_affect[2] ); } send_to_char( buf->data, ch ); buffer_free( buf ); return; } void do_flaglookup( CHAR_DATA *ch, const char *argument ) { CHAR_DATA *rch; rch = get_char( ch ); if( !authorized( rch, "flaglookup" ) ) return; show_help( ch, argument ); } /***************************************************************************** Name: show_help Purpose: Displays help for many tables used in OLC. Called by: olc interpreters. ****************************************************************************/ bool show_help( CHAR_DATA *ch, const char *argument ) { BUFFER *buf; 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' ) { buf = buffer_new( MAX_STRING_LENGTH ); buffer_strcat( buf, "Syntax: ? [command]\n\r\n\r" ); buffer_strcat( buf, "[command] [description]\n\r" ); for( cnt = 0; bit_table[cnt].command[0] != '\0'; cnt++ ) { if( !IS_SET( bit_table[cnt].flags, BIT_INVISIBLE ) ) bprintf( buf, "%-10.10s -%s\n\r", capitalize( bit_table[cnt].command ), bit_table[cnt].desc ); } send_to_char( buf->data, ch ); buffer_free( buf ); return FALSE; } /* * Find the command, show changeable data. * --------------------------------------- */ for( cnt = 0; *bit_table[cnt].command; cnt++ ) { if( arg[0] == bit_table[cnt].command[0] && !str_prefix( arg, bit_table[cnt].command ) ) { if( !str_cmp( bit_table[cnt].command, "spec" ) ) { show_spec_cmds( ch ); return FALSE; } else if( !str_cmp( bit_table[cnt].command, "liquid" ) ) { show_liqlist( ch ); return FALSE; } else if( !str_cmp( bit_table[cnt].command, "spells" ) ) { 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, bit_table[cnt].structure ); return FALSE; } } } show_help( ch, "" ); return FALSE; } bool sedit_create( CHAR_DATA *ch, const char *argument ) { SOCIAL_DATA *pSocial; char buf[MAX_INPUT_LENGTH]; char *p; strcpy( buf, argument ); for( p = &buf[0]; p && *p; ++p ) *p = LOWER( *p ); pSocial = new_social( buf ); ch->desc->pEdit = (void *)pSocial; wiznetf( ch, WIZ_CREATE, get_trust( ch ), "%s has created a social %s.", ch->name, pSocial->name ); send_to_char( "SEdit: Social created.\n\r", ch ); if( strchr( buf, ' ' ) ) send_to_char( "Be careful with spaces, " "they might stuff you up here.\n\r", ch ); return TRUE; } bool sedit_show( CHAR_DATA *ch, const char *argument ) { SOCIAL_DATA *pSocial; BUFFER *buf = buffer_new( MAX_INPUT_LENGTH ); EDIT_SOCIAL( ch, pSocial ); bprintf( buf, "&gName &b[&c%s&b]&n\n\r", pSocial->name ); bprintf( buf, "&gChar_No_Arg: &w%s&n\n\r", pSocial->char_no_arg ); bprintf( buf, "&gOthers_No_Arg:&w%s&n\n\r", pSocial->others_no_arg ); bprintf( buf, "&gChar_Found: &w%s&n\n\r", pSocial->char_found ); bprintf( buf, "&gOthers_Found: &w%s&n\n\r", pSocial->others_found ); bprintf( buf, "&gVictim_Found: &w%s&n\n\r", pSocial->vict_found ); bprintf( buf, "&gChar_Auto: &w%s&n\n\r", pSocial->char_auto ); bprintf( buf, "&gOthers_Auto: &w%s&n\n\r", pSocial->others_auto ); send_to_char( buf->data, ch ); buffer_free( buf ); return FALSE; } bool sedit_name( CHAR_DATA *ch, const char *argument ) { SOCIAL_DATA *pSocial; EDIT_SOCIAL( ch, pSocial ); if( argument[0] == '\0' ) { send_to_char( "Syntax: name <$name>\n\r", ch ); return FALSE; } free_string( pSocial->name ); pSocial->name = str_dup( argument ); send_to_char( "Name set.\n\r", ch ); return FALSE; } bool sedit_change( CHAR_DATA *ch, const char *argument, char **which, bool hasvict ) { char const *legal = "nNeEmMsSgGoO%$"; const char *p; if( !hasvict ) legal = "nemsgo%$"; for( p = strchr( argument, '$' ); p && *p; p = strchr( p, '$' ) ) { p++; if( !*p || !strchr( legal, *p ) ) { send_to_char( "Illegal act string.\n\r", ch ); return FALSE; } } free_string( *which ); *which = str_dup( argument ); send_to_char( "Value set.\n\r", ch ); return TRUE; } bool sedit_cna( CHAR_DATA *ch, const char *argument ) { SOCIAL_DATA *pSocial; EDIT_SOCIAL( ch, pSocial ); if( argument[0] == '\0' ) { send_to_char( "Syntax: cna <$char no arg>\n\r", ch ); return FALSE; } return sedit_change( ch, argument, &pSocial->char_no_arg, FALSE ); } bool sedit_ona( CHAR_DATA *ch, const char *argument ) { SOCIAL_DATA *pSocial; EDIT_SOCIAL( ch, pSocial ); if( argument[0] == '\0' ) { send_to_char( "Syntax: ona <$others no arg>\n\r", ch ); return FALSE; } return sedit_change( ch, argument, &pSocial->others_no_arg, FALSE ); } bool sedit_cf( CHAR_DATA *ch, const char *argument ) { SOCIAL_DATA *pSocial; EDIT_SOCIAL( ch, pSocial ); if( argument[0] == '\0' ) { send_to_char( "Syntax: cf <$char found>\n\r", ch ); return FALSE; } return sedit_change( ch, argument, &pSocial->char_found, TRUE ); } bool sedit_of( CHAR_DATA *ch, const char *argument ) { SOCIAL_DATA *pSocial; EDIT_SOCIAL( ch, pSocial ); if( argument[0] == '\0' ) { send_to_char( "Syntax: of <$others found>\n\r", ch ); return FALSE; } return sedit_change( ch, argument, &pSocial->others_found, TRUE ); } bool sedit_vf( CHAR_DATA *ch, const char *argument ) { SOCIAL_DATA *pSocial; EDIT_SOCIAL( ch, pSocial ); if( argument[0] == '\0' ) { send_to_char( "Syntax: vf <$victim found>\n\r", ch ); return FALSE; } return sedit_change( ch, argument, &pSocial->vict_found, TRUE ); } bool sedit_ca( CHAR_DATA *ch, const char *argument ) { SOCIAL_DATA *pSocial; EDIT_SOCIAL( ch, pSocial ); if( argument[0] == '\0' ) { send_to_char( "Syntax: ca <$char auto>\n\r", ch ); return FALSE; } return sedit_change( ch, argument, &pSocial->char_auto, FALSE ); } bool sedit_oa( CHAR_DATA *ch, const char *argument ) { SOCIAL_DATA *pSocial; EDIT_SOCIAL( ch, pSocial ); if( argument[0] == '\0' ) { send_to_char( "Syntax: oa <$others auto>\n\r", ch ); return FALSE; } return sedit_change( ch, argument, &pSocial->others_auto, FALSE ); } bool hedit_create( CHAR_DATA *ch, const char *argument ) { HELP_DATA *pHelp; AREA_DATA *pArea; char arg[MAX_INPUT_LENGTH]; char buf[MAX_STRING_LENGTH]; pArea = ch->in_room->area; if( !IS_BUILDER( ch, pArea ) ) { send_to_char( "SEdit: You can't edit this area.\n\r", ch ); return FALSE; } argument = one_argument( argument, arg ); if( argument[0] == '\0' || arg[0] == 0 || !is_number( arg ) ) { send_to_char( "Syntax: create <#level> <keyword(s)>\n\r", ch ); return FALSE; } pHelp = new_help( ); pHelp->area = pArea; pHelp->level = atoi( arg ); pHelp->keyword = str_dup( all_capitalize( buf, argument ) ); pHelp->text = str_dup( "" ); ch->desc->pEdit = (void *)pHelp; ch->desc->interpreter = get_interpreter( "HEdit" ); wiznetf( ch, WIZ_CREATE, get_trust( ch ), "%s has created a new help %s.", ch->name, pHelp->keyword ); send_to_char( "HEdit: New help created.\n\r", ch ); hedit_show( ch, "" ); return TRUE; } bool hedit_keyword( CHAR_DATA *ch, const char *argument ) { HELP_DATA *pHelp; char buf[MAX_INPUT_LENGTH]; char *p; EDIT_HELP( ch, pHelp ); if( argument[0] == '\0' ) { send_to_char( "Syntax: keyword <$keywords>\n\r", ch ); return FALSE; } strcpy( buf, argument ); for( p = &buf[0]; *p; ++p ) *p = UPPER( *p ); free_string( pHelp->keyword ); pHelp->keyword = str_dup( buf ); send_to_char( "Keyword(s) set.\n\r", ch ); return TRUE; } bool hedit_trust( CHAR_DATA *ch, const char *argument ) { HELP_DATA *pHelp; EDIT_HELP( ch, pHelp ); if( argument[0] == '\0' || !is_number( argument ) ) { send_to_char( "Syntax: trust <#level>\n\r", ch ); return FALSE; } pHelp->level = atoi( argument ); send_to_char( "Trust level set.\n\r", ch ); return TRUE; } bool hedit_text( CHAR_DATA *ch, const char *argument ) { HELP_DATA *pHelp; EDIT_HELP( ch, pHelp ); if( argument[0] == '\0' ) { string_edit( ch, &pHelp->text ); return TRUE; } send_to_char( "Syntax: text - line edit\n\r", ch ); return FALSE; } bool hedit_show( CHAR_DATA *ch, const char *argument ) { HELP_DATA *pHelp; BUFFER *buf = buffer_new( MAX_STRING_LENGTH ); EDIT_HELP( ch, pHelp ); bprintf( buf, "&gKeyword(s): &b[&c%s&b]&n\n\r", pHelp->keyword ); bprintf( buf, "&gArea: &b[&c%4d&b]&m %s&n\n\r", !pHelp->area ? -1 : pHelp->area->vnum, !pHelp->area ? "No Area" : pHelp->area->name ); bprintf( buf, "&gLevel: &b[&c%4d&b]&n\n\r" "&gText:\n\r&w", pHelp->level ); if( *pHelp->text == '.' ) buffer_strcat( buf, pHelp->text + 1 ); else buffer_strcat( buf, pHelp->text ); send_to_char( buf->data, ch ); send_to_char( "&n", ch ); buffer_free( buf ); return FALSE; } bool hedit_harea( CHAR_DATA *ch, const char *argument ) { HELP_DATA *pHelp; AREA_DATA *pArea; EDIT_HELP( ch, pHelp ); if( argument[0] == '\0' || !is_number( argument ) ) { send_to_char( "Syntax: harea <#areavnum>\n\r", ch ); return FALSE; } pArea = get_area_data( atoi( argument ) ); if( !pArea ) { send_to_char( "No area there.\n\r", ch ); return FALSE; } if( !IS_BUILDER( ch, pArea ) ) { send_to_char( "You can build that area.\n\r", ch ); return FALSE; } pHelp->area = pArea; SET_BIT( pArea->area_flags, AREA_CHANGED ); send_to_char( "HEdit: Help area set.\n\r", ch ); return TRUE; } bool hedit_hlist( CHAR_DATA *ch, const char *argument ) { HELP_DATA *pHelp; AREA_DATA *pArea; char buf[MAX_STRING_LENGTH]; char buf1[MAX_STRING_LENGTH * 4]; bool fAll = FALSE; EDIT_HELP( ch, pHelp ); pArea = pHelp->area; if( !str_cmp( argument, "all" ) ) { fAll = TRUE; } buf1[0] = '\0'; for( pHelp = help_first; pHelp; pHelp = pHelp->next ) { if( pHelp->level > get_trust( ch ) ) continue; if( !fAll && pHelp->area != pArea ) continue; sprintf( buf, ">%s\n\r", pHelp->keyword ); strcat( buf1, buf ); } send_to_char( buf1, ch ); return FALSE; } void display_resets( CHAR_DATA *ch ) { ROOM_INDEX_DATA *pRoom; RESET_DATA *pReset; MOB_INDEX_DATA *pMob = NULL; BUFFER *final = buffer_new( MAX_STRING_LENGTH ); char tmp[MAX_INPUT_LENGTH]; int iReset = 0; EDIT_ROOM( ch, pRoom ); buffer_strcat( final, " &gNo. Loads Description Location Vnum Max Description&n\n\r" "&B==== ======== ============= =================== ======== ===== ===============&n\n\r" ); for( pReset = pRoom->reset_first; pReset; pReset = pReset->next ) { OBJ_INDEX_DATA *pObj; MOB_INDEX_DATA *pMobIndex; OBJ_INDEX_DATA *pObjIndex; OBJ_INDEX_DATA *pObjToIndex; int save_pos; bprintf( final, "&b[&r%2d&b] ", ++iReset ); save_pos = final->len; switch( pReset->command ) { default: bprintf( final, "&RBad reset command: %c.", pReset->command ); break; case 'M': if( !( pMobIndex = get_mob_index( pReset->arg1 ) ) ) { bprintf( final, "&RLoad Mobile - Bad Mob %d&n\n\r", pReset->arg1 ); continue; } pMob = pMobIndex; bprintf( final, "&cM&b[&r%5d&b] &g%s &win room ", pReset->arg1, colour_strpad( tmp, pMob->short_descr, 13 ) ); bprintf( final, "&cR&b[&r%5d&b] [&r%3d&b] &y%s&n\n\r", pRoom->vnum, pReset->arg2, colour_strpad( tmp, pRoom->name, 15 ) ); /* * Check for pet shop, change 'M' to 'P' */ { ROOM_INDEX_DATA *pRoomIndexPrev; pRoomIndexPrev = get_room_index( pRoom->vnum - 1 ); if( pRoomIndexPrev && IS_SET( pRoomIndexPrev->room_flags, ROOM_PET_SHOP ) ) final->data[save_pos + 2] = 'P'; } break; case 'O': if( !( pObjIndex = get_obj_index( pReset->arg1 ) ) ) { bprintf( final, "&RLoad Object - Bad Object %d&n\n\r", pReset->arg1 ); continue; } pObj = pObjIndex; bprintf( final, "&cO&b[&r%5d&b] &g%s &win room ", pReset->arg1, colour_strpad( tmp, pObj->short_descr, 13 ) ); bprintf( final, "&cR&b[&r%5d&b] &y%s&n\n\r", pRoom->vnum, colour_strpad( tmp, pRoom->name, 15 ) ); break; case 'P': if( !( pObjIndex = get_obj_index( pReset->arg1 ) ) ) { bprintf( final, "&RPut Object - Bad Object %d&n\n\r", pReset->arg1 ); continue; } pObj = pObjIndex; if( !( pObjToIndex = get_obj_index( pReset->arg2 ) ) ) { bprintf( final, "&RPut Object - Bad To Object %d&n\n\r", pReset->arg2 ); continue; } bprintf( final, "&cO&b[&r%5d&b] &g%s &winside ", pReset->arg1, colour_strpad( tmp, pObj->short_descr, 13 ) ); bprintf( final, "&cO&b[&r%5d&b] &g%s&n\n\r", pReset->arg2, colour_strpad( tmp, pObjToIndex->short_descr, 15 ) ); break; case 'G': case 'E': if( !( pObjIndex = get_obj_index( pReset->arg1 ) ) ) { bprintf( final, "&RGive/Equip Object - Bad Object %d&n\n\r", pReset->arg1 ); continue; } pObj = pObjIndex; if( !pMob ) { bprintf( final, "&RGive/Equip Object - No Previous Mobile&n\n\r" ); break; } bprintf( final, "&cO&b[&r%5d&b] &g%s &w%-19.19s ", pReset->arg1, colour_strpad( tmp, pObj->short_descr, 13 ), ( pReset->command == 'G' ) ? wear_loc_strings[0].name : flag_string( wear_loc_strings, &pReset->arg2 ) ); bprintf( final, "&c%c&b[&r%5d&b] &g%s&n\n\r", pMob->pShop ? 'S' : 'M', pMob->vnum, colour_strpad( tmp, pMob->short_descr, 15 ) ); 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': pRoom = get_room_index( pReset->arg1 ); bprintf( final, "&cR&b[&r%5d&b] &g%s &wdoor of %s reset to %s&n\n\r", pReset->arg1, capitalize( dir_name[ pReset->arg2 ] ), colour_strpad( tmp, pRoom->name, 19 ), flag_string( door_resets, &pReset->arg3 ) ); break; * * End Doors Comment. */ case 'R': if( pReset->arg1 != 0 ) bprintf( final, "&cR&b[&r%5d&b] &g%d &wExits are randomized in &y%s&n\n\r", pRoom->vnum, pReset->arg1, pRoom->name ); else bprintf( final, "&cR&b[&r%5d&b] Exits &g%s&w are randomized in &y%s&n\n\r", pRoom->vnum, flag_string( direction_flags, &pReset->arg2 ), pRoom->name ); break; } } send_to_char( final->data, ch ); buffer_free( final ); return; } /***************************************************************************** Name: add_reset Purpose: Inserts a new reset in the given index slot. Called by: do_resets( olc.c ). ****************************************************************************/ 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; SET_BIT( room->area->area_flags, AREA_CHANGED ); return; } void do_resets( CHAR_DATA *ch, const 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; CHAR_DATA *rch; rch = get_char( ch ); if( !authorized( rch, "resets" ) ) return; if( !IS_BUILDER( ch, ch->in_room->area ) ) { send_to_char( "Resets: Invalid security for editing this area.\n\r", ch ); return; } 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 ); /* * Display resets in current room. * ------------------------------- */ if( arg1[0] == '\0' ) { if( ch->in_room->reset_first ) { send_to_char( "&gResets: &cM&g = mobile, &cR&g = room, &cO&g = object, " "&cP&g = pet, &cS&g = shopkeeper&n\n\r", ch ); display_resets( ch ); } else send_to_char( "No resets in this room.\n\r", ch ); } /* * 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 area.\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 ); SET_BIT( pRoom->area->area_flags, AREA_CHANGED ); send_to_char( "Reset deleted.\n\r", ch ); } else /* * Add a reset. * ------------ */ if( ( !str_cmp( arg2, "mob" ) && is_number( arg3 ) ) || ( !str_cmp( arg2, "obj" ) && is_number( arg3 ) ) || ( !str_prefix( "rand", arg2 ) ) ) { /* * Check for Mobile reset. * ----------------------- */ if( !str_cmp( arg2, "mob" ) ) { pReset = new_reset_data( ); pReset->command = 'M'; pReset->arg1 = atoi( arg3 ); pReset->arg2 = is_number( arg4 ) ? atoi( arg4 ) : 1; /* Max # */ } else /* * Check for Object reset. * ----------------------- */ if( !str_cmp( arg2, "obj" ) ) { pReset = new_reset_data( ); if( is_number( arg3 ) ) pReset->arg1 = atoi( arg3 ); else { do_resets( ch, "1 ?" ); free_reset_data( pReset ); return; } /* * Inside another object. * ---------------------- */ if( !str_prefix( arg4, "inside" ) ) { pReset->command = 'P'; pReset->arg2 = is_number( arg5 ) ? atoi( arg5 ) : 1; } else /* * Inside the room. * ---------------- */ if( !str_cmp( arg4, "room" ) ) { pReset->command = 'O'; pReset->arg1 = atoi( arg3 ); pReset->arg2 = 0; } else /* * Into a Mobile's inventory. * -------------------------- */ { if( flag_value( NULL, wear_loc_flags, arg4 ) == NO_FLAG ) { send_to_char( "Resets: '? wear-loc'\n\r", ch ); free_reset_data( pReset ); return; } pReset->arg2 = flag_value( NULL, wear_loc_flags, arg4 ); if( pReset->arg2 == WEAR_NONE ) pReset->command = 'G'; else pReset->command = 'E'; } } else if( !str_prefix( "rand", arg2 ) ) { pReset = new_reset_data( ); pReset->command = 'R'; pReset->arg1 = ( arg3[0] != '\0' && is_number( arg3 ) ) ? atoi( arg3 ) : 6; if( pReset->arg1 == 0 ) { sprintf( arg3, "%s %s %s", arg4, arg5, argument ); if( arg4[0] == '\0' || flag_value( NULL, direction_flags, arg3 ) == NO_FLAG ) { send_to_char( "Usage reset <num> rand 0 <directions>\n\r", ch ); free_reset_data( pReset ); return; } pReset->arg2 = flag_value( NULL, direction_flags, arg3 ); } } add_reset( ch->in_room, pReset, atoi( arg1 ) ); send_to_char( "Reset added.\n\r", ch ); } else { send_to_char( "Syntax: RESET <number> OBJ <vnum> <wear_loc>\n\r" " RESET <number> OBJ <vnum> in <vnum>\n\r" " RESET <number> OBJ <vnum> room\n\r" " RESET <number> MOB <vnum> [<max #>]\n\r" " RESET <number> RANDOMIZE <num>\n\r" " RESET <number> DELETE\n\r", ch ); } } return; } /***************************************************************************** Name: do_alist Purpose: Normal command to list areas and display area information. Called by: interpreter( interp.c ) ****************************************************************************/ void do_alist( CHAR_DATA *ch, const char *argument ) { BUFFER *result = buffer_new( MAX_STRING_LENGTH * 2 ); AREA_DATA *pArea; CHAR_DATA *rch; char tmp[MAX_INPUT_LENGTH]; rch = get_char( ch ); if( !authorized( rch, "alist" ) ) return; bprintf( result, "&b[&r%3s&b] [&m%-27s&b] &b(&c%-5s&b-&c%5s&b)" " [&c%-10s&b] &r%3s&b[&g%-11s&b]&n\n\r", "Num", "Area Name", "lvnum", "uvnum", "Filename", "Sec", "Builders" ); for( pArea = area_first; pArea; pArea = pArea->next ) { bprintf( result, "&b[&r%3d&b]&m %s &b(&c%-5d&b-&c%5d&b)", pArea->vnum, colour_strpad( tmp, pArea->name, 29 ), pArea->lvnum, pArea->uvnum ); bprintf( result, "&c %s &b[&r%d&b]", colour_strpad( tmp, pArea->filename, 12 ), pArea->security ); bprintf( result, "[&g%s&b]&n\n\r", colour_strpad( tmp, pArea->builders, 11 ) ); } send_to_char( result->data, ch ); buffer_free( result ); return; } /* =========================================================================== This snippet was written by Erwin S. Andreasen, erwin@pip.dknet.dk. You may use this code freely, as long as you retain my name in all of the files. You also have to mail me telling that you are using it. I am giving this, hopefully useful, piece of source code to you for free, and all I require from you is some feedback. Please mail me if you find any bugs or have any new ideas or just comments. All my snippets are publically available at: http://pip.dknet.dk/~pip1773/ If you do not have WWW access, try ftp'ing to pip.dknet.dk and examine the /pub/pip1773 directory. =========================================================================== */ typedef enum { exit_from, exit_to, exit_both } exit_status; /* depending on status print > or < or <> between the 2 rooms */ void room_pair( ROOM_INDEX_DATA* left, ROOM_INDEX_DATA* right, exit_status ex, BUFFER *buf ) { const char *sExit; char tmp[MAX_INPUT_LENGTH]; switch( ex ) { default: sExit = "??"; break; /* invalid usage */ case exit_from: sExit = "< "; break; case exit_to: sExit = " >"; break; case exit_both: sExit = "<>"; break; } bprintf( buf, "&g%5d %s &c%s", left->vnum, colour_strpad( tmp, left->name, 24 ), sExit ); bprintf( buf, "&g %5d %s", right->vnum, colour_strpad( tmp, right->name, 24 ) ); bprintf( buf, "(%s)\n\r", colour_strpad( tmp, right->area->name, 12 ) ); } /* * for every exit in 'room' which leads to or from pArea but NOT both, print it */ void checkexits( ROOM_INDEX_DATA *room, AREA_DATA *pArea, BUFFER *buf ) { int i; EXIT_DATA *exit; ROOM_INDEX_DATA *to_room; for( i = 0; i < 6; i++ ) { exit = room->exit[i]; if( !exit ) continue; else to_room = exit->to_room; if( to_room ) /* there is something on the other side */ { if( ( room->area == pArea ) && ( to_room->area != pArea ) ) { /* * an exit from our area to another area * check first if it is a two-way exit */ if( to_room->exit[rev_dir[i]] && to_room->exit[rev_dir[i]]->to_room == room ) room_pair( room, to_room, exit_both, buf ); else room_pair( room, to_room, exit_to, buf ); } else if( ( room->area != pArea ) && ( exit->to_room->area == pArea ) ) { /* * an exit from another area to our area * note that the twoway exits are taken care of above */ if( !( to_room->exit[rev_dir[i]] && to_room->exit[rev_dir[i]]->to_room == room ) ) room_pair( to_room, room, exit_from, buf ); } } } return; } void do_exlist( CHAR_DATA *ch, const char *argument ) { CHAR_DATA *rch = get_char( ch ); AREA_DATA *pArea; ROOM_INDEX_DATA *room; int i; BUFFER *buf = buffer_new( MAX_STRING_LENGTH ); if( !authorized( rch, "exlist" ) ) return; if( !str_cmp( argument, "area" ) ) { pArea = get_editing_area( ch ); } else if( is_number( argument ) ) { pArea = get_area_data( atoi( argument ) ); } else pArea = ch->in_room->area; /* this is the area we want info on */ if( !IS_BUILDER( ch, pArea ) ) { send_to_char( "You are not a builder for this area.\n\r", ch ); return; } /* * Run through every room on the entire MUD */ for( i = 0; i < MAX_KEY_HASH; i++ ) for( room = room_index_hash[i]; room != NULL; room = room->next ) checkexits( room, pArea, buf ); buffer_strcat( buf, "&n" ); send_to_char( buf->data, ch ); buffer_free( buf ); } void do_poseset( CHAR_DATA *ch, const char *argument ) { char arg1[MAX_INPUT_LENGTH]; char arg2[MAX_INPUT_LENGTH]; int i; POSE_DATA *pose; CHAR_DATA *rch = get_char( ch ); if( !authorized( rch, "poseset" ) ) return; argument = one_argument( argument, arg1 ); argument = one_argument( argument, arg2 ); if( !str_prefix( arg1, "show" ) ) { BUFFER * buf; int start, num, end; if( !str_prefix( arg2, "table" ) ) { buf = buffer_new( MAX_INPUT_LENGTH ); buffer_strcat( buf, "Pose statistics for all classes.\n\r" ); buffer_strcat( buf, "[Class ] [#] [Class ] [#]\n\r" ); buffer_strcat( buf, "==================== ====================\n\r" ); for( i = 0; i < MAX_CLASS; ++i ) { bprintf( buf, "%-15s %4d", class_table[i].name, pose_table[i].size ); if( i % 2 ) buffer_strcat( buf, "\n\r" ); else buffer_strcat( buf, " " ); } if( i % 2 ) buffer_strcat( buf, "\n\r" ); buffer_strcat( buf, "==================== ====================\n\r" ); send_to_char( buf->data, ch ); buffer_free( buf ); return; } for( i = 0; i < MAX_CLASS; ++i ) if( !str_cmp( arg2, class_table[i].who_name ) || !str_prefix( arg2, class_table[i].name ) ) break; if( i >= MAX_CLASS ) { send_to_char( "That class doesn't exist.\n\r", ch ); return; } argument = one_argument( argument, arg1 ); if( !is_number( arg1 ) ) { send_to_char( "Please specify the number of a pose to show.\n\r", ch ); return; } start = atoi( arg1 ); num = start; for( pose = pose_table[i].first; pose; pose = pose->next ) if( --num <= 0 ) break; if( !pose ) { send_to_char( "That pose wasn't found.\n\r", ch ); return; } if( is_number( argument ) ) end = atoi( argument ); else end = start; if( end < start || end - start > 50 ) { send_to_char( "Usage: poseset show <class> <start#> <end#>\n\r", ch ); return; } buf = buffer_new( MAX_INPUT_LENGTH ); for( num = 0; pose && num <= end - start; num++ ) { bprintf( buf, "Pose number %d for the %s class:\n\r", start + num, class_table[i].name ); bprintf( buf, " TO_CHAR: %s\n\r", pose->to_char ); bprintf( buf, " TO_ROOM: %s\n\r", pose->to_room ); pose = pose->next; } send_to_char( buf->data, ch ); buffer_free( buf ); return; } if( !str_prefix( arg1, "edit" ) ) { int which; for( i = 0; i < MAX_CLASS; ++i ) if( !str_cmp( arg2, class_table[i].who_name ) || !str_prefix( arg2, class_table[i].name ) ) break; if( i >= MAX_CLASS ) { send_to_char( "That class doesn't exist.\n\r", ch ); return; } if( !is_number( argument ) ) { send_to_char( "Please specify the number of a pose to show.\n\r", ch ); return; } which = atoi( argument ); for( pose = pose_table[i].first; pose; pose = pose->next ) if( --which <= 0 ) break; if( !pose ) { send_to_char( "That pose wasn't found.\n\r", ch ); return; } ch->desc->pEdit = pose; ch->desc->interpreter = get_interpreter( "PoseEdit" ); poseedit_show( ch, "" ); return; } if( !str_prefix( arg1, "create" ) ) { if( poseedit_create( ch, arg2 ) ) ch->desc->interpreter = get_interpreter( "PoseEdit" ); return; } do_help( ch, "poseset" ); return; } bool poseedit_create( CHAR_DATA *ch, const char *argument ) { int i; POSE_DATA *pose; if( argument[0] == '\0' ) { send_to_char( "Usage: create <class-name>\n\r", ch ); return FALSE; } for( i = 0; i < MAX_CLASS; ++i ) if( !str_cmp( argument, class_table[i].who_name ) || !str_prefix( argument, class_table[i].name ) ) break; if( i >= MAX_CLASS ) { send_to_char( "Usage: create <class-name>\n\r", ch ); return FALSE; } pose = new_pose_data( ); pose->next = pose_table[i].first; pose_table[i].first = pose; pose_table[i].size++; ch->desc->pEdit = pose; ch->desc->interpreter = get_interpreter( "PoseEdit" ); return TRUE; } bool poseedit_show( CHAR_DATA *ch, const char *argument ) { POSE_DATA *pPose; EDIT_POSE( ch, pPose ); charprintf( ch, "TO_CHAR: %s\n\r", pPose->to_char ); charprintf( ch, "TO_ROOM: %s\n\r", pPose->to_room ); return FALSE; } bool poseedit_tochar( CHAR_DATA *ch, const char *argument ) { POSE_DATA *pPose; EDIT_POSE( ch, pPose ); if( argument[0] == '\0' ) { send_to_char( "Syntax: tochar <$message>\n\r", ch ); return FALSE; } return sedit_change( ch, argument, &pPose->to_char, FALSE ); } bool poseedit_toroom( CHAR_DATA *ch, const char *argument ) { POSE_DATA *pPose; EDIT_POSE( ch, pPose ); if( argument[0] == '\0' ) { send_to_char( "Syntax: toroom <$message>\n\r", ch ); return FALSE; } return sedit_change( ch, argument, &pPose->to_room, FALSE ); } bool pledit_show( CHAR_DATA *ch, const char *argument ) { PLANE_DATA *pPlane; EDIT_PLANE( ch, pPlane ); charprintf( ch, "&gPlane: &b[&c%s&b]&n\n\r", pPlane->name ); charprintf( ch, "&gMinimum Lvl: &b[&c%d&b]&n\n\r", pPlane->min_level ); return FALSE; } bool pledit_create( CHAR_DATA *ch, const char *argument ) { PLANE_DATA *pPlane; if( argument[0] == '\0' ) { send_to_char( "Syntax: create <plane name>\n\r", ch ); return FALSE; } pPlane = new_plane( ); pPlane->name = str_dup( argument ); ch->desc->pEdit = pPlane; ch->desc->interpreter = get_interpreter( "PlEdit" ); send_to_char( "PlEdit: Plane created.\n\r", ch ); return TRUE; } bool pledit_minimum( CHAR_DATA *ch, const char *argument ) { PLANE_DATA *pPlane; EDIT_PLANE( ch, pPlane ); if( argument[0] == '\0' || !is_number( argument ) ) { send_to_char( "Syntax: minimum <#min>\n\r", ch ); return FALSE; } pPlane->min_level = atoi( argument ); send_to_char( "PlEdit: Plane minimum level set.\n\r", ch ); return FALSE; } bool pledit_name( CHAR_DATA *ch, const char *argument ) { PLANE_DATA *pPlane; EDIT_PLANE( ch, pPlane ); if( argument[0] == '\0' ) { send_to_char( "Syntax: name <$plane name>\n\r", ch ); return FALSE; } free_string( pPlane->name ); pPlane->name = str_dup( argument ); send_to_char( "PlEdit: Plane name set.\n\r", ch ); return FALSE; }