/*************************************************************************** * File: olc_act.c * * * * Much time and thought has gone into this software and you are * * benefitting. We hope that you share your changes too. What goes * * around, comes around. * * * * This code was freely distributed with the The Isles 1.1 source code, * * and has been used here for OLC - OLC would not be what it is without * * all the previous coders who released their source code. * * * ***************************************************************************/ #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 <time.h> #include <math.h> #include "include.h" char * prog_type_to_name ( int type ); #define ALT_FLAGVALUE_SET( _blargh, _table, _arg ) \ { \ int blah = flag_value( _table, _arg ); \ _blargh = (blah == NO_FLAG) ? 0 : blah; \ } #define ALT_FLAGVALUE_TOGGLE( _blargh, _table, _arg ) \ { \ int blah = flag_value( _table, _arg ); \ _blargh ^= (blah == NO_FLAG) ? 0 : blah; \ } /* Return TRUE if area changed, FALSE if not. */ #define REDIT( fun ) bool fun( CHAR_DATA *ch, char *argument ) #define OEDIT( fun ) bool fun( CHAR_DATA *ch, char *argument ) #define MEDIT( fun ) bool fun( CHAR_DATA *ch, char *argument ) #define AEDIT( fun ) bool fun( CHAR_DATA *ch, char *argument ) #define GEDIT( fun ) bool fun( CHAR_DATA *ch, char *argument ) #define SKEDIT(fun ) bool fun( CHAR_DATA *ch, char *argument ) struct olc_help_type { char *command; const void *structure; char *desc; }; bool show_version( CHAR_DATA *ch, 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; } /* * This table contains help commands and a brief description of each. * ------------------------------------------------------------------ */ const struct olc_help_type help_table[] = { { "area", area_flags, "Area attributes." }, { "room", room_flags, "Room attributes." }, { "sector", sector_flags, "Sector types, terrain." }, { "exit", exit_flags, "Exit types." }, { "type", type_flags, "Types of objects." }, { "extra", extra_flags, "Object attributes." }, { "extra2", extra2_flags, "Object2 attributes." }, { "wear", wear_flags, "Where to wear object." }, { "spec", spec_table, "Available special programs." }, { "sex", sex_flags, "Sexes." }, { "act", act_flags, "Mobile attributes." }, { "affect", affect_flags, "Mobile affects." }, { "affect2", affect2_flags, "More mobile affects." }, { "wear-loc", wear_loc_flags, "Where mobile wears object." }, { "container", container_flags, "Container status." }, { "oprog", oprog_flags, "ObjProgram flags." }, { "rprog", rprog_flags, "RoomProgram flags." }, { "guild", guild_flags, "Guild flags." }, /* ROM specific bits: */ { "armor", ac_type, "Ac for different attacks." }, { "apply", apply_flags, "Apply flags" }, { "form", form_flags, "Mobile body form." }, { "part", part_flags, "Mobile body parts." }, { "imm", imm_flags, "Mobile immunity." }, { "res", res_flags, "Mobile resistance." }, { "vuln", vuln_flags, "Mobile vulnerability." }, { "off", off_flags, "Mobile offensive behaviour." }, { "size", size_flags, "Mobile size." }, { "position", position_flags, "Mobile positions." }, { "wclass", weapon_class, "Weapon class." }, { "wtype", weapon_type2, "Special weapon type." }, { "portal", portal_flags, "Portal types." }, { "furniture", furniture_flags, "Furniture types." }, { "liquid", liq_table, "Liquid types." }, { "apptype", apply_types, "Apply types." }, { "weapon", attack_table, "Weapon types." }, { "mprog", mprog_flags, "MobProgram flags." }, { NULL, NULL, NULL } }; /***************************************************************************** Name: show_flag_cmds Purpose: Displays settable flags and stats. Called by: show_help(olc_act.c). ****************************************************************************/ void show_flag_cmds( CHAR_DATA *ch, const struct flag_type *flag_table ) { char buf [ MAX_STRING_LENGTH ]; char buf1 [ MAX_STRING_LENGTH ]; int flag; int col; buf1[0] = '\0'; col = 0; for (flag = 0; flag_table[flag].name != NULL; flag++) { if ( flag_table[flag].settable ) { sprintf( buf, "%-19.18s", flag_table[flag].name ); strcat( buf1, buf ); if ( ++col % 4 == 0 ) strcat( buf1, "\n\r" ); } } if ( col % 4 != 0 ) strcat( buf1, "\n\r" ); 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].function != NULL; spec++) { sprintf( buf, "%-19.18s", &spec_table[spec].name[5] ); strcat( buf1, buf ); if ( ++col % 4 == 0 ) strcat( buf1, "\n\r" ); } if ( col % 4 != 0 ) strcat( buf1, "\n\r" ); send_to_char( buf1, 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 buf[MAX_STRING_LENGTH]; 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 != NULL; cnt++) { sprintf( buf, "%-10.10s -%s\n\r", capitalize( help_table[cnt].command ), help_table[cnt].desc ); send_to_char( buf, ch ); } return FALSE; } /* * Find the command, show changeable data. * --------------------------------------- */ for (cnt = 0; help_table[cnt].command != NULL; cnt++) { if ( arg[0] == help_table[cnt].command[0] && !str_prefix( arg, help_table[cnt].command ) ) { if ( help_table[cnt].structure == spec_table ) { show_spec_cmds( ch ); return FALSE; } else if ( help_table[cnt].structure == liq_table ) { show_liqlist( ch ); return FALSE; } else if ( help_table[cnt].structure == attack_table ) { show_damlist( ch ); return FALSE; } else if ( help_table[cnt].structure == skill_table ) { if ( spell[0] == '\0' ) { 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, (flag_type *)help_table[cnt].structure ); return FALSE; } } } show_help( ch, "" ); return FALSE; } REDIT( redit_rlist ) { ROOM_INDEX_DATA *pRoomIndex; AREA_DATA *pArea; char buf [ MAX_STRING_LENGTH ]; BUFFER *buf1; char arg [ MAX_INPUT_LENGTH ]; bool found; int vnum; int col = 0; one_argument( argument, arg ); pArea = ch->in_room->area; buf1=new_buf(); /* buf1[0] = '\0'; */ found = FALSE; for ( vnum = pArea->min_vnum; vnum <= pArea->max_vnum; vnum++ ) { if ( ( pRoomIndex = get_room_index( vnum ) ) ) { found = TRUE; sprintf( buf, "[%5d] %-17.16s", vnum, capitalize( pRoomIndex->name ) ); add_buf( buf1, buf ); if ( ++col % 3 == 0 ) add_buf( buf1, "\n\r" ); } } if ( !found ) { send_to_char( "Room(s) not found in this area.\n\r", ch); return FALSE; } if ( col % 3 != 0 ) add_buf( buf1, "\n\r" ); page_to_char( buf_string(buf1), ch ); free_buf(buf1); return FALSE; } REDIT( redit_mlist ) { MOB_INDEX_DATA *pMobIndex; AREA_DATA *pArea; char buf [ MAX_STRING_LENGTH ]; BUFFER *buf1; char arg [ MAX_INPUT_LENGTH ]; bool fAll, found; int vnum; int col = 0; one_argument( argument, arg ); if ( arg[0] == '\0' ) { send_to_char( "Syntax: mlist <all/name>\n\r", ch ); return FALSE; } buf1=new_buf(); pArea = ch->in_room->area; /* buf1[0] = '\0'; */ fAll = !str_cmp( arg, "all" ); found = FALSE; for ( vnum = pArea->min_vnum; vnum <= pArea->max_vnum; vnum++ ) { if ( ( pMobIndex = get_mob_index( vnum ) ) != NULL ) { if ( fAll || is_name( arg, pMobIndex->player_name ) ) { found = TRUE; sprintf( buf, "[%5d] %-17.16s", pMobIndex->vnum, capitalize( pMobIndex->short_descr ) ); add_buf( buf1, buf ); if ( ++col % 3 == 0 ) add_buf( buf1, "\n\r" ); } } } if ( !found ) { send_to_char( "Mobile(s) not found in this area.\n\r", ch); return FALSE; } if ( col % 3 != 0 ) add_buf( buf1, "\n\r" ); page_to_char( buf_string(buf1), ch ); free_buf(buf1); return FALSE; } REDIT( redit_olist ) { OBJ_INDEX_DATA *pObjIndex; AREA_DATA *pArea; char buf [ MAX_STRING_LENGTH ]; BUFFER *buf1; char arg [ MAX_INPUT_LENGTH ]; bool fAll, found; int vnum; int col = 0; one_argument( argument, arg ); if ( arg[0] == '\0' ) { send_to_char( "Syntax: olist <all/name/item_type>\n\r", ch ); return FALSE; } pArea = ch->in_room->area; buf1=new_buf(); /* buf1[0] = '\0'; */ fAll = !str_cmp( arg, "all" ); found = FALSE; for ( vnum = pArea->min_vnum; vnum <= pArea->max_vnum; vnum++ ) { if ( ( pObjIndex = get_obj_index( vnum ) ) ) { if ( fAll || is_name( arg, pObjIndex->name ) || flag_value( type_flags, arg ) == pObjIndex->item_type ) { found = TRUE; sprintf( buf, "[%5d] %-17.16s", pObjIndex->vnum, capitalize( pObjIndex->short_descr ) ); add_buf( buf1, buf ); if ( ++col % 3 == 0 ) add_buf( buf1, "\n\r" ); } } } if ( !found ) { send_to_char( "Object(s) not found in this area.\n\r", ch); return FALSE; } if ( col % 3 != 0 ) add_buf( buf1, "\n\r" ); page_to_char( buf_string(buf1), ch ); free_buf(buf1); return FALSE; } REDIT( redit_mshow ) { MOB_INDEX_DATA *pMob; int value; if ( argument[0] == '\0' ) { send_to_char( "Syntax: mshow <vnum>\n\r", ch ); return FALSE; } if ( !is_number( argument ) ) { send_to_char( "REdit: Ingresa un numero.\n\r", ch); return FALSE; } if ( is_number( argument ) ) { value = atoi( argument ); if ( !( pMob = get_mob_index( value ) )) { send_to_char( "REdit: That mobile does not exist.\n\r", ch ); return FALSE; } ch->desc->pEdit = (void *)pMob; } medit_show( ch, argument ); ch->desc->pEdit = (void *)ch->in_room; return FALSE; } REDIT( redit_walkabout ) { if ( argument[0] == '\0' ) { if ( !ch->desc->walkabout ) { ch->desc->walkabout = TRUE; send_to_char("{GWalkabout{x is now turned on.\n\r", ch ); } else { ch->desc->walkabout = FALSE; send_to_char("{RWalkabout{x is now turned off.\n\r", ch ); } } return FALSE; } REDIT( redit_oshow ) { OBJ_INDEX_DATA *pObj; int value; if ( argument[0] == '\0' ) { send_to_char( "Syntax: oshow <vnum>\n\r", ch ); return FALSE; } if ( !is_number( argument ) ) { send_to_char( "REdit: Ingresa un numero.\n\r", ch); return FALSE; } if ( is_number( argument ) ) { value = atoi( argument ); if ( !( pObj = get_obj_index( value ) )) { send_to_char( "REdit: That object does not exist.\n\r", ch ); return FALSE; } ch->desc->pEdit = (void *)pObj; } oedit_show( ch, argument ); ch->desc->pEdit = (void *)ch->in_room; return FALSE; } /***************************************************************************** Name: check_range( lower vnum, upper vnum ) Purpose: Ensures the range spans only one area. Called by: aedit_vnum(olc_act.c). ****************************************************************************/ bool check_range( int lower, int upper ) { AREA_DATA *pArea; int cnt = 0; for ( pArea = area_first; pArea; pArea = pArea->next ) { /* * lower < area < upper */ if ( ( lower <= pArea->min_vnum && pArea->min_vnum <= upper ) || ( lower <= pArea->max_vnum && pArea->max_vnum <= upper ) ) ++cnt; if ( cnt > 1 ) return FALSE; } return TRUE; } AREA_DATA *get_vnum_area( int vnum ) { AREA_DATA *pArea; for ( pArea = area_first; pArea; pArea = pArea->next ) { if ( vnum >= pArea->min_vnum && vnum <= pArea->max_vnum ) return pArea; } return 0; } /* * Area Editor Functions. */ AEDIT( aedit_show ) { AREA_DATA *pArea; char buf [MAX_STRING_LENGTH]; EDIT_AREA(ch, pArea); sprintf( buf, "Name: [%5d] %s\n\r", pArea->vnum, pArea->name ); send_to_char( buf, ch ); #if 0 /* ROM OLC */ sprintf( buf, "Recall : [%5d] %s\n\r", pArea->recall, get_room_index( pArea->recall ) ? get_room_index( pArea->recall )->name : "none" ); send_to_char( buf, ch ); #endif /* ROM */ sprintf( buf, "File: %s\n\r", pArea->file_name ); send_to_char( buf, ch ); sprintf( buf, "Vnums: [%d-%d]\n\r", pArea->min_vnum, pArea->max_vnum ); send_to_char( buf, ch ); sprintf( buf, "Age: [%d]\n\r", pArea->age ); send_to_char( buf, ch ); sprintf( buf, "Players: [%d]\n\r", pArea->nplayer ); send_to_char( buf, ch ); sprintf( buf, "Security: [%d]\n\r", pArea->security ); send_to_char( buf, ch ); sprintf( buf, "Temps: [%d-%d]\n\r", pArea->min_temp, pArea->max_temp ); send_to_char( buf, ch ); sprintf( buf, "Temperat: [%d]\n\r", pArea->temperature ); send_to_char( buf, ch ); sprintf( buf, "Builders: [%s]\n\r", pArea->builders ); send_to_char( buf, ch ); sprintf( buf, "Credits : [%s]\n\r", pArea->credits ); send_to_char( buf, ch ); sprintf( buf, "Repop Message: [%s]\n\r", pArea->repop_msg); send_to_char( buf, ch); sprintf( buf, "Flags: [%s]\n\r", flag_string( area_flags, pArea->area_flags ) ); send_to_char( buf, ch ); printf_to_char( ch, "Music: [%s]\n\r", pArea->soundfile ); printf_to_char(ch, "Continent: [%s]\n\r", cont_table[pArea->continent].name); printf_to_char(ch, "Level: %d-%d\n\r", pArea->min_lev, pArea->max_lev ); return FALSE; } AEDIT( aedit_reset ) { AREA_DATA *pArea; EDIT_AREA(ch, pArea); reset_area( pArea ); send_to_char( "Area reset.\n\r", ch ); return FALSE; } AEDIT( aedit_create ) { AREA_DATA *pArea; pArea = new_area(); area_last->next = pArea; area_last = pArea; /* Thanks, Walker. */ ch->desc->pEdit = (void *)pArea; SET_BIT( pArea->area_flags, AREA_ADDED ); send_to_char( "Area Created.\n\r", ch ); return FALSE; } AEDIT( aedit_name ) { AREA_DATA *pArea; EDIT_AREA(ch, pArea); if ( argument[0] == '\0' ) { send_to_char( "Syntax: name [$name]\n\r", ch ); return FALSE; } free_string( pArea->name ); pArea->name = str_dup( argument ); send_to_char( "Name set.\n\r", ch ); return TRUE; } AEDIT( aedit_credits ) { AREA_DATA *pArea; EDIT_AREA(ch, pArea); if ( argument[0] == '\0' ) { send_to_char( "Syntax: credits [$credits]\n\r", ch ); return FALSE; } free_string( pArea->credits ); pArea->credits = str_dup( argument ); send_to_char( "Credits set.\n\r", ch ); return TRUE; } AEDIT( aedit_file ) { AREA_DATA *pArea, *test; 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; } } for ( test = area_first; test != NULL; test = test->next) { char buf[MAX_STRING_LENGTH]; strcat( buf, file ); strcat( buf, ".are" ); if (test == pArea) continue; if (!str_cmp(test->file_name, buf)) { sprintf(buf,"%s: filename is already taken.", buf); send_to_char(buf,ch); return FALSE; } } free_string( pArea->file_name ); strcat( file, ".are" ); pArea->file_name = str_dup( file ); send_to_char( "Filename set.\n\r", ch ); return TRUE; } AEDIT( aedit_age ) { 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 [#xage]\n\r", ch ); return FALSE; } pArea->age = atoi( age ); send_to_char( "Age set.\n\r", ch ); return TRUE; } #if 0 /* ROM OLC */ AEDIT( aedit_recall ) { AREA_DATA *pArea; char room[MAX_STRING_LENGTH]; int value; EDIT_AREA(ch, pArea); one_argument( argument, room ); if ( !is_number( argument ) || argument[0] == '\0' ) { send_to_char( "Syntax: recall [#xrvnum]\n\r", ch ); return FALSE; } value = atoi( room ); if ( !get_room_index( value ) ) { send_to_char( "AEdit: Room vnum does not exist.\n\r", ch ); return FALSE; } pArea->recall = value; send_to_char( "Recall set.\n\r", ch ); return TRUE; } #endif /* ROM OLC */ AEDIT( aedit_security ) { 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 [#xlevel]\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; } AEDIT( aedit_builder ) { AREA_DATA *pArea; char name[MAX_STRING_LENGTH]; char buf[MAX_STRING_LENGTH]; EDIT_AREA(ch, pArea); one_argument( argument, name ); if ( name[0] == '\0' ) { 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 ); send_to_char( pArea->builders,ch); return TRUE; } return FALSE; } AEDIT( aedit_vnum ) { 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 [#xlower] [#xupper]\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; } if ( !check_range( atoi( lower ), atoi( upper ) ) ) { 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->min_vnum = 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->max_vnum = iupper; send_to_char( "Upper vnum set.\n\r", ch ); return TRUE; } AEDIT( aedit_lvnum ) { 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: min_vnum [#xlower]\n\r", ch ); return FALSE; } if ( ( ilower = atoi( lower ) ) > ( iupper = pArea->max_vnum ) ) { send_to_char( "AEdit: Value must be less than the max_vnum.\n\r", 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->min_vnum = ilower; send_to_char( "Lower vnum set.\n\r", ch ); return TRUE; } AEDIT( aedit_uvnum ) { 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: max_vnum [#xupper]\n\r", ch ); return FALSE; } if ( ( ilower = pArea->min_vnum ) > ( iupper = atoi( upper ) ) ) { send_to_char( "AEdit: Upper must be larger then lower.\n\r", 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->max_vnum = iupper; send_to_char( "Upper vnum set.\n\r", ch ); return TRUE; } /* * Room Editor Functions. */ REDIT( redit_show ) { ROOM_INDEX_DATA *pRoom; char buf [MAX_STRING_LENGTH]; char buf1 [2*MAX_STRING_LENGTH]; OBJ_DATA *obj; CHAR_DATA *rch; PROG_LIST *list; int door; bool fcnt; EDIT_ROOM(ch, pRoom); buf1[0] = '\0'; sprintf( buf, "Description:\n\r%s", pRoom->description ); strcat( buf1, buf ); sprintf( buf, "Name: [%s]\n\rArea: [%5d] %s\n\r", pRoom->name, pRoom->area->vnum, pRoom->area->name ); strcat( buf1, buf ); sprintf( buf, "Vnum: [%5d]\n\rSector: [%s]\n\r", pRoom->vnum, flag_string( sector_flags, pRoom->sector_type ) ); strcat( buf1, buf ); sprintf( buf, "Room flags: [%s]\n\r", flag_string( room_flags, pRoom->room_flags ) ); strcat( buf1, buf ); if ( pRoom->heal_rate != 100 || pRoom->mana_rate != 100 ) { sprintf( buf, "Health rec: [%d]\n\rMana rec : [%d]\n\r", pRoom->heal_rate , pRoom->mana_rate ); strcat( buf1, buf ); } if ( pRoom->clan > 0 ) { sprintf( buf, "Clan : [%d] %s\n\r", pRoom->clan, clan_table[pRoom->clan].name ); strcat( buf1, buf ); } if ( !IS_NULLSTR(pRoom->owner) ) { sprintf( buf, "Owner : [%s]\n\r", pRoom->owner ); strcat( buf1, buf ); } if ( pRoom->extra_descr ) { EXTRA_DESCR_DATA *ed; strcat( buf1, "Desc Kwds: [" ); for ( ed = pRoom->extra_descr; ed; ed = ed->next ) { strcat( buf1, ed->keyword ); if ( ed->next ) strcat( buf1, " " ); } strcat( buf1, "]\n\r" ); } strcat( buf1, "Characters: [" ); fcnt = FALSE; for ( rch = pRoom->people; rch; rch = rch->next_in_room ) { if (can_see( ch,rch ) ) { one_argument( rch->name, buf ); strcat( buf1, buf ); strcat( buf1, " " ); fcnt = TRUE; } } if ( fcnt ) { int end; end = strlen(buf1) - 1; buf1[end] = ']'; strcat( buf1, "\n\r" ); } else strcat( buf1, "none]\n\r" ); strcat( buf1, "Objects: [" ); fcnt = FALSE; for ( obj = pRoom->contents; obj; obj = obj->next_content ) { one_argument( obj->name, buf ); strcat( buf1, buf ); strcat( buf1, " " ); fcnt = TRUE; } if ( fcnt ) { int end; end = strlen(buf1) - 1; buf1[end] = ']'; strcat( buf1, "\n\r" ); } else strcat( buf1, "none]\n\r" ); sprintf( buf, "Minerals: Steel (%-3d) Iron (%-3d)\n\r" " Copper (%-3d) Adamantium (%-3d)\n\r" " Platinum (%-3d) Bronze (%-3d)\n\r" " Silver (%-3d) Marble (%-3d)\n\r" " Brass (%-3d) Granite (%-3d)\n\r" " Electrum (%-3d)\n\r", pRoom->mineral[MIN_STEEL], pRoom->mineral[MIN_IRON], pRoom->mineral[MIN_COPPER], pRoom->mineral[MIN_ADAMANTIUM], pRoom->mineral[MIN_PLATINUM], pRoom->mineral[MIN_BRONZE], pRoom->mineral[MIN_SILVER], pRoom->mineral[MIN_MARBLE], pRoom->mineral[MIN_BRASS], pRoom->mineral[MIN_GRANITE], pRoom->mineral[MIN_ELECTRUM]); strcat(buf1, buf); for ( door = 0; door < MAX_DIR; door++ ) { EXIT_DATA *pexit; if ( ( pexit = pRoom->exit[door] ) ) { char word[MAX_INPUT_LENGTH]; char reset_state[MAX_STRING_LENGTH]; char state[MSL]; int i, length; sprintf( buf, "-%-5s to [%5d] Key: [%5d] ", capitalize(dir_name[door]), pexit->u1.to_room ? pexit->u1.to_room->vnum : 0, /* ROM OLC */ pexit->key ); strcat( buf1, buf ); /* * Format up the exit info. * Capitalize all flags that are not part of the reset info. */ strcpy( reset_state, flag_string( exit_flags, pexit->rs_flags ) ); sprintf(state, "%s", flag_string( exit_flags, pexit->exit_info )); strcat( buf1, " Exit flags: [" ); for (; ;) { sprintf(state, "%s", one_argument( state, word ) ); if ( word[0] == '\0' ) { int end; end = strlen(buf1) - 1; buf1[end] = ']'; strcat( buf1, "\n\r" ); break; } if ( str_infix( word, reset_state ) ) { length = strlen(word); for (i = 0; i < length; i++) word[i] = UPPER(word[i]); } strcat( buf1, word ); strcat( buf1, " " ); } if ( pexit->keyword && pexit->keyword[0] != '\0' ) { sprintf( buf, "Kwds: [%s]\n\r", pexit->keyword ); strcat( buf1, buf ); } if ( pexit->description && pexit->description[0] != '\0' ) { sprintf( buf, "%s", pexit->description ); strcat( buf1, buf ); } } } if ( pRoom->rprogs ) { int cnt; sprintf(buf, "\n\rROOMPrograms for [%5d]:\n\r", pRoom->vnum); send_to_char( buf, ch ); for (cnt=0, list=pRoom->rprogs; list; list=list->next) { if (cnt ==0) { send_to_char ( " Number Vnum Trigger Phrase\n\r", ch ); send_to_char ( " ------ ---- ------- ------\n\r", ch ); } sprintf(buf, "[%5d] %4d %7s %s\n\r", cnt, list->vnum,prog_type_to_name(list->trig_type), list->trig_phrase); send_to_char( buf, ch ); cnt++; } } send_to_char( buf1, ch ); return FALSE; } /* 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]; int value; int i; EDIT_ROOM(ch, pRoom); /* * Set the exit flags, needs full argument. * ---------------------------------------- */ if ( ( value = flag_value( exit_flags, argument ) ) != NO_FLAG ) { ROOM_INDEX_DATA *pToRoom; sh_int rev; /* ROM OLC */ if ( !pRoom->exit[door] ) { send_to_char("Salida no existe.\n\r",ch); return FALSE; } /* * This room. */ TOGGLE_BIT(pRoom->exit[door]->rs_flags, value); if (!(EX_ISDOOR & pRoom->exit[door]->rs_flags)) pRoom->exit[door]->rs_flags = 0; pRoom->exit[door]->exit_info = pRoom->exit[door]->rs_flags; /* * Connected room. */ pToRoom = pRoom->exit[door]->u1.to_room; /* ROM OLC */ rev = rev_dir[door]; if (pToRoom->exit[rev] != NULL) { pToRoom->exit[rev]->rs_flags = pRoom->exit[door]->rs_flags; pToRoom->exit[rev]->exit_info = pRoom->exit[door]->exit_info; } send_to_char( "Exit flag toggled.\n\r", ch ); return TRUE; } /* * Now parse the arguments. */ argument = one_argument( argument, command ); one_argument( argument, arg ); if ( command[0] == '\0' && argument[0] == '\0' ) /* Move command. */ { if ( ch->desc->walkabout ) change_exit(ch, "dig", door); move_char( ch, door, TRUE ); /* ROM OLC */ return FALSE; } if ( command[0] == '?' ) { do_help( ch, "EXIT" ); return FALSE; } if ( !str_cmp( command, "delete" ) ) { ROOM_INDEX_DATA *pToRoom; sh_int rev; /* ROM OLC */ if ( !pRoom->exit[door] ) { send_to_char( "REdit: Cannot delete a null exit.\n\r", ch ); return FALSE; } /* * Remove ToRoom Exit. */ rev = rev_dir[door]; pToRoom = pRoom->exit[door]->u1.to_room; /* ROM OLC */ if ( pToRoom->exit[rev] ) { free_exit( pToRoom->exit[rev] ); pToRoom->exit[rev] = NULL; } /* * Remove this exit. */ free_exit( pRoom->exit[door] ); pRoom->exit[door] = NULL; send_to_char( "Exit unlinked.\n\r", ch ); return TRUE; } if ( !str_cmp( command, "link" ) ) { EXIT_DATA *pExit; ROOM_INDEX_DATA *toRoom; if ( arg[0] == '\0' || !is_number( arg ) ) { send_to_char( "Syntax: [direction] link [vnum]\n\r", ch ); return FALSE; } value = atoi( arg ); if ( ! (toRoom = get_room_index( value )) ) { send_to_char( "REdit: Cannot link to non-existant room.\n\r", ch ); return FALSE; } if ( !IS_BUILDER( ch, toRoom->area ) ) { send_to_char( "REdit: Cannot link to that area.\n\r", ch ); return FALSE; } if ( toRoom->exit[rev_dir[door]] ) { send_to_char( "REdit: Remote side's exit already exists.\n\r", ch ); return FALSE; } if ( !pRoom->exit[door] ) pRoom->exit[door] = new_exit(); pRoom->exit[door]->u1.to_room = toRoom; pRoom->exit[door]->orig_door = door; door = rev_dir[door]; pExit = new_exit(); pExit->u1.to_room = pRoom; pExit->orig_door = door; toRoom->exit[door] = pExit; send_to_char( "Two-way link established.\n\r", ch ); return TRUE; } if ( !str_cmp( command, "dig" ) ) { char buf[MAX_STRING_LENGTH]; bool found = FALSE; if ( arg[0] == '\0' || !is_number( arg ) ) { if(ch->in_room->exit[door] && ch->in_room->exit[door]->u1.to_room ) { send_to_char("You can't dig that way.\n\r",ch); return FALSE; } for( i = ch->in_room->area->min_vnum; i <= ch->in_room->area->max_vnum ; i++ ) { if( get_room_index(i) == NULL ) { found = TRUE; break; } } if(!found ) { send_to_char("Your outta vnums! No autodiggin!\n\r",ch); return FALSE; } sprintf(arg, "%d",i ); printf_to_char(ch, "AutoDig: Linke established to %d.\n\r",i); } redit_create( ch, arg ); sprintf( buf, "link %s", arg ); change_exit( ch, buf, door); return TRUE; } if ( !str_cmp( command, "room" ) ) { ROOM_INDEX_DATA *toRoom; if ( arg[0] == '\0' || !is_number( arg ) ) { send_to_char( "Syntax: [direction] room [vnum]\n\r", ch ); return FALSE; } value = atoi( arg ); if ( !(toRoom = get_room_index( value )) ) { send_to_char( "REdit: Cannot link to non-existant room.\n\r", ch ); return FALSE; } if ( !pRoom->exit[door] ) pRoom->exit[door] = new_exit(); pRoom->exit[door]->u1.to_room = toRoom; /* ROM OLC */ pRoom->exit[door]->orig_door = door; send_to_char( "One-way link established.\n\r", ch ); return TRUE; } if ( !str_cmp( command, "key" ) ) { OBJ_INDEX_DATA *key; if ( arg[0] == '\0' || !is_number( arg ) ) { send_to_char( "Syntax: [direction] key [vnum]\n\r", ch ); return FALSE; } if ( !pRoom->exit[door] ) { send_to_char("Salida no existe.\n\r",ch); return FALSE; } value = atoi( arg ); if ( !(key = get_obj_index( value )) ) { send_to_char( "REdit: Key doesn't exist.\n\r", ch ); return FALSE; } if ( key->item_type != ITEM_KEY ) { send_to_char( "REdit: Objeto no es llave.\n\r", ch ); return FALSE; } pRoom->exit[door]->key = value; 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 ); send_to_char( " [direction] name none\n\r", ch ); return FALSE; } if ( !pRoom->exit[door] ) { send_to_char("Salida no existe.\n\r",ch); return FALSE; } free_string( pRoom->exit[door]->keyword ); if (str_cmp(arg,"none")) pRoom->exit[door]->keyword = str_dup( arg ); else pRoom->exit[door]->keyword = str_dup( "" ); send_to_char( "Exit name set.\n\r", ch ); return TRUE; } if ( !str_prefix( command, "description" ) ) { if ( arg[0] == '\0' ) { if ( !pRoom->exit[door] ) { send_to_char("Salida no existe.\n\r",ch); return FALSE; } string_append( ch, &pRoom->exit[door]->description ); return TRUE; } send_to_char( "Syntax: [direction] desc\n\r", ch ); return FALSE; } 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; } 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; } ed->description = format_string( ed->description ); send_to_char( "Extra description formatted.\n\r", ch ); return TRUE; } redit_ed( ch, "" ); return FALSE; } REDIT( redit_create ) { AREA_DATA *pArea; ROOM_INDEX_DATA *pRoom; int value; int iHash; EDIT_ROOM(ch, pRoom); value = atoi( argument ); if ( argument[0] == '\0' || value <= 0 ) { send_to_char( "Syntax: create [vnum > 0]\n\r", ch ); return FALSE; } pArea = get_vnum_area( value ); if ( !pArea ) { send_to_char( "REdit: That vnum is not assigned an area.\n\r", ch ); return FALSE; } if ( !IS_BUILDER( ch, pArea ) ) { send_to_char( "REdit: Vnum in an area you cannot build in.\n\r", ch ); return FALSE; } if ( get_room_index( value ) ) { send_to_char( "REdit: 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; send_to_char( "Room created.\n\r", ch ); return TRUE; } 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_heal ) { ROOM_INDEX_DATA *pRoom; EDIT_ROOM(ch, pRoom); if (is_number(argument)) { pRoom->heal_rate = atoi ( argument ); send_to_char ( "Heal rate set.\n\r", ch); return TRUE; } send_to_char ( "Syntax : heal <#xnumber>\n\r", ch); return FALSE; } REDIT( redit_mana ) { ROOM_INDEX_DATA *pRoom; EDIT_ROOM(ch, pRoom); if (is_number(argument)) { pRoom->mana_rate = atoi ( argument ); send_to_char ( "Mana rate set.\n\r", ch); return TRUE; } send_to_char ( "Syntax : mana <#xnumber>\n\r", ch); return FALSE; } REDIT( redit_clan ) { ROOM_INDEX_DATA *pRoom; EDIT_ROOM(ch, pRoom); pRoom->clan = clan_lookup(argument); send_to_char ( "Clan set.\n\r", ch); return TRUE; } REDIT( redit_format ) { ROOM_INDEX_DATA *pRoom; EDIT_ROOM(ch, pRoom); 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 ]; char arg2 [ MAX_INPUT_LENGTH ]; RESET_DATA *pReset; char output [ MAX_STRING_LENGTH ]; EDIT_ROOM(ch, pRoom); argument = one_argument( argument, arg ); argument = one_argument( argument, arg2 ); if ( arg[0] == '\0' || !is_number( arg ) ) { send_to_char ( "Syntax: mreset <vnum> <max #x> <mix #x>\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( arg2 ) ? atoi( arg2 ) : MAX_MOB; pReset->arg3 = pRoom->vnum; pReset->arg4 = is_number( argument ) ? atoi (argument) : 1; add_reset( pRoom, pReset, 0/* Last slot*/ ); /* * Create the mobile. */ newmob = create_mobile( pMobIndex ); char_to_room( newmob, pRoom ); 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; } 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_WEDDING, ITEM_WEAR_WEDDING }, { 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_SHOULDER, ITEM_WEAR_SHOULDER }, { WEAR_HOOD, ITEM_WEAR_HOOD }, { WEAR_CLOAK, ITEM_WEAR_CLOAK }, { WEAR_LAYER_ARMS,ITEM_LAYER_ARMS }, { WEAR_LAYER_BODY,ITEM_LAYER_BODY }, { WEAR_LAYER_LEGS,ITEM_LAYER_LEGS }, { WEAR_BACK, ITEM_WEAR_BACK }, { 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; pReset->arg4 = 0; 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 = 0; pReset->arg3 = to_obj->pIndexData->vnum; pReset->arg4 = 1; add_reset( pRoom, pReset, 0/* Last slot*/ ); newobj = create_object( pObjIndex, number_fuzzy( olevel ) ); newobj->cost = 0; obj_to_obj( newobj, to_obj ); 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, NULL, 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: [%s]\n\r", capitalize( pObjIndex->short_descr ), pObjIndex->vnum, flag_string( wear_flags, pObjIndex->wear_flags ) ); send_to_char( output, ch ); return FALSE; } /* * Can't load into same position. */ if ( get_eq_char( to_mob, wear_loc ) ) { 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; } /* * Object Editor Functions. */ void show_obj_values( CHAR_DATA *ch, OBJ_INDEX_DATA *obj ) { char buf[MAX_STRING_LENGTH]; switch( obj->item_type ) { default: /* No values. */ break; case ITEM_LIGHT: if ( obj->value[2] == -1 || obj->value[2] == 999 ) /* ROM OLC */ sprintf( buf, "[v2] Light: Infinite[-1]\n\r" ); else sprintf( buf, "[v2] Light: [%d]\n\r", obj->value[2] ); send_to_char( buf, ch ); break; case ITEM_WAND: case ITEM_STAFF: sprintf( buf, "[v0] Level: [%d]\n\r" "[v1] Charges Total: [%d]\n\r" "[v2] Charges Left: [%d]\n\r" "[v3] Spell: %s\n\r", obj->value[0], obj->value[1], obj->value[2], obj->value[3] != -1 ? skill_table[obj->value[3]].name : "none" ); send_to_char( buf, ch ); break; case ITEM_PORTAL: sprintf( buf, "[v0] Charges: [%d]\n\r" "[v1] Exit Flags: %s\n\r" "[v2] Portal Flags: %s\n\r" "[v3] Goes to (vnum): [%d]\n\r", obj->value[0], flag_string( exit_flags, obj->value[1]), flag_string( portal_flags , obj->value[2]), obj->value[3] ); send_to_char( buf, ch); break; case ITEM_FURNITURE: sprintf( buf, "[v0] Max people: [%d]\n\r" "[v1] Max weight: [%d]\n\r" "[v2] Furniture Flags: %s\n\r" "[v3] Heal bonus: [%d]\n\r" "[v4] Mana bonus: [%d]\n\r", obj->value[0], obj->value[1], flag_string( furniture_flags, obj->value[2]), obj->value[3], obj->value[4] ); send_to_char( buf, ch ); break; case ITEM_SCROLL: case ITEM_POTION: case ITEM_PILL: sprintf( buf, "[v0] Level: [%d]\n\r" "[v1] Spell: %s\n\r" "[v2] Spell: %s\n\r" "[v3] Spell: %s\n\r" "[v4] Spell: %s\n\r", obj->value[0], obj->value[1] != -1 ? skill_table[obj->value[1]].name : "none", obj->value[2] != -1 ? skill_table[obj->value[2]].name : "none", obj->value[3] != -1 ? skill_table[obj->value[3]].name : "none", obj->value[4] != -1 ? skill_table[obj->value[4]].name : "none" ); send_to_char( buf, ch ); break; /* ARMOR for ROM */ case ITEM_ARMOR: if (IS_OBJ_STAT(obj, ITEM_QUEST)) sprintf(buf, "[v0-3] AC Values not set for Quest Eq.\n\r"); else sprintf( buf, "[v0] Ac pierce [%d]\n\r" "[v1] Ac bash [%d]\n\r" "[v2] Ac slash [%d]\n\r" "[v3] Ac exotic [%d]\n\r", obj->value[0], obj->value[1], obj->value[2], obj->value[3] ); send_to_char( buf, ch ); break; /* WEAPON changed in ROM: */ /* I had to split the output here, I have no idea why, but it helped -- Hugin */ /* It somehow fixed a bug in showing scroll/pill/potions too ?! */ case ITEM_WEAPON: sprintf( buf, "[v0] Weapon class: %s\n\r", flag_string( weapon_class, obj->value[0] ) ); send_to_char( buf, ch ); if (!IS_OBJ_STAT(obj, ITEM_QUEST)) { sprintf( buf, "[v1] Number of dice: [%d]\n\r", obj->value[1] ); send_to_char( buf, ch ); sprintf( buf, "[v2] Type of dice: [%d]\n\r", obj->value[2] ); send_to_char( buf, ch ); } sprintf( buf, "[v3] Type: %s\n\r", attack_table[obj->value[3]].name ); send_to_char( buf, ch ); sprintf( buf, "[v4] Special type: %s\n\r", flag_string( weapon_type2, obj->value[4] ) ); send_to_char( buf, ch ); break; case ITEM_BELT: printf_to_char( ch, "[v0] Weight capacity: [%d]\n\r" "[v1] Durability (1-5): [%d]\n\r", obj->value[0], obj->value[1] == 0 ? 1 : obj->value[1] ); break; case ITEM_SHEATH: sprintf( buf, "[v0] Max weapon size: [%d]\n\r",obj->value[0]); send_to_char(buf,ch); sprintf( buf, "[v1] Max weapon weight: [%d]\n\r",obj->value[1] == 0 ? 1 : obj->value[1] ); send_to_char(buf,ch); sprintf( buf, "[v2] double sheath?:[0/yes, 1/no] %d\n\r", obj->value[2]); send_to_char(buf,ch); sprintf( buf, "[v3] With strap?: [0/yes, 1/no] %d\n\r", obj->value[3]); send_to_char(buf,ch); break; case ITEM_CONTAINER: if(IS_OBJ_STAT(obj, ITEM_QUEST)) sprintf(buf, "[v0] Weight: Not set on Quest Items.\n\r" "[v1] Flags: [%s]\n\r" "[v2] Key: [%d] %s\n\r" "[v3] Capacity Not set on Quest Items.\n\r" "[v4] Weight Mult [%d]\n\r", flag_string(container_flags, obj->value[1]), obj->value[2], get_obj_index(obj->value[2]) ? get_obj_index(obj->value[2])->short_descr : "none", obj->value[4]); else sprintf( buf, "[v0] Weight: [%d kg]\n\r" "[v1] Flags: [%s]\n\r" "[v2] Key: %s [%d]\n\r" "[v3] Capacity [%d]\n\r" "[v4] Weight Mult [%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], obj->value[3], obj->value[4] ); send_to_char( buf, ch ); break; case ITEM_DRINK_CON: sprintf( buf, "[v0] Liquid Total: [%d]\n\r" "[v1] Liquid Left: [%d]\n\r" "[v2] Liquid: %s\n\r" "[v3] Poisoned: %s\n\r", obj->value[0], obj->value[1], liq_table[obj->value[2]].liq_name, obj->value[3] != 0 ? "Yes" : "No" ); send_to_char( buf, ch ); break; case ITEM_FOUNTAIN: sprintf( buf, "[v0] Liquid Total: [%d]\n\r" "[v1] Liquid Left: [%d]\n\r" "[v2] Liquid: %s\n\r", obj->value[0], obj->value[1], liq_table[obj->value[2]].liq_name ); send_to_char( buf,ch ); break; case ITEM_FOOD: sprintf( buf, "[v0] Food hours: [%d]\n\r" "[v1] Full hours: [%d]\n\r" "[v3] Poisoned: %s\n\r", obj->value[0], obj->value[1], obj->value[3] != 0 ? "Yes" : "No" ); send_to_char( buf, ch ); break; case ITEM_MONEY: sprintf( buf, "[v0] Gold: [%d]\n\r", obj->value[0] ); send_to_char( buf, ch ); break; case ITEM_TOKEN: sprintf( buf, "[v0] Quest point value: [%d]\n\r", obj->value[0]); send_to_char( buf, ch ); break; case ITEM_SOURCE: sprintf( buf, "[v0] to hp: [%d]\n\r" "[v1] to mn: [%d]\n\r" "[v2] to mv: [%d]\n\r", obj->value[0], obj->value[1], obj->value[2] ); send_to_char( buf,ch ); break; case ITEM_SOCKET: sprintf( buf, "{G[{Yv0{G]{R to hit: {W[{C%d{W]{x\n\r" "{G[{Yv1{G]{R to dam: {W[{C%d{W]{x\n\r", obj->value[0], obj->value[1] ); send_to_char( buf,ch ); break; case ITEM_SOCKETS: sprintf( buf, "[v0] Type: %s\n\r", socket_flags[obj->value[0]].name ); send_to_char( buf, ch ); sprintf( buf, "[v1] Value: %s\n\r", socket_values[obj->value[1]].name ); send_to_char( buf, ch ); break; case ITEM_QUIVER: sprintf( buf, "[v0] Number of Arrows: %d\n\r", obj->value[0] ); send_to_char( buf, ch); sprintf( buf, "[v1] Number of Dice: %d\n\r", obj->value[1] ); send_to_char( buf, ch); sprintf( buf, "[v2] Type of Dice: %d\n\r", obj->value[2] ); send_to_char( buf, ch); sprintf( buf, "[v3] Spell: %s\n\r", obj->value[3] != -1 ? skill_table[obj->value[3]].name : "none" ); send_to_char( buf, ch); break; case ITEM_ARROW: sprintf( buf, "[v1] Number of Dice: %d\n\r", obj->value[1] ); send_to_char( buf, ch); sprintf( buf, "[v2] Type of Dice: %d\n\r", obj->value[2] ); send_to_char( buf, ch); sprintf( buf, "[v3] Spell: %s\n\r", obj->value[3] != -1 ? skill_table[obj->value[3]].name : "none" ); send_to_char( buf, ch); break; case ITEM_ORE: printf_to_char(ch, "[v0] Mineral: %s\n\r", mineral_table[obj->value[0]].name ); break; } return; } bool set_obj_values( CHAR_DATA *ch, OBJ_INDEX_DATA *pObj, int value_num, char *argument) { int amount; int value = 0; switch( pObj->item_type ) { default: break; case ITEM_LIGHT: switch ( value_num ) { default: do_help( ch, "ITEM_LIGHT" ); return FALSE; 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, "ITEM_STAFF_WAND" ); return FALSE; 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, "ITEM_SCROLL_POTION_PILL" ); return FALSE; 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; case 4: send_to_char( "SPELL TYPE 4 SET.\n\r\n\r", ch ); pObj->value[4] = skill_lookup( argument ); break; } break; /* ARMOR for ROM: */ case ITEM_ARMOR: switch ( value_num ) { default: do_help( ch, "ITEM_ARMOR" ); return FALSE; case 0: send_to_char( "AC PIERCE SET.\n\r\n\r", ch ); pObj->value[0] = atoi( argument ); break; case 1: send_to_char( "AC BASH SET.\n\r\n\r", ch ); pObj->value[1] = atoi( argument ); break; case 2: send_to_char( "AC SLASH SET.\n\r\n\r", ch ); pObj->value[2] = atoi( argument ); break; case 3: send_to_char( "AC EXOTIC SET.\n\r\n\r", ch ); pObj->value[3] = atoi( argument ); break; } break; /* WEAPONS changed in ROM */ case ITEM_WEAPON: amount = atoi(argument); switch ( value_num ) { default: do_help( ch, "ITEM_WEAPON" ); return FALSE; case 0: send_to_char( "WEAPON CLASS SET.\n\r\n\r", ch ); ALT_FLAGVALUE_SET( pObj->value[0], weapon_class, argument ); break; case 1: if ( amount >= 20 ) { send_to_char( "Please choose an amount less than 20.\n\r", ch ); return FALSE; } send_to_char( "NUMBER OF DICE SET.\n\r\n\r", ch ); pObj->value[1] = amount; break; case 2: if ( amount >= 20 ) { send_to_char( "Please set an amount smaller than 20.\n\r", ch ); return FALSE; } send_to_char( "TYPE OF DICE SET.\n\r\n\r", ch ); pObj->value[2] = amount; break; case 3: send_to_char( "WEAPON TYPE SET.\n\r\n\r", ch ); pObj->value[3] = attack_lookup( argument ); break; case 4: send_to_char( "SPECIAL WEAPON TYPE TOGGLED.\n\r\n\r", ch ); ALT_FLAGVALUE_TOGGLE( pObj->value[4], weapon_type2, argument ); break; } break; case ITEM_BELT: switch( value_num ) { default: send_to_char( "v0 -- The amount of weight (in 10ths of pounds) the belt can hold.\n\r" "v1 -- The relative quality of the belt. A fully-loaded belt with this\n\r" " set to 1 might just break under the strain, for instance...\n\n\r", ch ); break; case 0: send_to_char( "Weight capacity set.\n\r\n\r", ch ); pObj->value[0] = atoi( argument ); break; case 1: if ( atoi(argument) > 5 || atoi(argument) < 1 ) { send_to_char( "Durability must be between 1 (weakest) and 5 (strongest).\n\r", ch ); return FALSE; } send_to_char( "Durability set.\n\r\n\r", ch ); pObj->value[1] = atoi( argument ); break; } break; case ITEM_SHEATH: switch( value_num ) { default: send_to_char( "v0 -- The numbers are thus: exotic - any, dagger/shortsword - 1, longsword - 2,\n\r",ch); send_to_char( " massive swords and axes - 3, spears and polearms - 4.\n\r",ch); send_to_char( "v1 -- The max weight the sheath can hold, in 10ths of pounds.\n\r",ch); send_to_char( "v2 -- Check for a double sheath.", ch ); send_to_char( "v3 -- Does it come with strap?\n\r",ch); break; case 0: if (atoi(argument) > 4 || atoi(argument) < 1) { send_to_char( "Max size must be between 1 and 4.\n\r", ch ); return FALSE; } send_to_char( "Max weapon size set.\n\r\n\r", ch ); pObj->value[0] = atoi( argument ); break; case 1: send_to_char( "Max weight set.\n\r\n\r", ch ); pObj->value[1] = atoi( argument ); break; case 2: if(atoi(argument) < 0 || atoi(argument) > 1) { send_to_char( "It must be either 1 or 0.\n\r", ch ); return FALSE; } if(atoi(argument) == 1) { send_to_char("It is not a double sheath.\n\r",ch); pObj->value[2] = SHEATH_NO; } else { send_to_char("It is a double sheath!\n\r",ch); pObj->value[2] = SHEATH_YES; } break; case 3: if(atoi(argument) < 0 || atoi(argument) > 1) { send_to_char( "It must be either 1 or 0.\n\r", ch ); return FALSE; } if(atoi(argument) == 1) { send_to_char("It doesn't come with a strap.\n\r",ch); pObj->value[3] = SHEATH_NO; } else { send_to_char("It does come with a strap!\n\r",ch); pObj->value[3] = SHEATH_YES; } break; } break; case ITEM_PORTAL: switch ( value_num ) { default: do_help(ch, "ITEM_PORTAL" ); return FALSE; case 0: send_to_char( "CHARGES SET.\n\r\n\r", ch); pObj->value[0] = atoi ( argument ); break; case 1: send_to_char( "EXIT FLAGS SET.\n\r\n\r", ch); ALT_FLAGVALUE_SET( pObj->value[1], exit_flags, argument ); break; case 2: send_to_char( "PORTAL FLAGS SET.\n\r\n\r", ch); ALT_FLAGVALUE_SET( pObj->value[2], portal_flags, argument ); break; case 3: send_to_char( "EXIT VNUM SET.\n\r\n\r", ch); pObj->value[3] = atoi ( argument ); break; } break; case ITEM_FURNITURE: switch ( value_num ) { default: do_help( ch, "ITEM_FURNITURE" ); return FALSE; case 0: send_to_char( "NUMBER OF PEOPLE SET.\n\r\n\r", ch); pObj->value[0] = atoi ( argument ); break; case 1: send_to_char( "MAX WEIGHT SET.\n\r\n\r", ch); pObj->value[1] = atoi ( argument ); break; case 2: send_to_char( "FURNITURE FLAGS TOGGLED.\n\r\n\r", ch); ALT_FLAGVALUE_TOGGLE( pObj->value[2], furniture_flags, argument ); break; case 3: send_to_char( "HEAL BONUS SET.\n\r\n\r", ch); pObj->value[3] = atoi ( argument ); break; case 4: send_to_char( "MANA BONUS SET.\n\r\n\r", ch); pObj->value[4] = atoi ( argument ); break; } break; case ITEM_CONTAINER: switch ( value_num ) { int value; default: do_help( ch, "ITEM_CONTAINER" ); return FALSE; case 0: send_to_char( "WEIGHT CAPACITY SET.\n\r\n\r", ch ); pObj->value[0] = atoi( argument ); break; case 1: if ( ( value = flag_value( container_flags, argument ) ) != NO_FLAG ) TOGGLE_BIT(pObj->value[1], value); else { do_help ( ch, "ITEM_CONTAINER" ); return FALSE; } send_to_char( "CONTAINER TYPE SET.\n\r\n\r", ch ); break; case 2: if ( atoi(argument) != 0 ) { if ( !get_obj_index( atoi( argument ) ) ) { send_to_char( "THERE IS NO SUCH ITEM.\n\r\n\r", ch ); return FALSE; } if ( get_obj_index( atoi( argument ) )->item_type != ITEM_KEY ) { send_to_char( "THAT ITEM IS NOT A KEY.\n\r\n\r", ch ); return FALSE; } } send_to_char( "CONTAINER KEY SET.\n\r\n\r", ch ); pObj->value[2] = atoi( argument ); break; case 3: send_to_char( "CONTAINER MAX WEIGHT SET.\n\r", ch); pObj->value[3] = atoi( argument ); break; case 4: send_to_char( "WEIGHT MULTIPLIER SET.\n\r\n\r", ch ); pObj->value[4] = atoi ( argument ); break; } break; case ITEM_DRINK_CON: switch ( value_num ) { default: do_help( ch, "ITEM_DRINK" ); /* OLC do_help( ch, "liquids" ); */ return FALSE; 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] = ( liq_lookup(argument) != -1 ? liq_lookup(argument) : 0 ); 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_FOUNTAIN: switch (value_num) { default: do_help( ch, "ITEM_FOUNTAIN" ); /* OLC do_help( ch, "liquids" ); */ return FALSE; 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] = ( liq_lookup( argument ) != -1 ? liq_lookup( argument ) : 0 ); break; } break; case ITEM_FOOD: switch ( value_num ) { default: do_help( ch, "ITEM_FOOD" ); return FALSE; case 0: send_to_char( "HOURS OF FOOD SET.\n\r\n\r", ch ); pObj->value[0] = atoi( argument ); break; case 1: send_to_char( "HOURS OF FULL SET.\n\r\n\r", ch ); pObj->value[1] = 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_MONEY: switch ( value_num ) { default: do_help( ch, "ITEM_MONEY" ); return FALSE; case 0: send_to_char( "GOLD AMOUNT SET.\n\r\n\r", ch ); pObj->value[0] = atoi( argument ); break; case 1: send_to_char( "SILVER AMOUNT SET.\n\r\n\r", ch ); pObj->value[1] = atoi( argument ); break; } break; case ITEM_TOKEN: switch ( value_num ) { default: do_help( ch, "ITEM_TOKEN" ); return FALSE; case 0: send_to_char ( "QP VALUE OF TOKEN SET.\n\r\n\r", ch ); pObj->value[0] = atoi( argument ); break; } break; case ITEM_SOURCE: switch ( value_num ) { default: do_help( ch, "ITEM_SOURCE" ); return FALSE; case 0: send_to_char( "HP modifier SET.\n\r\n\r", ch ); pObj->value[0] = atoi( argument ); break; case 1: send_to_char( "MN modifier SET.\n\r\n\r", ch ); pObj->value[1] = atoi( argument ); break; case 2: send_to_char( "MV modifier SET.\n\r\n\r", ch ); pObj->value[2] = atoi( argument ); break; } case ITEM_SOCKET: switch ( value_num ) { default: do_help( ch, "ITEM_SOCKETS" ); return FALSE; case 0: send_to_char( "HIT modifier SET.\n\r\n\r", ch ); pObj->value[0] = atoi( argument ); break; case 1: send_to_char( "DAM modifier SET.\n\r\n\r", ch ); pObj->value[1] = atoi( argument ); break; } break; case ITEM_SOCKETS: value = atoi( argument ); switch( value_num ) { default: do_help( ch, "sockets" ); return FALSE; break; case 0: if ( value >= 6 ) { send_to_char( "Please choose a value between 0 and 5.\n\r", ch ); return FALSE; } send_to_char( "INLAY TYPE SET.\n\r\n\r", ch ); pObj->value[0] = value; break; case 1: if ( value >= 4 ) { send_to_char( "Please choose an amount between 0 and 3.\n\r", ch ); return FALSE; } send_to_char( "GEM VALUE SET.\n\r\n\r", ch ); pObj->value[1] = value; break; } break; case ITEM_QUIVER: switch ( value_num ) { default: do_help( ch, "ITEM_QUIVER" ); return FALSE; case 0: send_to_char( "NUMBER OF ARROWS SET.\n\r\n\r", ch ); pObj->value[0] = atoi( argument ); break; case 1: send_to_char( "NUMBER OF DICE SET.\n\r\n\r", ch ); pObj->value[1] = atoi( argument ); break; case 2: send_to_char( "TYPE OF DICE SET.\n\r\n\r", ch ); pObj->value[2] = atoi( argument ); break; } break; case ITEM_ARROW: switch ( value_num ) { default: do_help( ch, "ITEM_ARROW" ); return FALSE; case 1: send_to_char( "NUMBER OF DICE SET.\n\r\n\r", ch ); pObj->value[1] = atoi( argument ); break; case 2: send_to_char( "TYPE OF DICE SET.\n\r\n\r", ch ); pObj->value[2] = atoi( argument ); break; } break; case ITEM_ORE: switch( value_num ) { default: send_to_char("[v0] - Mineral type.\n\r",ch); case 0: if( mineral_lookup(argument ) == -1 ) { send_to_char("What type of mineral is that?\n\r",ch); return FALSE; } pObj->value[0] = mineral_lookup(argument ); printf_to_char(ch, "Mineral set to %s\n\r",mineral_table[pObj->value[0]].name ); break; } break; } show_obj_values( ch, pObj ); return TRUE; } OEDIT( oedit_show ) { OBJ_INDEX_DATA *pObj; char buf[MAX_STRING_LENGTH]; AFFECT_DATA *paf; PROG_LIST *list; int cnt; EDIT_OBJ(ch, pObj); sprintf( buf, "Name: [%s]\n\rArea: [%5d] %s\n\r", pObj->name, !pObj->area ? -1 : pObj->area->vnum, !pObj->area ? "No Area" : pObj->area->name ); send_to_char( buf, ch ); sprintf( buf, "Vnum: [%5d]\n\rType: [%s]\n\r", pObj->vnum, flag_string( type_flags, pObj->item_type ) ); send_to_char( buf, ch ); sprintf( buf, "Level: [%5d]\n\r", pObj->level ); send_to_char( buf, ch ); sprintf( buf, "Wear flags: [%s]\n\r", flag_string( wear_flags, pObj->wear_flags ) ); send_to_char( buf, ch ); sprintf( buf, "Extra flags: [%s]\n\r", flag_string( extra_flags, pObj->extra_flags ) ); send_to_char( buf, ch ); sprintf( buf, "Extra2 flags: [%s]\n\r", flag_string( extra2_flags, pObj->extra2_flags ) ); send_to_char( buf, ch ); sprintf( buf, "Material: [%s]\n\r", /* ROM */ pObj->material ); send_to_char( buf, ch ); sprintf( buf, "Condition: [%5d]\n\r", /* ROM */ pObj->condition ); send_to_char( buf, ch ); sprintf( buf, "Xp to level: [%5d]\n\r", /* ROM */ pObj->xp_tolevel ); send_to_char( buf, ch ); sprintf( buf, "Size: [%5s]\n\r", (pObj->size >=0 && pObj->size <= 5) ? osize_table[pObj->size] : "unknown"); send_to_char( buf, ch ); sprintf( buf, "Weight: [%5d]\n\rCost: [%5d]\n\r", pObj->weight, pObj->cost ); send_to_char( buf, ch ); if ( pObj->extra_descr ) { EXTRA_DESCR_DATA *ed; send_to_char( "Ex desc kwd: ", ch ); for ( ed = pObj->extra_descr; ed; ed = ed->next ) { send_to_char( "[", ch ); send_to_char( ed->keyword, ch ); send_to_char( "]", ch ); } send_to_char( "\n\r", ch ); } sprintf( buf, "Short desc: %s\n\rLong desc:\n\r %s\n\r", pObj->short_descr, pObj->description ); send_to_char( buf, ch ); for ( cnt = 0, paf = pObj->affected; paf; paf = paf->next ) { if ( cnt == 0 ) { send_to_char( "Number Modifier Affects\n\r", ch ); send_to_char( "------ -------- -------\n\r", ch ); } sprintf( buf, "[%4d] %-8d %s\n\r", cnt, paf->modifier, flag_string( apply_flags, paf->location ) ); send_to_char( buf, ch ); cnt++; } if ( pObj->oprogs ) { int cnt; sprintf(buf, "\n\rOBJPrograms for [%5d]:\n\r", pObj->vnum); send_to_char( buf, ch ); for (cnt=0, list=pObj->oprogs; list; list=list->next) { if (cnt ==0) { send_to_char ( " Number Vnum Trigger Phrase\n\r", ch ); send_to_char ( " ------ ---- ------- ------\n\r", ch ); } sprintf(buf, "[%5d] %4d %7s %s\n\r", cnt, list->vnum,prog_type_to_name(list->trig_type), list->trig_phrase); send_to_char( buf, ch ); cnt++; } } show_obj_values( ch, pObj ); return FALSE; } /* * Need to issue warning if flag isn't valid. -- does so now -- Hugin. */ OEDIT( oedit_addaffect ) { int value; OBJ_INDEX_DATA *pObj; AFFECT_DATA *pAf; char loc[MAX_STRING_LENGTH]; char mod[MAX_STRING_LENGTH]; EDIT_OBJ(ch, pObj); argument = one_argument( argument, loc ); one_argument( argument, mod ); if ( loc[0] == '\0' || mod[0] == '\0' || !is_number( mod ) ) { send_to_char( "Syntax: addaffect [location] [#xmod]\n\r", ch ); return FALSE; } if ( ( value = flag_value( apply_flags, loc ) ) == NO_FLAG ) /* Hugin */ { send_to_char( "Valid affects are:\n\r", ch ); show_help( ch, "apply" ); return FALSE; } pAf = new_affect(); pAf->location = value; pAf->modifier = atoi( mod ); pAf->where = TO_OBJECT; pAf->type = -1; pAf->duration = -1; pAf->bitvector = 0; pAf->level = pObj->level; pAf->next = pObj->affected; pObj->affected = pAf; send_to_char( "Affect added.\n\r", ch); return TRUE; } OEDIT( oedit_addapply ) { int value,bv,typ; OBJ_INDEX_DATA *pObj; AFFECT_DATA *pAf; char loc[MAX_STRING_LENGTH]; char mod[MAX_STRING_LENGTH]; char type[MAX_STRING_LENGTH]; char bvector[MAX_STRING_LENGTH]; EDIT_OBJ(ch, pObj); argument = one_argument( argument, type ); argument = one_argument( argument, loc ); argument = one_argument( argument, mod ); one_argument( argument, bvector ); if ( type[0] == '\0' || ( typ = flag_value( apply_types, type ) ) == NO_FLAG ) { send_to_char( "Invalid apply type. Valid apply types are:\n\r", ch); show_help( ch, "apptype" ); return FALSE; } if ( loc[0] == '\0' || ( value = flag_value( apply_flags, loc ) ) == NO_FLAG ) { send_to_char( "Valid applys are:\n\r", ch ); show_help( ch, "apply" ); return FALSE; } if ( bvector[0] == '\0' || ( bv = flag_value( bitvector_type[typ].table, bvector ) ) == NO_FLAG ) { send_to_char( "Invalid bitvector type.\n\r", ch ); send_to_char( "Valid bitvector types are:\n\r", ch ); show_help( ch, bitvector_type[typ].help ); return FALSE; } if ( mod[0] == '\0' || !is_number( mod ) ) { send_to_char( "Syntax: addapply [type] [location] [#xmod] [bitvector]\n\r", ch ); return FALSE; } pAf = new_affect(); pAf->location = value; pAf->modifier = atoi( mod ); pAf->where = apply_types[typ].bit; pAf->type = -1; pAf->duration = -1; pAf->bitvector = bv; pAf->level = pObj->level; pAf->next = pObj->affected; pObj->affected = pAf; send_to_char( "Apply added.\n\r", ch); return TRUE; } /* * My thanks to Hans Hvidsten Birkeland and Noam Krendel(Walker) * for really teaching me how to manipulate pointers. */ OEDIT( oedit_delaffect ) { OBJ_INDEX_DATA *pObj; AFFECT_DATA *pAf; 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; } OEDIT( oedit_name ) { 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_short ) { 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 ); pObj->short_descr[0] = LOWER( pObj->short_descr[0] ); send_to_char( "Short description set.\n\r", ch); return TRUE; } OEDIT( oedit_long ) { OBJ_INDEX_DATA *pObj; EDIT_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; } 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' changed to "" -- Hugin */ return FALSE; } if ( set_obj_values( ch, pObj, value, argument ) ) return TRUE; return FALSE; } /***************************************************************************** Name: oedit_values Purpose: Finds the object and sets its value. Called by: The four valueX functions below. (now five -- Hugin ) ****************************************************************************/ bool oedit_values( CHAR_DATA *ch, char *argument, int value ) { OBJ_INDEX_DATA *pObj; EDIT_OBJ(ch, pObj); if ( set_value( ch, pObj, argument, value ) ) return TRUE; return FALSE; } OEDIT( oedit_value0 ) { if ( oedit_values( ch, argument, 0 ) ) return TRUE; return FALSE; } OEDIT( oedit_value1 ) { if ( oedit_values( ch, argument, 1 ) ) return TRUE; return FALSE; } OEDIT( oedit_value2 ) { if ( oedit_values( ch, argument, 2 ) ) return TRUE; return FALSE; } OEDIT( oedit_value3 ) { if ( oedit_values( ch, argument, 3 ) ) return TRUE; return FALSE; } OEDIT( oedit_value4 ) { if ( oedit_values( ch, argument, 4 ) ) return TRUE; return FALSE; } OEDIT( oedit_weight ) { 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; } OEDIT( oedit_cost ) { 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; } OEDIT( oedit_create ) { 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; 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; ch->desc->pEdit = (void *)pObj; send_to_char( "Object Created.\n\r", ch ); return TRUE; } OEDIT( oedit_ed ) { 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; } ed->description = format_string( ed->description ); send_to_char( "Extra description formatted.\n\r", ch ); return TRUE; } oedit_ed( ch, "" ); return FALSE; } /* ROM object functions : */ OEDIT( oedit_extra ) /* Moved out of oedit() due to naming conflicts -- Hugin */ { OBJ_INDEX_DATA *pObj; int value; if ( argument[0] != '\0' ) { EDIT_OBJ(ch, pObj); if ( ( value = flag_value( extra_flags, argument ) ) != NO_FLAG ) { TOGGLE_BIT(pObj->extra_flags, value); send_to_char( "Extra flag toggled.\n\r", ch); return TRUE; } } send_to_char( "Syntax: extra [flag]\n\r" "Type '? extra' for a list of flags.\n\r", ch ); return FALSE; } OEDIT( oedit_extra2 ) /* Moved out of oedit() due to naming conflicts -- Hugin */ { OBJ_INDEX_DATA *pObj; int value; if ( argument[0] != '\0' ) { EDIT_OBJ(ch, pObj); if ( ( value = flag_value( extra2_flags, argument ) ) != NO_FLAG ) { TOGGLE_BIT(pObj->extra2_flags, value); send_to_char( "Extra2 flag toggled.\n\r", ch); return TRUE; } } send_to_char( "Syntax: extra2 [flag]\n\r" "Type '? extra2' for a list of flags.\n\r", ch ); return FALSE; } OEDIT( oedit_wear ) /* Moved out of oedit() due to naming conflicts -- Hugin */ { OBJ_INDEX_DATA *pObj; int value; if ( argument[0] != '\0' ) { EDIT_OBJ(ch, pObj); if ( ( value = flag_value( wear_flags, argument ) ) != NO_FLAG ) { TOGGLE_BIT(pObj->wear_flags, value); send_to_char( "Wear flag toggled.\n\r", ch); return TRUE; } } send_to_char( "Syntax: wear [flag]\n\r" "Type '? wear' for a list of flags.\n\r", ch ); return FALSE; } OEDIT( oedit_type ) /* Moved out of oedit() due to naming conflicts -- Hugin */ { OBJ_INDEX_DATA *pObj; int value; if ( argument[0] != '\0' ) { EDIT_OBJ(ch, pObj); if ( ( value = flag_value( type_flags, argument ) ) != NO_FLAG ) { pObj->item_type = value; 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; pObj->value[4] = 0; /* ROM */ return TRUE; } } send_to_char( "Syntax: type [flag]\n\r" "Type '? type' for a list of flags.\n\r", ch ); return FALSE; } OEDIT( oedit_material ) { OBJ_INDEX_DATA *pObj; EDIT_OBJ(ch, pObj); if ( argument[0] == '\0' ) { send_to_char( "Syntax: material [string]\n\r", ch ); return FALSE; } free_string( pObj->material ); pObj->material = str_dup( argument ); send_to_char( "Material set.\n\r", ch); return TRUE; } OEDIT( oedit_level ) { OBJ_INDEX_DATA *pObj; EDIT_OBJ(ch, pObj); if ( argument[0] == '\0' || !is_number( argument ) ) { send_to_char( "Syntax: level [number]\n\r", ch ); return FALSE; } pObj->level = atoi( argument ); send_to_char( "Level set.\n\r", ch); return TRUE; } OEDIT( oedit_condition ) { OBJ_INDEX_DATA *pObj; int value; if ( argument[0] != '\0' && ( value = atoi (argument ) ) >= 0 && ( value <= 100 ) ) { EDIT_OBJ( ch, pObj ); pObj->condition = value; send_to_char( "Condition set.\n\r", ch ); return TRUE; } send_to_char( "Syntax: condition [number]\n\r" "Where number can range from 0 (ruined) to 100 (perfect).\n\r", ch ); return FALSE; } OEDIT( oedit_size ) { OBJ_INDEX_DATA *pObj; int value; if ( argument[0] != '\0' ) { EDIT_OBJ( ch, pObj ); if ( ( value = flag_value( size_flags, argument ) ) != NO_FLAG ) { pObj->size = value; send_to_char( "Size set.\n\r", ch ); return TRUE; } } send_to_char( "Syntax: size [size]\n\r" "Type '? size' for a list of sizes.\n\r", ch ); return FALSE; } /* * Mobile Editor Functions. */ MEDIT( medit_show ) { MOB_INDEX_DATA *pMob; char buf[MAX_STRING_LENGTH]; PROG_LIST *list; EDIT_MOB(ch, pMob); sprintf( buf, "Name: [%s]\n\rArea: [%5d] %s\n\r", pMob->player_name, !pMob->area ? -1 : pMob->area->vnum, !pMob->area ? "No Area" : pMob->area->name ); send_to_char( buf, ch ); sprintf( buf, "Act: [%s]\n\r", flag_string( act_flags, pMob->act ) ); send_to_char( buf, ch ); sprintf( buf, "Vnum: [%5d] Sex: [%s] Race: [%s]\n\r", pMob->vnum, pMob->sex == SEX_MALE ? "male " : pMob->sex == SEX_FEMALE ? "female " : pMob->sex == 3 ? "random " : "neutral", race_table[pMob->race].name ); send_to_char( buf, ch ); sprintf( buf, "Level: [%2d] Align: [%4d] Hitroll: [%2d] Dam Type: [%s]\n\r", pMob->level, pMob->alignment, pMob->hitroll, attack_table[pMob->dam_type].name ); send_to_char( buf, ch ); if ( pMob->group ) { sprintf( buf, "Group: [%5d]\n\r", pMob->group ); send_to_char( buf, ch ); } sprintf( buf, "Hit dice: [%2ldd%-3ld+%4ld] ", pMob->hit[DICE_NUMBER], pMob->hit[DICE_TYPE], pMob->hit[DICE_BONUS] ); send_to_char( buf, ch ); sprintf( buf, "Damage dice: [%2dd%-3d+%4d] ", pMob->damage[DICE_NUMBER], pMob->damage[DICE_TYPE], pMob->damage[DICE_BONUS] ); send_to_char( buf, ch ); sprintf( buf, "Mana dice: [%2ldd%-3ld+%4ld]\n\r", pMob->mana[DICE_NUMBER], pMob->mana[DICE_TYPE], pMob->mana[DICE_BONUS] ); send_to_char( buf, ch ); /* ROM values end */ sprintf( buf, "Affected by: [%s]\n\r", flag_string( affect_flags, pMob->affected_by ) ); send_to_char( buf, ch ); sprintf( buf, "Affected by: [%s]\n\r", flag_string( affect2_flags, pMob->affected2_by ) ); send_to_char( buf, ch ); /* ROM values: */ sprintf( buf, "Armor: [pierce: %d bash: %d slash: %d magic: %d]\n\r", pMob->ac[AC_PIERCE], pMob->ac[AC_BASH], pMob->ac[AC_SLASH], pMob->ac[AC_EXOTIC] ); send_to_char( buf, ch ); sprintf( buf, "Form: [%s]\n\r", flag_string( form_flags, pMob->form ) ); send_to_char( buf, ch ); sprintf( buf, "Parts: [%s]\n\r", flag_string( part_flags, pMob->parts ) ); send_to_char( buf, ch ); sprintf( buf, "Imm: [%s]\n\r", flag_string( imm_flags, pMob->imm_flags ) ); send_to_char( buf, ch ); sprintf( buf, "Res: [%s]\n\r", flag_string( res_flags, pMob->res_flags ) ); send_to_char( buf, ch ); sprintf( buf, "Vuln: [%s]\n\r", flag_string( vuln_flags, pMob->vuln_flags ) ); send_to_char( buf, ch ); sprintf( buf, "Off: [%s]\n\r", flag_string( off_flags, pMob->off_flags ) ); send_to_char( buf, ch ); sprintf( buf, "Size: [%s]\n\r", flag_string( size_flags, pMob->size ) ); send_to_char( buf, ch ); sprintf( buf, "Material: [%s]\n\r", pMob->material ); send_to_char( buf, ch ); sprintf( buf, "Start pos. [%s]\n\r", flag_string( position_flags, pMob->start_pos ) ); send_to_char( buf, ch ); sprintf( buf, "Default pos [%s]\n\r", flag_string( position_flags, pMob->default_pos ) ); send_to_char( buf, ch ); sprintf( buf, "Wealth: [%5ld]\n\r", pMob->wealth ); send_to_char( buf, ch ); sprintf( buf, "Clevel: [%5d]\n\r", pMob->cast_level ); send_to_char( buf, ch ); sprintf( buf, "Cability: [%5d]\n\r", pMob->cast_ability ); send_to_char( buf, ch ); printf_to_char( ch, "Aggression: [%5d]\n\r", pMob->aggression ); if ( IS_SET( pMob->act, ACT_PET ) ) { sprintf( buf, "Xp to level: [%5d]\n\r", pMob->xp_tolevel ); send_to_char( buf, ch ); } /* ROM values end */ if ( pMob->spec_fun ) { sprintf( buf, "Spec fun: [%s]\n\r", spec_name( pMob->spec_fun ) ); send_to_char( buf, ch ); } sprintf( buf, "Short descr: %s\n\rLong descr:\n\r%s", pMob->short_descr, pMob->long_descr ); send_to_char( buf, ch ); sprintf( buf, "Description:\n\r%s", pMob->description ); send_to_char( buf, ch ); if ( pMob->pShop ) { SHOP_DATA *pShop; int iTrade; pShop = pMob->pShop; sprintf( buf, "Shop data for [%5d]:\n\r" " Markup for purchaser: %d%%\n\r" " Markdown for seller: %d%%\n\r", pShop->keeper, pShop->profit_buy, pShop->profit_sell ); send_to_char( buf, ch ); sprintf( buf, " Hours: %d to %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] != 0 ) { if ( iTrade == 0 ) { send_to_char( " Number Trades Type\n\r", ch ); send_to_char( " ------ -----------\n\r", ch ); } sprintf( buf, " [%4d] %s\n\r", iTrade, flag_string( type_flags, pShop->buy_type[iTrade] ) ); send_to_char( buf, ch ); } } } if ( pMob->mprogs ) { int cnt; sprintf(buf, "\n\rMOBPrograms for [%5d]:\n\r", pMob->vnum); send_to_char( buf, ch ); for (cnt=0, list=pMob->mprogs; list; list=list->next) { if (cnt ==0) { send_to_char ( " Number Vnum Trigger Phrase\n\r", ch ); send_to_char ( " ------ ---- ------- ------\n\r", ch ); } sprintf(buf, "[%5d] %4d %7s %s\n\r", cnt, list->vnum,prog_type_to_name(list->trig_type), list->trig_phrase); send_to_char( buf, ch ); cnt++; } } return FALSE; } MEDIT( medit_create ) { MOB_INDEX_DATA *pMob; AREA_DATA *pArea; int value; int iHash; value = atoi( argument ); if ( argument[0] == '\0' || value == 0 ) { send_to_char( "Syntax: medit create [vnum]\n\r", ch ); return FALSE; } pArea = get_vnum_area( value ); if ( !pArea ) { send_to_char( "MEdit: That vnum is not assigned an area.\n\r", ch ); return FALSE; } if ( !IS_BUILDER( ch, pArea ) ) { send_to_char( "MEdit: Vnum in an area you cannot build in.\n\r", ch ); return FALSE; } if ( get_mob_index( value ) ) { send_to_char( "MEdit: 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; ch->desc->pEdit = (void *)pMob; send_to_char( "Mobile Created.\n\r", ch ); return TRUE; } MEDIT( medit_spec ) { MOB_INDEX_DATA *pMob; EDIT_MOB(ch, pMob); if ( argument[0] == '\0' ) { send_to_char( "Syntax: spec [special function]\n\r", ch ); return FALSE; } if ( !str_cmp( argument, "none" ) ) { pMob->spec_fun = NULL; send_to_char( "Spec removed.\n\r", ch); return TRUE; } if ( spec_lookup( argument ) != 0 ) { pMob->spec_fun = spec_lookup( argument ); send_to_char( "Spec set.\n\r", ch); return TRUE; } send_to_char( "MEdit: No such special function.\n\r", ch ); return FALSE; } MEDIT( medit_damtype ) { MOB_INDEX_DATA *pMob; EDIT_MOB(ch, pMob); if ( argument[0] == '\0' ) { send_to_char( "Syntax: damtype [damage message]\n\r", ch ); send_to_char( "Para ver una lista de tipos de mensajes, pon '? weapon'.\n\r", ch ); return FALSE; } pMob->dam_type = attack_lookup(argument); send_to_char( "Damage type set.\n\r", ch); return TRUE; } MEDIT( medit_align ) { MOB_INDEX_DATA *pMob; EDIT_MOB(ch, pMob); if ( argument[0] == '\0' || !is_number( argument ) ) { send_to_char( "Syntax: alignment [number]\n\r", ch ); return FALSE; } pMob->alignment = atoi( argument ); send_to_char( "Alignment set.\n\r", ch); return TRUE; } MEDIT( medit_level ) { MOB_INDEX_DATA *pMob; EDIT_MOB(ch, pMob); if ( argument[0] == '\0' || !is_number( argument ) ) { send_to_char( "Syntax: level [number]\n\r", ch ); return FALSE; } pMob->level = atoi( argument ); send_to_char( "Level set.\n\r", ch); return TRUE; } MEDIT( medit_experience ) { MOB_INDEX_DATA *pMob; int level; EDIT_MOB(ch, pMob); if ( argument[0] == '\0' || !is_number( argument ) ) { send_to_char( "Syntax: experience [number]\n\r", ch ); return FALSE; } level = atoi( argument ); if ( level < 1000 || level > 2500 ) { send_to_char("Please choose a value between 1000, and 2500.\n\r", ch ); return FALSE; } pMob->xp_tolevel = level; send_to_char( "Exp to Level 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_long ) { MOB_INDEX_DATA *pMob; EDIT_MOB(ch, pMob); if ( argument[0] == '\0' ) { send_to_char( "Syntax: 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_short ) { MOB_INDEX_DATA *pMob; EDIT_MOB(ch, pMob); if ( argument[0] == '\0' ) { send_to_char( "Syntax: 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_name ) { MOB_INDEX_DATA *pMob; EDIT_MOB(ch, pMob); if ( argument[0] == '\0' ) { send_to_char( "Syntax: 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_shop ) { MOB_INDEX_DATA *pMob; char command[MAX_INPUT_LENGTH]; char arg1[MAX_INPUT_LENGTH]; argument = one_argument( argument, command ); argument = one_argument( argument, arg1 ); EDIT_MOB(ch, pMob); if ( command[0] == '\0' ) { send_to_char( "Syntax: shop hours [#xopening] [#xclosing]\n\r", ch ); send_to_char( " shop profit [#xbuying%] [#xselling%]\n\r", ch ); send_to_char( " shop type [#x0-4] [item type]\n\r", ch ); send_to_char( " shop assign\n\r", ch ); send_to_char( " shop remove\n\r", ch ); return FALSE; } if ( !str_cmp( command, "hours" ) ) { if ( arg1[0] == '\0' || !is_number( arg1 ) || argument[0] == '\0' || !is_number( argument ) ) { send_to_char( "Syntax: shop hours [#xopening] [#xclosing]\n\r", ch ); return FALSE; } if ( !pMob->pShop ) { send_to_char( "MEdit: Debes crear un shop primero (shop assign).\n\r", ch ); return FALSE; } pMob->pShop->open_hour = atoi( arg1 ); pMob->pShop->close_hour = atoi( argument ); send_to_char( "Shop hours set.\n\r", ch); return TRUE; } if ( !str_cmp( command, "profit" ) ) { if ( arg1[0] == '\0' || !is_number( arg1 ) || argument[0] == '\0' || !is_number( argument ) ) { send_to_char( "Syntax: shop profit [#xbuying%] [#xselling%]\n\r", ch ); return FALSE; } if ( !pMob->pShop ) { send_to_char( "MEdit: Debes crear un shop primero (shop assign).\n\r", ch ); return FALSE; } pMob->pShop->profit_buy = atoi( arg1 ); pMob->pShop->profit_sell = atoi( argument ); send_to_char( "Shop profit set.\n\r", ch); return TRUE; } if ( !str_cmp( command, "type" ) ) { char buf[MAX_INPUT_LENGTH]; int value; if ( arg1[0] == '\0' || !is_number( arg1 ) || argument[0] == '\0' ) { send_to_char( "Syntax: shop type [#x0-4] [item type]\n\r", ch ); return FALSE; } if ( atoi( arg1 ) >= MAX_TRADE ) { sprintf( buf, "MEdit: May sell %d items max.\n\r", MAX_TRADE ); send_to_char( buf, ch ); return FALSE; } if ( !pMob->pShop ) { send_to_char( "MEdit: Debes crear un shop primero (shop assign).\n\r", ch ); return FALSE; } if ( ( value = flag_value( type_flags, argument ) ) == NO_FLAG ) { send_to_char( "MEdit: That type of item is not known.\n\r", ch ); return FALSE; } pMob->pShop->buy_type[atoi( arg1 )] = value; send_to_char( "Shop type set.\n\r", ch); return TRUE; } /* shop assign && shop delete by Phoenix */ if ( !str_prefix(command, "assign") ) { if ( pMob->pShop ) { send_to_char("Mob already has a shop assigned to it.\n\r", ch); return FALSE; } pMob->pShop = new_shop(); if ( !shop_first ) shop_first = pMob->pShop; if ( shop_last ) shop_last->next = pMob->pShop; shop_last = pMob->pShop; pMob->pShop->keeper = pMob->vnum; send_to_char("New shop assigned to mobile.\n\r", ch); return TRUE; } if ( !str_prefix(command, "remove") ) { SHOP_DATA *pShop; pShop = pMob->pShop; pMob->pShop = NULL; if ( pShop == shop_first ) { if ( !pShop->next ) { shop_first = NULL; shop_last = NULL; } else shop_first = pShop->next; } else { SHOP_DATA *ipShop; for ( ipShop = shop_first; ipShop; ipShop = ipShop->next ) { if ( ipShop->next == pShop ) { if ( !pShop->next ) { shop_last = ipShop; shop_last->next = NULL; } else ipShop->next = pShop->next; } } } free_shop(pShop); send_to_char("Mobile is no longer a shopkeeper.\n\r", ch); return TRUE; } medit_shop( ch, "" ); return FALSE; } /* ROM medit functions: */ MEDIT( medit_sex ) /* Moved out of medit() due to naming conflicts -- Hugin */ { MOB_INDEX_DATA *pMob; int value; if ( argument[0] != '\0' ) { EDIT_MOB( ch, pMob ); if ( ( value = flag_value( sex_flags, argument ) ) != NO_FLAG ) { pMob->sex = value; send_to_char( "Sex set.\n\r", ch); return TRUE; } } send_to_char( "Syntax: sex [sex]\n\r" "Type '? sex' for a list of flags.\n\r", ch ); return FALSE; } MEDIT( medit_act ) /* Moved out of medit() due to naming conflicts -- Hugin */ { MOB_INDEX_DATA *pMob; int value; if ( argument[0] != '\0' ) { EDIT_MOB( ch, pMob ); if ( ( value = flag_value( act_flags, argument ) ) != NO_FLAG ) { pMob->act ^= value; SET_BIT( pMob->act, ACT_IS_NPC ); send_to_char( "Act flag toggled.\n\r", ch); return TRUE; } } send_to_char( "Syntax: act [flag]\n\r" "Type '? act' for a list of flags.\n\r", ch ); return FALSE; } MEDIT( medit_affect ) /* Moved out of medit() due to naming conflicts -- Hugin */ { MOB_INDEX_DATA *pMob; int value; if ( argument[0] != '\0' ) { EDIT_MOB( ch, pMob ); if ( ( value = flag_value( affect_flags, argument ) ) != NO_FLAG ) { pMob->affected_by ^= value; send_to_char( "Affect flag toggled.\n\r", ch); return TRUE; } } send_to_char( "Syntax: affect [flag]\n\r" "Type '? affect' for a list of flags.\n\r", ch ); return FALSE; } MEDIT( medit_affect2 ) { MOB_INDEX_DATA *pMob; int value; if ( argument[0] != '\0' ) { EDIT_MOB( ch, pMob ); if ( ( value = flag_value( affect2_flags, argument ) ) != NO_FLAG ) { pMob->affected2_by ^= value; send_to_char( "Affect2 flag toggled.\n\r", ch); return TRUE; } } send_to_char( "Syntax: affect2 [flag]\n\r" "Type '? affect2' for a list of flags.\n\r", ch ); return FALSE; } MEDIT( medit_ac ) { MOB_INDEX_DATA *pMob; char arg[MAX_INPUT_LENGTH]; int pierce, bash, slash, exotic; do /* So that I can use break and send the syntax in one place */ { if ( argument[0] == '\0' ) break; EDIT_MOB(ch, pMob); argument = one_argument( argument, arg ); if ( !is_number( arg ) ) break; pierce = atoi( arg ); argument = one_argument( argument, arg ); if ( arg[0] != '\0' ) { if ( !is_number( arg ) ) break; bash = atoi( arg ); argument = one_argument( argument, arg ); } else bash = pMob->ac[AC_BASH]; if ( arg[0] != '\0' ) { if ( !is_number( arg ) ) break; slash = atoi( arg ); argument = one_argument( argument, arg ); } else slash = pMob->ac[AC_SLASH]; if ( arg[0] != '\0' ) { if ( !is_number( arg ) ) break; exotic = atoi( arg ); } else exotic = pMob->ac[AC_EXOTIC]; pMob->ac[AC_PIERCE] = pierce; pMob->ac[AC_BASH] = bash; pMob->ac[AC_SLASH] = slash; pMob->ac[AC_EXOTIC] = exotic; send_to_char( "Ac set.\n\r", ch ); return TRUE; } while ( FALSE ); /* Just do it once.. */ send_to_char( "Syntax: ac [ac-pierce [ac-bash [ac-slash [ac-exotic]]]]\n\r" "help MOB_AC gives a list of reasonable ac-values.\n\r", ch ); return FALSE; } MEDIT( medit_form ) { MOB_INDEX_DATA *pMob; int value; if ( argument[0] != '\0' ) { EDIT_MOB( ch, pMob ); if ( ( value = flag_value( form_flags, argument ) ) != NO_FLAG ) { pMob->form ^= value; send_to_char( "Form toggled.\n\r", ch ); return TRUE; } } send_to_char( "Syntax: form [flags]\n\r" "Type '? form' for a list of flags.\n\r", ch ); return FALSE; } MEDIT( medit_part ) { MOB_INDEX_DATA *pMob; int value; if ( argument[0] != '\0' ) { EDIT_MOB( ch, pMob ); if ( ( value = flag_value( part_flags, argument ) ) != NO_FLAG ) { pMob->parts ^= value; send_to_char( "Parts toggled.\n\r", ch ); return TRUE; } } send_to_char( "Syntax: part [flags]\n\r" "Type '? part' for a list of flags.\n\r", ch ); return FALSE; } MEDIT( medit_imm ) { MOB_INDEX_DATA *pMob; int value; if ( argument[0] != '\0' ) { EDIT_MOB( ch, pMob ); if ( ( value = flag_value( imm_flags, argument ) ) != NO_FLAG ) { pMob->imm_flags ^= value; send_to_char( "Immunity toggled.\n\r", ch ); return TRUE; } } send_to_char( "Syntax: imm [flags]\n\r" "Type '? imm' for a list of flags.\n\r", ch ); return FALSE; } MEDIT( medit_res ) { MOB_INDEX_DATA *pMob; int value; if ( argument[0] != '\0' ) { EDIT_MOB( ch, pMob ); if ( ( value = flag_value( res_flags, argument ) ) != NO_FLAG ) { pMob->res_flags ^= value; send_to_char( "Resistance toggled.\n\r", ch ); return TRUE; } } send_to_char( "Syntax: res [flags]\n\r" "Type '? res' for a list of flags.\n\r", ch ); return FALSE; } MEDIT( medit_vuln ) { MOB_INDEX_DATA *pMob; int value; if ( argument[0] != '\0' ) { EDIT_MOB( ch, pMob ); if ( ( value = flag_value( vuln_flags, argument ) ) != NO_FLAG ) { pMob->vuln_flags ^= value; send_to_char( "Vulnerability toggled.\n\r", ch ); return TRUE; } } send_to_char( "Syntax: vuln [flags]\n\r" "Type '? vuln' for a list of flags.\n\r", ch ); return FALSE; } MEDIT( medit_material ) { MOB_INDEX_DATA *pMob; EDIT_MOB(ch, pMob); if ( argument[0] == '\0' ) { send_to_char( "Syntax: material [string]\n\r", ch ); return FALSE; } free_string( pMob->material ); pMob->material = str_dup( argument ); send_to_char( "Material set.\n\r", ch); return TRUE; } MEDIT( medit_off ) { MOB_INDEX_DATA *pMob; int value; if ( argument[0] != '\0' ) { EDIT_MOB( ch, pMob ); if ( ( value = flag_value( off_flags, argument ) ) != NO_FLAG ) { pMob->off_flags ^= value; send_to_char( "Offensive behaviour toggled.\n\r", ch ); return TRUE; } } send_to_char( "Syntax: off [flags]\n\r" "Type '? off' for a list of flags.\n\r", ch ); return FALSE; } MEDIT( medit_size ) { MOB_INDEX_DATA *pMob; int value; if ( argument[0] != '\0' ) { EDIT_MOB( ch, pMob ); if ( ( value = flag_value( size_flags, argument ) ) != NO_FLAG ) { pMob->size = value; send_to_char( "Size set.\n\r", ch ); return TRUE; } } send_to_char( "Syntax: size [size]\n\r" "Type '? size' for a list of sizes.\n\r", ch ); return FALSE; } MEDIT( medit_hitdice ) { static char syntax[] = "Syntax: hitdice <number> d <type> + <bonus>\n\r"; char *num, *type, *bonus, *cp; MOB_INDEX_DATA *pMob; EDIT_MOB( ch, pMob ); if ( argument[0] == '\0' ) { send_to_char( syntax, ch ); return FALSE; } num = cp = argument; while ( isdigit( *cp ) ) ++cp; while ( *cp != '\0' && !isdigit( *cp ) ) *(cp++) = '\0'; type = cp; while ( isdigit( *cp ) ) ++cp; while ( *cp != '\0' && !isdigit( *cp ) ) *(cp++) = '\0'; bonus = cp; while ( isdigit( *cp ) ) ++cp; if ( *cp != '\0' ) *cp = '\0'; if ( ( !is_number( num ) || atoi( num ) < 1 ) || ( !is_number( type ) || atoi( type ) < 1 ) || ( !is_number( bonus ) || atoi( bonus ) < 0 ) ) { send_to_char( syntax, ch ); return FALSE; } pMob->hit[DICE_NUMBER] = atoi( num ); pMob->hit[DICE_TYPE] = atoi( type ); pMob->hit[DICE_BONUS] = atoi( bonus ); send_to_char( "Hitdice set.\n\r", ch ); return TRUE; } MEDIT( medit_manadice ) { static char syntax[] = "Syntax: manadice <number> d <type> + <bonus>\n\r"; char *num, *type, *bonus, *cp; MOB_INDEX_DATA *pMob; EDIT_MOB( ch, pMob ); if ( argument[0] == '\0' ) { send_to_char( syntax, ch ); return FALSE; } num = cp = argument; while ( isdigit( *cp ) ) ++cp; while ( *cp != '\0' && !isdigit( *cp ) ) *(cp++) = '\0'; type = cp; while ( isdigit( *cp ) ) ++cp; while ( *cp != '\0' && !isdigit( *cp ) ) *(cp++) = '\0'; bonus = cp; while ( isdigit( *cp ) ) ++cp; if ( *cp != '\0' ) *cp = '\0'; if ( !( is_number( num ) && is_number( type ) && is_number( bonus ) ) ) { send_to_char( syntax, ch ); return FALSE; } if ( ( !is_number( num ) || atoi( num ) < 1 ) || ( !is_number( type ) || atoi( type ) < 1 ) || ( !is_number( bonus ) || atoi( bonus ) < 0 ) ) { send_to_char( syntax, ch ); return FALSE; } pMob->mana[DICE_NUMBER] = atoi( num ); pMob->mana[DICE_TYPE] = atoi( type ); pMob->mana[DICE_BONUS] = atoi( bonus ); send_to_char( "Manadice set.\n\r", ch ); return TRUE; } MEDIT( medit_damdice ) { static char syntax[] = "Syntax: damdice <number> d <type> + <bonus>\n\r"; char *num, *type, *bonus, *cp; MOB_INDEX_DATA *pMob; EDIT_MOB( ch, pMob ); if ( argument[0] == '\0' ) { send_to_char( syntax, ch ); return FALSE; } num = cp = argument; while ( isdigit( *cp ) ) ++cp; while ( *cp != '\0' && !isdigit( *cp ) ) *(cp++) = '\0'; type = cp; while ( isdigit( *cp ) ) ++cp; while ( *cp != '\0' && !isdigit( *cp ) ) *(cp++) = '\0'; bonus = cp; while ( isdigit( *cp ) ) ++cp; if ( *cp != '\0' ) *cp = '\0'; if ( !( is_number( num ) && is_number( type ) && is_number( bonus ) ) ) { send_to_char( syntax, ch ); return FALSE; } if ( ( !is_number( num ) || atoi( num ) < 1 ) || ( !is_number( type ) || atoi( type ) < 1 ) || ( !is_number( bonus ) || atoi( bonus ) < 0 ) ) { send_to_char( syntax, ch ); return FALSE; } pMob->damage[DICE_NUMBER] = atoi( num ); pMob->damage[DICE_TYPE] = atoi( type ); pMob->damage[DICE_BONUS] = atoi( bonus ); send_to_char( "Damdice set.\n\r", ch ); return TRUE; } MEDIT( medit_race ) { MOB_INDEX_DATA *pMob; int race; if ( argument[0] != '\0' && ( race = race_lookup( argument ) ) != 0 ) { EDIT_MOB( ch, pMob ); pMob->race = race; pMob->act |= race_table[race].act; pMob->affected_by |= race_table[race].aff; pMob->off_flags |= race_table[race].off; pMob->imm_flags |= race_table[race].imm; pMob->res_flags |= race_table[race].res; pMob->vuln_flags |= race_table[race].vuln; pMob->form |= race_table[race].form; pMob->parts |= race_table[race].parts; send_to_char( "Race set.\n\r", ch ); return TRUE; } if ( argument[0] == '?' ) { char buf[MAX_STRING_LENGTH]; send_to_char( "Available races are:", ch ); for ( race = 0; race_table[race].name != NULL; race++ ) { if ( ( race % 3 ) == 0 ) send_to_char( "\n\r", ch ); sprintf( buf, " %-15s", race_table[race].name ); send_to_char( buf, ch ); } send_to_char( "\n\r", ch ); return FALSE; } send_to_char( "Syntax: race [race]\n\r" "Type 'race ?' for a list of races.\n\r", ch ); return FALSE; } MEDIT( medit_position ) { MOB_INDEX_DATA *pMob; char arg[MAX_INPUT_LENGTH]; int value; argument = one_argument( argument, arg ); switch ( arg[0] ) { default: break; case 'S': case 's': if ( str_prefix( arg, "start" ) ) break; if ( ( value = flag_value( position_flags, argument ) ) == NO_FLAG ) break; EDIT_MOB( ch, pMob ); pMob->start_pos = value; send_to_char( "Start position set.\n\r", ch ); return TRUE; case 'D': case 'd': if ( str_prefix( arg, "default" ) ) break; if ( ( value = flag_value( position_flags, argument ) ) == NO_FLAG ) break; EDIT_MOB( ch, pMob ); pMob->default_pos = value; send_to_char( "Default position set.\n\r", ch ); return TRUE; } send_to_char( "Syntax: position [start/default] [position]\n\r" "Type '? position' for a list of positions.\n\r", ch ); return FALSE; } MEDIT( medit_gold ) { MOB_INDEX_DATA *pMob; EDIT_MOB(ch, pMob); if ( argument[0] == '\0' || !is_number( argument ) ) { send_to_char( "Syntax: wealth [number]\n\r", ch ); return FALSE; } pMob->wealth = atoi( argument ); send_to_char( "Wealth set.\n\r", ch); return TRUE; } MEDIT( medit_hitroll ) { MOB_INDEX_DATA *pMob; EDIT_MOB(ch, pMob); if ( argument[0] == '\0' || !is_number( argument ) ) { send_to_char( "Syntax: hitroll [number]\n\r", ch ); return FALSE; } pMob->hitroll = atoi( argument ); send_to_char( "Hitroll set.\n\r", ch); return TRUE; } void show_liqlist(CHAR_DATA *ch) { int liq; BUFFER *buffer; char buf[MAX_STRING_LENGTH]; buffer = new_buf(); for ( liq = 0; liq_table[liq].liq_name != NULL; liq++) { if ( (liq % 21) == 0 ) add_buf(buffer,"Name Color Proof Full Thirst Food Ssize\n\r"); sprintf(buf, "%-20s %-14s %5d %4d %6d %4d %5d\n\r", liq_table[liq].liq_name,liq_table[liq].liq_color, liq_table[liq].liq_affect[0],liq_table[liq].liq_affect[1], liq_table[liq].liq_affect[2],liq_table[liq].liq_affect[3], liq_table[liq].liq_affect[4] ); add_buf(buffer,buf); } page_to_char(buf_string(buffer),ch); free_buf(buffer); return; } void show_damlist(CHAR_DATA *ch) { int att; BUFFER *buffer; char buf[MAX_STRING_LENGTH]; buffer = new_buf(); for ( att = 0; attack_table[att].name != NULL; att++) { if ( (att % 21) == 0 ) add_buf(buffer,"Name Noun\n\r"); sprintf(buf, "%-20s %-20s\n\r", attack_table[att].name,attack_table[att].noun ); add_buf(buffer,buf); } page_to_char(buf_string(buffer),ch); free_buf(buffer); return; } MEDIT( medit_group ) { MOB_INDEX_DATA *pMob; MOB_INDEX_DATA *pMTemp; char arg[MAX_STRING_LENGTH]; char buf[MAX_STRING_LENGTH]; int temp; BUFFER *buffer; bool found = FALSE; EDIT_MOB(ch, pMob); if ( argument[0] == '\0' ) { send_to_char( "Syntax: group [number]\n\r", ch); send_to_char( " group show [number]\n\r", ch); return FALSE; } if (is_number(argument)) { pMob->group = atoi(argument); send_to_char( "Group set.\n\r", ch ); return TRUE; } argument = one_argument( argument, arg ); if ( !strcmp( arg, "show" ) && is_number( argument ) ) { if (atoi(argument) == 0) { send_to_char( "Are you crazy?\n\r", ch); return FALSE; } buffer = new_buf (); for (temp = 0; temp < 65536; temp++) { pMTemp = get_mob_index(temp); if ( pMTemp && ( pMTemp->group == atoi(argument) ) ) { found = TRUE; sprintf( buf, "[%5d] %s\n\r", pMTemp->vnum, pMTemp->player_name ); add_buf( buffer, buf ); } } if (found) page_to_char( buf_string(buffer), ch ); else send_to_char( "No mobs in that group.\n\r", ch ); free_buf( buffer ); return FALSE; } return FALSE; } REDIT( redit_owner ) { ROOM_INDEX_DATA *pRoom; EDIT_ROOM(ch, pRoom); if ( argument[0] == '\0' ) { send_to_char( "Syntax: owner [owner]\n\r", ch ); send_to_char( " owner none\n\r", ch ); return FALSE; } free_string( pRoom->owner ); if (!str_cmp(argument, "none")) pRoom->owner = str_dup(""); else pRoom->owner = str_dup( argument ); send_to_char( "Owner set.\n\r", ch ); return TRUE; } MEDIT ( medit_addmprog ) { int value; MOB_INDEX_DATA *pMob; PROG_LIST *list; PROG_CODE *code; char trigger[MAX_STRING_LENGTH]; char phrase[MAX_STRING_LENGTH]; char num[MAX_STRING_LENGTH]; EDIT_MOB(ch, pMob); argument=one_argument(argument, num); argument=one_argument(argument, trigger); argument=one_argument(argument, phrase); if (!is_number(num) || trigger[0] =='\0' || phrase[0] =='\0' ) { send_to_char("Syntax: addmprog [vnum] [trigger] [phrase]\n\r",ch); return FALSE; } if ( (value = flag_value (mprog_flags, trigger) ) == NO_FLAG) { send_to_char("Valid flags are:\n\r",ch); show_help( ch, "mprog"); return FALSE; } if ( ( code = get_prog_index (atoi(num), PRG_MPROG ) ) == NULL) { send_to_char("No such MOBProgram.\n\r",ch); return FALSE; } list = new_mprog(); list->vnum = atoi(num); list->trig_type = value; list->trig_phrase = str_dup(phrase); list->code = code->code; SET_BIT(pMob->mprog_flags,value); list->next = pMob->mprogs; pMob->mprogs = list; send_to_char( "Mprog Added.\n\r",ch); return TRUE; } MEDIT ( medit_delmprog ) { MOB_INDEX_DATA *pMob; PROG_LIST *list; PROG_LIST *list_next; char mprog[MAX_STRING_LENGTH]; int value; int cnt = 0; EDIT_MOB(ch, pMob); one_argument( argument, mprog ); if (!is_number( mprog ) || mprog[0] == '\0' ) { send_to_char("Syntax: delmprog [#mprog]\n\r",ch); return FALSE; } value = atoi ( mprog ); if ( value < 0 ) { send_to_char("Only non-negative mprog-numbers allowed.\n\r",ch); return FALSE; } if ( !(list= pMob->mprogs) ) { send_to_char("MEdit: Non existant mprog.\n\r",ch); return FALSE; } if ( value == 0 ) { REMOVE_BIT(pMob->mprog_flags, pMob->mprogs->trig_type); list = pMob->mprogs; pMob->mprogs = list->next; free_mprog( list ); } else { while ( (list_next = list->next) && (++cnt < value ) ) list = list_next; if ( list_next ) { REMOVE_BIT(pMob->mprog_flags, list_next->trig_type); list->next = list_next->next; free_mprog(list_next); } else { send_to_char("No such mprog.\n\r",ch); return FALSE; } } send_to_char("Mprog removed.\n\r", ch); return TRUE; } REDIT( redit_room ) { ROOM_INDEX_DATA *room; int value; EDIT_ROOM(ch, room); if ( !str_cmp( argument, "postal" ) || !str_cmp( argument, "post" ) ) { new_postal( ch ); return FALSE; } if ( (value = flag_value( room_flags, argument )) == NO_FLAG ) { send_to_char( "Sintaxis: room [flags]\n\r", ch ); return FALSE; } TOGGLE_BIT(room->room_flags, value); send_to_char( "Room flags toggled.\n\r", ch ); printf_to_char( ch, "Here is the value %d\n\r", value ); return TRUE; } REDIT( redit_sector ) { ROOM_INDEX_DATA *room; int value; EDIT_ROOM(ch, room); if ( (value = flag_value( sector_flags, argument )) == NO_FLAG ) { send_to_char( "Sintaxis: sector [tipo]\n\r", ch ); return FALSE; } room->sector_type = value; send_to_char( "Sector type set.\n\r", ch ); return TRUE; } REDIT( redit_mineral ) { ROOM_INDEX_DATA *room; int value, mineral; char arg1[MSL], arg2[MSL]; argument = one_argument(argument, arg1 ); argument = one_argument(argument, arg2 ); EDIT_ROOM(ch, room); if(arg1[0] == '\0' || arg2[0] == '\0' ) { send_to_char("Syntax: mineral <mineral> <percentage to find>\n\r",ch); return FALSE; } if ( !is_number(arg2)) { send_to_char( "The percentage must be a number.\n\r", ch ); return FALSE; } if( (value = atoi(arg2) ) > 100 || value < 0 ) { send_to_char("Must be between 0 and 100.\n\r",ch); return FALSE; } if( ( mineral = mineral_lookup(arg1) ) == -1 ) { send_to_char("What type of mineral is that!?\n\r",ch); return FALSE; } room->mineral[mineral] = value; printf_to_char(ch, "%s now has a %d percent chance of being found.\n\r", mineral_table[mineral], value ); return TRUE; } OEDIT ( oedit_addoprog ) { int value; OBJ_INDEX_DATA *pObj; PROG_LIST *list; PROG_CODE *code; char trigger[MAX_STRING_LENGTH]; char phrase[MAX_STRING_LENGTH]; char num[MAX_STRING_LENGTH]; EDIT_OBJ(ch, pObj); argument=one_argument(argument, num); argument=one_argument(argument, trigger); if (!is_number(num) || trigger[0] =='\0' || argument[0] == '\0' ) { send_to_char("Syntax: addoprog [vnum] [trigger] [phrase]\n\r",ch); return FALSE; } if ( (value = flag_value (oprog_flags, trigger) ) == NO_FLAG) { send_to_char("Valid flags are:\n\r",ch); show_help( ch, "oprog"); return FALSE; } if( value != TRIG_ALIAS ) argument=one_argument(argument, phrase); else sprintf(phrase, "%s", argument ); if ( ( code =get_prog_index (atoi(num), PRG_OPROG ) ) == NULL) { send_to_char("No such OBJProgram.\n\r",ch); return FALSE; } list = new_oprog(); list->vnum = atoi(num); list->trig_type = value; list->trig_phrase = str_dup(phrase); list->code = code->code; SET_BIT(pObj->oprog_flags,value); list->next = pObj->oprogs; pObj->oprogs = list; send_to_char( "Oprog Added.\n\r",ch); return TRUE; } OEDIT ( oedit_deloprog ) { OBJ_INDEX_DATA *pObj; PROG_LIST *list; PROG_LIST *list_next; char oprog[MAX_STRING_LENGTH]; int value; int cnt = 0; EDIT_OBJ(ch, pObj); one_argument( argument, oprog ); if (!is_number( oprog ) || oprog[0] == '\0' ) { send_to_char("Syntax: deloprog [#oprog]\n\r",ch); return FALSE; } value = atoi ( oprog ); if ( value < 0 ) { send_to_char("Only non-negative oprog-numbers allowed.\n\r",ch); return FALSE; } if ( !(list= pObj->oprogs) ) { send_to_char("OEdit: Non existant oprog.\n\r",ch); return FALSE; } if ( value == 0 ) { REMOVE_BIT(pObj->oprog_flags, pObj->oprogs->trig_type); list = pObj->oprogs; pObj->oprogs = list->next; free_oprog( list ); } else { while ( (list_next = list->next) && (++cnt < value ) ) list = list_next; if ( list_next ) { REMOVE_BIT(pObj->oprog_flags, list_next->trig_type); list->next = list_next->next; free_oprog(list_next); } else { send_to_char("No such oprog.\n\r",ch); return FALSE; } } send_to_char("Oprog removed.\n\r", ch); return TRUE; } REDIT ( redit_addrprog ) { int value; ROOM_INDEX_DATA *pRoom; PROG_LIST *list; PROG_CODE *code; char trigger[MAX_STRING_LENGTH]; char phrase[MAX_STRING_LENGTH]; char num[MAX_STRING_LENGTH]; EDIT_ROOM(ch, pRoom); argument=one_argument(argument, num); argument=one_argument(argument, trigger); argument=one_argument(argument, phrase); if (!is_number(num) || trigger[0] =='\0' || phrase[0] =='\0' ) { send_to_char("Syntax: addrprog [vnum] [trigger] [phrase]\n\r",ch); return FALSE; } if ( (value = flag_value (rprog_flags, trigger) ) == NO_FLAG) { send_to_char("Valid flags are:\n\r",ch); show_help( ch, "rprog"); return FALSE; } if ( ( code =get_prog_index (atoi(num), PRG_RPROG ) ) == NULL) { send_to_char("No such ROOMProgram.\n\r",ch); return FALSE; } list = new_rprog(); list->vnum = atoi(num); list->trig_type = value; list->trig_phrase = str_dup(phrase); list->code = code->code; SET_BIT(pRoom->rprog_flags,value); list->next = pRoom->rprogs; pRoom->rprogs = list; send_to_char( "Rprog Added.\n\r",ch); return TRUE; } REDIT ( redit_delrprog ) { ROOM_INDEX_DATA *pRoom; PROG_LIST *list; PROG_LIST *list_next; char rprog[MAX_STRING_LENGTH]; int value; int cnt = 0; EDIT_ROOM(ch, pRoom); one_argument( argument, rprog ); if (!is_number( rprog ) || rprog[0] == '\0' ) { send_to_char("Syntax: delrprog [#rprog]\n\r",ch); return FALSE; } value = atoi ( rprog ); if ( value < 0 ) { send_to_char("Only non-negative rprog-numbers allowed.\n\r",ch); return FALSE; } if ( !(list= pRoom->rprogs) ) { send_to_char("REdit: Non existant rprog.\n\r",ch); return FALSE; } if ( value == 0 ) { REMOVE_BIT(pRoom->rprog_flags, pRoom->rprogs->trig_type); list = pRoom->rprogs; pRoom->rprogs = list->next; free_rprog( list ); } else { while ( (list_next = list->next) && (++cnt < value ) ) list = list_next; if ( list_next ) { REMOVE_BIT(pRoom->rprog_flags, list_next->trig_type); list->next = list_next->next; free_rprog(list_next); } else { send_to_char("No such rprog.\n\r",ch); return FALSE; } } send_to_char("Rprog removed.\n\r", ch); return TRUE; } OEDIT( oedit_autoweapon ) { OBJ_INDEX_DATA *pObj; AFFECT_DATA *pAf; int dice, size, bonus; double avg; EDIT_OBJ(ch, pObj); if (pObj->item_type != ITEM_WEAPON) { send_to_char( " {rAutoweapn only works on weapons...{x\n\r", ch); return FALSE; } if (pObj->level < 1) { send_to_char( " {cAutoweapon requires a level to be set on the weapon first.{x\n\r", ch); return FALSE; } bonus = UMAX(0, pObj->level/10 - 1); /* adjust this next line to change the avg dmg your weapons will get! */ avg = (pObj->level * .76); dice = (pObj->level/10 + 1); size = dice/2; for (size=dice/2 ; dice * (size +2)/2 < avg ; size++ ) { } dice = UMAX(1, dice); size = UMAX(2, size); switch (pObj->value[0]) { default: case WEAPON_EXOTIC: case WEAPON_BOW: case WEAPON_SWORD: break; case WEAPON_DAGGER: dice = UMAX(1, dice - 1); size = UMAX(2, size - 1); break; case WEAPON_SPEAR: case WEAPON_POLEARM: size++; break; case WEAPON_MACE: case WEAPON_AXE: size = UMAX(2,size - 1); break; case WEAPON_FLAIL: case WEAPON_WHIP: dice = UMAX(1, dice - 1); break; } dice = UMAX(1, dice); size = UMAX(2, size); pObj->cost = 25 * (size * (dice + 1)) + 20 * bonus + 20 * pObj->level; pObj->weight = pObj->level + 1; pObj->value[1] = dice; pObj->value[2] = size; if (bonus > 0) { pAf = new_affect(); pAf->location = APPLY_DAMROLL; pAf->modifier = bonus; pAf->where = TO_OBJECT; pAf->type = -1; pAf->duration = -1; pAf->bitvector = 0; pAf->level = pObj->level; pAf->next = pObj->affected; pObj->affected = pAf; pAf = new_affect(); pAf->location = APPLY_HITROLL; pAf->modifier = bonus; pAf->where = TO_OBJECT; pAf->type = -1; pAf->duration = -1; pAf->bitvector = 0; pAf->level = pObj->level; pAf->next = pObj->affected; pObj->affected = pAf; } send_to_char(" {cExperimental values set on weapon...{x\n\r", ch); return TRUE; } OEDIT( oedit_autoarmor ) { OBJ_INDEX_DATA *pObj; int size; EDIT_OBJ(ch, pObj); if (pObj->item_type != ITEM_ARMOR) { send_to_char( " {rAutoArmor only works on Armor ...{x\n\r", ch); return FALSE; } if (pObj->level < 1) { send_to_char( " {cAutoArmor requires a level to be set on the armor first.{x\n\r", ch); return FALSE; } size = UMAX(1, pObj->level/2.8 + 1); pObj->weight = pObj->level + 1; pObj->cost = pObj->level^2 * 2; pObj->value[0] = size; pObj->value[1] = size; pObj->value[2] = size; pObj->value[3] = (size - 1); send_to_char( " {cAutoArmor has set experimental values for AC.{x\n\r", ch); return TRUE; } MEDIT( medit_clevel ) { MOB_INDEX_DATA *pMob; int amount = 0; EDIT_MOB(ch, pMob); if ( argument[0] == '\0' || !is_number( argument ) ) { send_to_char( "Syntax: clevel [number]\n\r", ch ); return FALSE; } amount = atoi( argument ); if ( amount < 0 || amount > 10 ) { send_to_char( "Please choose an amount between 0 and 10.\n\r", ch ); return FALSE; } pMob->cast_level = amount; send_to_char( "Cast level set.\n\r", ch); return TRUE; } MEDIT( medit_cability ) { MOB_INDEX_DATA *pMob; int amount = 0; EDIT_MOB(ch, pMob); if ( argument[0] == '\0' || !is_number( argument ) ) { send_to_char( "Syntax: cability [number]\n\r", ch ); return FALSE; } amount = atoi( argument ); if ( amount < 0 || amount > 10 ) { send_to_char( "Please choose an amount between 0 and 10.\n\r", ch ); return FALSE; } pMob->cast_ability = amount; send_to_char( "Cast ability set.\n\r", ch); return TRUE; } /** Function: gedit_flags * Descr : Sets the various flags associated with guilds. * Returns : True/False if changed. * Syntax : flags flag_id... * Written : v1.0 3/98 * Author : Gary McNickle <gary@dharvest.com> */ GEDIT( gedit_flags ) { CLAN_DATA *pClan; long value = 0; if ( argument[0] != '\0' ) { EDIT_GUILD( ch, pClan ); if ( ( value = flag_value( guild_flags, argument ) ) != NO_FLAG ) { pClan->flags ^= value; send_to_char( "Guild flag(s) toggled.\n\r", ch); return TRUE; } } send_to_char( "Syntax: flag [flag ID]\n\r" "Type '? guild' for a list of valid flags.\n\r", ch ); return FALSE; } /** Function: gedit_rank * Descr : Sets the guild rank name * Returns : True/False if changed. * Syntax : rank rank_id rank_name * Written : v1.0 3/98 * Author : Gary McNickle <gary@dharvest.com> */ GEDIT( gedit_rank ) { CLAN_DATA *pClan; char arg1[4]; EDIT_GUILD(ch, pClan); argument = one_argument(argument, arg1); if (is_number(arg1) && atoi(arg1) <= MAX_RANK) { int value; value = atoi(arg1) -1; if (argument[0] != '\0') { free_string(pClan->rank[value].rankname); pClan->rank[value].rankname = str_dup( argument ); send_to_char("Rank name changed.\n\r", ch); return TRUE; } } send_to_char("Syntax: rank rank# newname\n\r", ch); return FALSE; } /** Function: gedit_skill * Descr : Sets the skills associated with the various ranks. * Returns : True/False if changed & notice if skill dosent exist. * Syntax : skill rank_# skill_name * Written : v1.0 3/98 * Author : Gary McNickle <gary@dharvest.com> */ GEDIT( gedit_skill ) { CLAN_DATA *pClan; char arg1[4]; EDIT_GUILD(ch, pClan); argument = one_argument(argument, arg1); if (is_number(arg1) && atoi(arg1) <= MAX_RANK) { int value; value = atoi(arg1) -1; if (argument[0] != '\0') { free_string(pClan->rank[value].skillname); pClan->rank[value].skillname = str_dup( argument ); if (skill_lookup(argument) == -1) send_to_char("Notice: That skill does not exist.\n\r", ch); send_to_char("Skill changed.\n\r", ch); return TRUE; } } send_to_char("Syntax: skill rank# newskill\n\r", ch); return FALSE; } /** Function: gedit_create * Descr : Creates a new, empty guild if room is available in the array. * Returns : True/False if created * Syntax : (n/a) * Written : v1.0 3/98 * Author : Gary McNickle <gary@dharvest.com> */ GEDIT( gedit_create ) { int i = 0; for (i=1; i < MAX_CLAN; i++) /* just loop through and find an open slot */ { if (clan_lookup(clan_table[i].name) == 0) break; } if (i <= MAX_CLAN) /* open slot */ { CLAN_DATA *pClan; int x; clan_table[i].name = str_dup("NewGuild"); clan_table[i].who_name = str_dup("New Guild"); for (x = 0; x < MAX_RANK; x++) { clan_table[i].rank[x].rankname = str_dup("Empty"); clan_table[i].rank[x].skillname = str_dup(""); } pClan = &clan_table[i]; /* return new clan data */ ch->desc->pEdit = pClan; send_to_char("Guild created.\n\r", ch); return TRUE; } send_to_char("No room to create a new guild. Increase MAX_CLAN\n\r", ch); return FALSE; } /** Function: gedit_list * Descr : List's all of the current guilds, including those not yet * : saved to the data file, and those marked for deletion. * Returns : list of guilds. * Syntax : (N/A) * Written : v1.0 3/98 Updated on 5/98 * Author : Gary McNickle <gary#dharvest,com> */ GEDIT( gedit_list ) { char buf[MIL]; BUFFER *buffer; int i; int count = 0; buffer = new_buf(); sprintf(buf, "Num Guild Name Flags\n\r" "-----------------------------------------------\n\r"); add_buf(buffer, buf); for (i=1; i < MAX_CLAN; i++) { if (clan_table[i].name != NULL && clan_table[i].name[0] != '\0') { count++; sprintf(buf,"[%2d] %-30s [%s]\n\r", i, clan_table[i].name, flag_string( guild_flags, clan_table[i].flags ) ); add_buf(buffer, buf); } } sprintf(buf,"\n\r-----------------------------------------------\n\r" "There are %d slots available for new guilds.\n\r", MAX_CLAN - count); add_buf(buffer, buf); page_to_char( buf_string(buffer), ch ); free_buf(buffer); return FALSE; } /** Function: gedit_show * Descr : Displays currently selected guild data to the screen. * Returns : (N/A) * Syntax : (N/A) * Written : v1.0 3/98 * Author : Gary McNickle <gary@dharvest.com> */ GEDIT( gedit_show ) { CLAN_DATA *pClan; char buf[MIL]; BUFFER *buffer; int i; EDIT_GUILD(ch, pClan); buffer = new_buf(); sprintf(buf, "Name : %s %s %s\n\rWho Name : %-10s\n\r", pClan->name, IS_SET(pClan->flags, GUILD_CHANGED) ? "`c[`B*`c]`w" : "", IS_SET(pClan->flags, GUILD_DELETED) ? "`RMarked for Deletion!`w" : "", pClan->who_name); add_buf(buffer, buf); sprintf(buf, "Recall Room [%-6d] Morgue Room [%-6d] Clan Temple [%-6d]\n\r\n\r", pClan->room[0], pClan->room[1], pClan->room[2]); add_buf(buffer, buf); sprintf(buf, "Flags: [%s]\n\r\n\r", flag_string( guild_flags, pClan->flags ) ); add_buf(buffer, buf); sprintf(buf, "# Rank Skill Associated with this Rank\n\r--------------------------------------------------------------\n\r"); add_buf(buffer, buf); for (i=0; i < MAX_RANK; i++) { sprintf(buf,"[%2d] %-25s %s\n\r", i+1, (pClan->rank[i].rankname != '\0') ? pClan->rank[i].rankname : "None", (pClan->rank[i].skillname != '\0') ? pClan->rank[i].skillname : ""); add_buf(buffer, buf); } add_buf(buffer,"\n\r"); sprintf(buf, "Mortal Leader Rights\n\r--------------------\n\r"); add_buf(buffer, buf); sprintf(buf,"Can Guild : %s\n\rCan Deguild : %s\n\rCan Promote : %s\n\rCan Demote : %s\n\r", (pClan->ml[0]==1) ? "True" : "False", (pClan->ml[1]==1) ? "True" : "False", (pClan->ml[2]==1) ? "True" : "False", (pClan->ml[3]==1) ? "True" : "False"); add_buf(buffer, buf); page_to_char( buf_string(buffer), ch ); free_buf(buffer); return FALSE; } /** Function: gedit_name * Descr : Changes the name of the currently selected guild. * Returns : True/False if modified * Syntax : name new_name * Written : v1.0 3/98 * Author : Gary McNickle <gary@dharvest.com> */ GEDIT( gedit_name ) { CLAN_DATA *pClan; EDIT_GUILD(ch, pClan); if ( argument[0] == '\0' ) { send_to_char( "Syntax: name [name]\n\r", ch ); return FALSE; } if (clan_lookup(argument) != 0) { send_to_char("That guild allready exists.\n\r", ch); return FALSE; } if (pClan->name[0] != '\0') free_string( pClan->name ); pClan->name = str_dup( argument ); send_to_char( "Name set.\n\r", ch ); return TRUE; } /** Function: gedit_whoname * Descr : Changes the who_name of the currently selected guild. * Returns : True/False if modified. * Syntax : whoname new_who_name * Written : v1.0 3/98 * Author : Gary McNickle <gary@dharvest.com> */ GEDIT( gedit_whoname ) { CLAN_DATA *pClan; EDIT_GUILD(ch, pClan); if ( argument[0] == '\0' ) { send_to_char( "Syntax: whoname [name]\n\r", ch ); return FALSE; } if (pClan->who_name[0] != '\0') free_string( pClan->who_name ); pClan->who_name = str_dup( argument ); send_to_char( "Who Name set.\n\r", ch ); return TRUE; } /** Function: gedit_rooms * Descr : Changes the vnum of the room(s) selected. * Returns : True/False if modified. * Syntax : rooms [hall new#|morgue new#|temple new#] * Written : v1.0 3/98 * Author : Gary McNickle <gary@dharvest.com> */ GEDIT( gedit_rooms ) { CLAN_DATA *pClan; char arg1[10], arg2[10], arg3[10], arg4[10], arg5[10], arg6[10]; bool set = FALSE; EDIT_GUILD(ch, pClan); if ( argument[0] == '\0' ) { send_to_char( "Syntax: rooms [hall #|morgue #|temple #]\n\r", ch ); return FALSE; } 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); argument = one_argument(argument, arg6); /* kinda of convoluted, I know, but this seemed the easiest way to allow for any combination of commands. ie: hall 1 morgue 2 temple 3 morgue 2 hall 3 temple 1 or even hall 1 morgue 2 hall 1 */ if (!str_cmp(arg1,"hall") && is_number(arg2) ) { pClan->room[0] = atoi(arg2); set = TRUE; } else if (!str_cmp(arg1,"morgue") && is_number(arg2) ) { pClan->room[1] = atoi(arg2); set = TRUE; } else if (!str_cmp(arg1,"temple") && is_number(arg2) ) { pClan->room[2] = atoi(arg2); set = TRUE; } if (!str_cmp(arg3,"hall") && is_number(arg4) ) { pClan->room[0] = atoi(arg4); set = TRUE; } else if (!str_cmp(arg3,"morgue") && is_number(arg4) ) { pClan->room[1] = atoi(arg4); set = TRUE; } else if (!str_cmp(arg3,"temple") && is_number(arg4) ) { pClan->room[2] = atoi(arg4); set = TRUE; } if (!str_cmp(arg5,"hall") && is_number(arg6) ) { pClan->room[0] = atoi(arg6); set = TRUE; } else if (!str_cmp(arg5,"morgue") && is_number(arg6) ) { pClan->room[1] = atoi(arg6); set = TRUE; } else if (!str_cmp(arg5,"temple") && is_number(arg6) ) { pClan->room[2] = atoi(arg6); set = TRUE; } if (set) { send_to_char("Room(s) set.\n\r", ch); return TRUE; } return FALSE; } /** Function: gedit_ml * Descr : Changes the mortal leader settings. * Returns : True/False if modified * Syntax : ml [true/false|true/false|true/false|true/false] * Written : v1.0 3/98 * Author : Gary McNickle <gary@dharvest.com> */ GEDIT( gedit_ml ) { CLAN_DATA *pClan; char arg1[6], arg2[6], arg3[6], arg4[6]; bool set = FALSE; EDIT_GUILD(ch, pClan); if ( argument[0] == '\0' ) { send_to_char( "Syntax: ml TRUE|FALSE TRUE|FALSE TRUE|FALSE TRUE|FALSE\n\r", ch ); return FALSE; } argument = one_argument(argument, arg1); argument = one_argument(argument, arg2); argument = one_argument(argument, arg3); argument = one_argument(argument, arg4); if (!str_prefix(arg1,"true") ) { pClan->ml[0] = TRUE; set = TRUE; } else if (!str_prefix(arg1, "false") ) { pClan->ml[0] = FALSE; set = TRUE; } if (!str_prefix(arg2,"true") ) { pClan->ml[1] = TRUE; set = TRUE; } else if (!str_prefix(arg2, "false") ) { pClan->ml[1] = FALSE; set = TRUE; } if (!str_prefix(arg3,"true") ) { pClan->ml[2] = TRUE; set = TRUE; } else if (!str_prefix(arg3, "false") ) { pClan->ml[2] = FALSE; set = TRUE; } if (!str_prefix(arg4,"true") ) { pClan->ml[3] = TRUE; set = TRUE; } else if (!str_prefix(arg4, "false") ) { pClan->ml[3] = FALSE; set = TRUE; } if (set) { send_to_char("Mortal Leader traits set.\n\r", ch); return TRUE; } return FALSE; } void unlink_reset (ROOM_INDEX_DATA * pRoom, RESET_DATA * pReset) { RESET_DATA *prev, *wReset; prev = pRoom->reset_first; for (wReset = pRoom->reset_first; wReset; wReset = wReset->next) { if (wReset == pReset) { if (pRoom->reset_first == pReset) { pRoom->reset_first = pReset->next; if (!pRoom->reset_first) pRoom->reset_last = NULL; } else if (pRoom->reset_last == pReset) { pRoom->reset_last = prev; prev->next = NULL; } else prev->next = prev->next->next; if (pRoom->reset_first == pReset) pRoom->reset_first = pReset->next; if (!pRoom->reset_first) pRoom->reset_last = NULL; } prev = wReset; } } void unlink_obj_index (OBJ_INDEX_DATA * pObj) { int iHash; OBJ_INDEX_DATA *iObj, *sObj; iHash = pObj->vnum % MAX_KEY_HASH; sObj = obj_index_hash[iHash]; if (sObj->next == NULL) obj_index_hash[iHash] = NULL; else if (sObj == pObj) obj_index_hash[iHash] = pObj->next; else { for (iObj = sObj; iObj != NULL; iObj = iObj->next) { if (iObj == pObj) { sObj->next = pObj->next; break; } sObj = iObj; } } } void unlink_room_index (ROOM_INDEX_DATA * pRoom) { int iHash; ROOM_INDEX_DATA *iRoom, *sRoom; iHash = pRoom->vnum % MAX_KEY_HASH; sRoom = room_index_hash[iHash]; if (sRoom->next == NULL) room_index_hash[iHash] = NULL; else if (sRoom == pRoom) room_index_hash[iHash] = pRoom->next; else { for (iRoom = sRoom; iRoom != NULL; iRoom = iRoom->next) { if (iRoom == pRoom) { sRoom->next = pRoom->next; break; } sRoom = iRoom; } } } void unlink_mob_index (MOB_INDEX_DATA * pMob) { int iHash; MOB_INDEX_DATA *iMob, *sMob; iHash = pMob->vnum % MAX_KEY_HASH; sMob = mob_index_hash[iHash]; if (sMob->next == NULL) mob_index_hash[iHash] = NULL; else if (sMob == pMob) mob_index_hash[iHash] = pMob->next; else { for (iMob = sMob; iMob != NULL; iMob = iMob->next) { if (iMob == pMob) { sMob->next = pMob->next; break; } sMob = iMob; } } } MEDIT (medit_delete) { CHAR_DATA *wch, *wnext; MOB_INDEX_DATA *pMob; RESET_DATA *pReset, *wReset; ROOM_INDEX_DATA *pRoom; char arg[MIL]; int pIndex, i; int mcount, rcount, iHash; bool foundmob = FALSE; bool foundobj = FALSE; if (IS_NULLSTR (argument)) { if (ch) send_to_char ("Syntax: medit delete [vnum]\n\r", ch); return FALSE; } one_argument (argument, arg); if (is_number (arg)) { pIndex = atol (arg); pMob = get_mob_index (pIndex); } else { if (ch) send_to_char ("That is not a number.\n\r", ch); return FALSE; } for (i = 0; vnum_table[i].vnum != NULL; i++) { if (vnum_table[i].type != VNUM_MOB) continue; if (*vnum_table[i].vnum == pIndex) { if (ch) send_to_char ("That vnum is reserved.\n\r", ch); return FALSE; } } if (!pMob) { if (ch) send_to_char ("No such mobile.\n\r", ch); return FALSE; } stop_editing (pMob); SET_BIT (pMob->area->area_flags, AREA_CHANGED); if (top_vnum_mob == pIndex) for (i = 1; i < pIndex; i++) if (get_mob_index (i)) top_vnum_mob = i; top_mob_index--; rcount = 0; mcount = 0; for (iHash = 0; iHash < MAX_KEY_HASH; iHash++) { for (pRoom = room_index_hash[iHash]; pRoom; pRoom = pRoom->next) { for (wch = pRoom->people; wch; wch = wnext) { wnext = wch->next_in_room; if (wch->pIndexData == pMob) { extract_char (wch, TRUE); mcount++; } } for (pReset = pRoom->reset_first; pReset; pReset = wReset) { wReset = pReset->next; switch (pReset->command) { case 'M': if (pReset->arg1 == pIndex) { foundmob = TRUE; unlink_reset (pRoom, pReset); free_reset_data (pReset); rcount++; SET_BIT (pRoom->area->area_flags, AREA_CHANGED); } else foundmob = FALSE; break; case 'E': case 'G': if (foundmob) { foundobj = TRUE; unlink_reset (pRoom, pReset); free_reset_data (pReset); rcount++; SET_BIT (pRoom->area->area_flags, AREA_CHANGED); } else foundobj = FALSE; break; case '0': foundobj = FALSE; break; case 'P': if (foundobj && foundmob) { unlink_reset (pRoom, pReset); free_reset_data (pReset); rcount++; SET_BIT (pRoom->area->area_flags, AREA_CHANGED); } } } } } unlink_mob_index (pMob); pMob->area = NULL; pMob->vnum = 0; free_mob_index (pMob); if (ch) { printf_to_char (ch, "Removed mobile vnum {C%ld{x and {C%d{x resets.\n\r", pIndex, rcount); printf_to_char (ch, "{C%d{x mobiles were extracted" " from the mud.\n\r", mcount); } return TRUE; } OEDIT (oedit_delete) { OBJ_DATA *obj, *obj_next; OBJ_INDEX_DATA *pObj; RESET_DATA *pReset, *wReset; ROOM_INDEX_DATA *pRoom; char arg[MIL]; int pIndex, i; int rcount, ocount, iHash; if (IS_NULLSTR (argument)) { if (ch) send_to_char ("Syntax: oedit delete [vnum]\n\r", ch); return FALSE; } one_argument (argument, arg); if (is_number (arg)) { pIndex = atol (arg); pObj = get_obj_index (pIndex); } else { if (ch) send_to_char ("That is not a number.\n\r", ch); return FALSE; } for (i = 0; vnum_table[i].vnum != NULL; i++) { if (vnum_table[i].type != VNUM_OBJ) continue; if (*vnum_table[i].vnum == pIndex) { if (ch) send_to_char ("That vnum is reserved.\n\r", ch); return FALSE; } } if (!pObj) { if (ch) send_to_char ("No such object.\n\r", ch); return FALSE; } stop_editing (pObj); SET_BIT (pObj->area->area_flags, AREA_CHANGED); if (top_vnum_obj == pIndex) for (i = 1; i < pIndex; i++) if (get_obj_index (i)) top_vnum_obj = i; top_obj_index--; ocount = 0; for (obj = object_list; obj; obj = obj_next) { obj_next = obj->next; if (obj->pIndexData == pObj) { extract_obj (obj); ocount++; } } rcount = 0; for (iHash = 0; iHash < MAX_KEY_HASH; iHash++) { for (pRoom = room_index_hash[iHash]; pRoom; pRoom = pRoom->next) { for (pReset = pRoom->reset_first; pReset; pReset = wReset) { wReset = pReset->next; switch (pReset->command) { case 'O': case 'E': case 'P': case 'G': if ((pReset->arg1 == pIndex) || ((pReset->command == 'P') && (pReset->arg3 == pIndex))) { unlink_reset (pRoom, pReset); free_reset_data (pReset); rcount++; SET_BIT (pRoom->area->area_flags, AREA_CHANGED); } } } } } unlink_obj_index (pObj); pObj->area = NULL; pObj->vnum = 0; free_obj_index (pObj); if (ch) { printf_to_char (ch, "Removed object vnum {C%ld{x and" " {C%d{x resets.\n\r", pIndex, rcount); printf_to_char (ch, "{C%d{x occurences of the object" " were extracted from the mud.\n\r", ocount); } return TRUE; } REDIT (redit_delete) { ROOM_INDEX_DATA *pRoom, *pRoom2; RESET_DATA *pReset; EXIT_DATA *ex; OBJ_DATA *Obj, *obj_next; CHAR_DATA *wch, *wnext; EXTRA_DESCR_DATA *pExtra; char arg[MIL]; int pIndex, v; int i, iHash, rcount, ecount, mcount, ocount, edcount; if (IS_NULLSTR (argument)) { if (ch) send_to_char ("Syntax: redit delete [vnum]\n\r", ch); return FALSE; } one_argument (argument, arg); if (is_number (arg)) { pIndex = atol (arg); pRoom = get_room_index (pIndex); } else { if (ch) send_to_char ("That is not a number.\n\r", ch); return FALSE; } for (i = 0; vnum_table[i].vnum != NULL; i++) { if (vnum_table[i].type != VNUM_ROOM) continue; if (*vnum_table[i].vnum == pIndex) { if (ch) send_to_char ("That vnum is reserved.\n\r", ch); return FALSE; } } if (!pRoom) { if (ch) send_to_char ("No such room.\n\r", ch); return FALSE; } stop_editing (pRoom); SET_BIT (pRoom->area->area_flags, AREA_CHANGED); rcount = 0; for (pReset = pRoom->reset_first; pReset; pReset = pReset->next) { rcount++; } ocount = 0; for (Obj = pRoom->contents; Obj; Obj = obj_next) { obj_next = Obj->next_content; extract_obj (Obj); ocount++; } mcount = 0; for (wch = pRoom->people; wch; wch = wnext) { wnext = wch->next_in_room; if (IS_NPC (wch)) { extract_char (wch, TRUE); mcount++; } else { send_to_char ("This room is being deleted. Moving you somewhere safe.\n\r", wch); if (wch->fighting != NULL) stop_fighting (wch, TRUE); char_from_room (wch); char_to_room (wch, get_room_index (ROOM_VNUM_TEMPLE)); wch->was_in_room = wch->in_room; } } ecount = 0; for (iHash = 0; iHash < MAX_KEY_HASH; iHash++) { for (pRoom2 = room_index_hash[iHash]; pRoom2; pRoom2 = pRoom2->next) { for (i = 0; i < MAX_DIR; i++) { if (!(ex = pRoom2->exit[i])) continue; if (pRoom2 == pRoom) { ecount++; continue; } if (ex->u1.to_room == pRoom) { free_exit (ex); pRoom2->exit[i] = NULL; SET_BIT (pRoom2->area->area_flags, AREA_CHANGED); ecount++; } } } } edcount = 0; for (pExtra = pRoom->extra_descr; pExtra; pExtra = pExtra->next) { edcount++; } if (top_vnum_room == pIndex) for (v = 1; v < pIndex; v++) if (get_room_index (v)) top_vnum_room = v; top_room--; unlink_room_index (pRoom); pRoom->area = NULL; pRoom->vnum = 0; free_room_index (pRoom); if (ch) { printf_to_char (ch, "Removed room vnum {C%ld{x, %d resets, %d extra " "descriptions and %d exits.\n\r", pIndex, rcount, edcount, ecount); printf_to_char (ch, "{C%d{x objects and {C%d{x mobiles were extracted " "from the room.\n\r", ocount, mcount); } return TRUE; } OEDIT( oedit_addspell ) { OBJ_INDEX_DATA *pObj; AFFECT_DATA *pAf; int sn; EDIT_OBJ(ch, pObj); if(argument[0]=='\0') { send_to_char("Syntax: addapply <spellname>\n\r",ch); return FALSE; } sn = skill_lookup(argument); if (sn == -1) { send_to_char("No such spell.\n\r",ch); return FALSE; } pAf = new_affect(); pAf->where = TO_AFFECTS; pAf->type = sn; pAf->level = pObj->level; pAf->duration = -1; pAf->location = APPLY_SPELL_AFFECT; pAf->modifier = 0; pAf->bitvector = 0; pAf->level = pObj->level; pAf->next = pObj->affected; pObj->affected = pAf; send_to_char("Apply added.\n\r", ch); return TRUE; } AEDIT( aedit_continent ) { AREA_DATA *pArea; int i = 0; EDIT_AREA(ch, pArea); if(ch->pcdata->security < 9) { send_to_char("You cannot set continents for areas.\n\r",ch); return FALSE; } if(argument[0] != '\0') { if( ( i = cont_lookup(argument) ) != -1 ) { send_to_char("Continent for area set.\n\r",ch); pArea->continent = i; return TRUE; } else { send_to_char("Valid continents are:\n\r",ch); for(i = 0 ; i < MAX_CONT; i++) printf_to_char(ch, "%s\n\r", cont_table[i] ); return FALSE; } } send_to_char("Valid continents are:\n\r",ch); for(i = 0 ; i < MAX_CONT; i++) printf_to_char(ch, "%s\n\r", cont_table[i] ); return FALSE; } AEDIT (aedit_complete) { AREA_DATA *pArea; EDIT_AREA(ch, pArea); if(!is_admin(ch) ) { send_to_char("Only admins can deam an area copmlete.\n\r",ch); return FALSE; } if(IS_SET(pArea->area_flags, AREA_COMPLETE ) ) { REMOVE_BIT(pArea->area_flags, AREA_COMPLETE ); send_to_char("Area is now incomplete.\n\r",ch); return TRUE; } SET_BIT(pArea->area_flags, AREA_COMPLETE ); send_to_char("Area is now complete.\n\r",ch); return TRUE; } SKEDIT( skedit_show ) { int sn; int i; char spkell[MSL]; EDIT_SKILL(ch, sn); if(skill_table[sn].spell_fun == spell_null ) sprintf(spkell, "{WSkill"); else sprintf(spkell, "{WSpell"); printf_to_char(ch, "%s {D:{W %s\n\r", spkell, skill_table[sn].name); printf_to_char(ch, "%s level {D:{W ",spkell); for (i = 0;i < MAX_CLASS ; i++ ) printf_to_char(ch, "%s{D[{W%-3d{D]{W ", capitalize(class_table[i].name), skill_table[sn].skill_level[i] ); send_to_char("\n\r",ch); printf_to_char(ch, "%s rating {D:{W ", spkell); for (i = 0;i < MAX_CLASS ; i++ ) printf_to_char(ch, "%s{D[{W%-3d{D]{W ", capitalize(class_table[i].name), skill_table[sn].rating[i] ); send_to_char("\n\r",ch); printf_to_char(ch, "{WSpell Fun {D: {W%s\n\r{W",spellfun_table[find_spellfun(skill_table[sn].spell_fun)].name ); printf_to_char(ch, "Target {D: {W%s\n\r{W",target_table[skill_table[sn].target].name ); printf_to_char(ch, "Position {D: {W%s\n\r{W",position_table[skill_table[sn].minimum_position].name); printf_to_char(ch, "Minimum Mana {D: {W%d\n\r{W",skill_table[sn].min_mana); printf_to_char(ch, "Beats {D: {W%d\n\r{W",skill_table[sn].beats); printf_to_char(ch, "Noun Damage {D: {W%s\n\r{W", skill_table[sn].noun_damage ); printf_to_char(ch, "Message Off {D: {W%s\n\r{W", skill_table[sn].msg_off); printf_to_char(ch, "Obj Msg Off {D: {W%s\n\r{x", skill_table[sn].msg_obj); return TRUE; } SKEDIT( skedit_list ) { int i, col = 0; char arg[MSL]; argument = one_argument(argument,arg); if(arg[0] == '\0' ) { send_to_char("Which number would you like to start from?\n\r",ch); return FALSE; } if(!is_number(arg) ) { send_to_char("Must be a number.\n\r",ch); return FALSE; } for( i = atoi(arg) ; i < MAX_SKILL ; i++ ) { printf_to_char(ch, "{c[{C({c%2d{C) {R%15s{c]{x ",i, skill_table[i].name ); if ( ++col % 4 == 0 ) send_to_char( "\n\r", ch); } return TRUE; } SKEDIT( skedit_name ) { int sn; EDIT_SKILL(ch, sn); if (argument[0] == '\0') { send_to_char("Syntax: name [name]\n\r",ch); return FALSE; } if( skill_lookup(argument) != -1 ) { send_to_char("There is already a skill/spell by that name.\n\r",ch); return FALSE; } free_string(skill_table[sn].name); skill_table[sn].name = str_dup(capitalize(argument) ); send_to_char("Name set.\n\r",ch); return TRUE; } SKEDIT(skedit_level) { int sn; int level, iClass; char arg[MSL], arg2[MSL]; EDIT_SKILL(ch, sn); argument = one_argument(argument,arg); argument = one_argument(argument,arg2); if(arg[0] == '\0' || arg2[0] == '\0') { send_to_char("Syntax: rating <class> <level>\n\r",ch); return FALSE; } if( (iClass = class_lookup(arg) ) == -1 ) { send_to_char("No such class. Valid classes are:\n\r",ch); for(iClass = 0; iClass < MAX_CLASS ; iClass++) printf_to_char(ch, "%s, ", class_table[iClass].name ); return FALSE; } if(!is_number(arg2) ) { send_to_char("It must be a number!\n\r",ch); return FALSE; } if ( ( (level = atoi(arg2) ) < 0 ) || level > MAX_LEVEL ) { printf_to_char(ch, "The level must be between 0, and %s",MAX_LEVEL ); return FALSE; } skill_table[sn].skill_level[iClass] = level; printf_to_char(ch, "Level for %s class, set to %d.\n\r",class_table[iClass].name, level); return TRUE; } SKEDIT(skedit_rating) { int sn; int level, iClass; char arg[MSL], arg2[MSL]; EDIT_SKILL(ch, sn); argument = one_argument(argument,arg); argument = one_argument(argument,arg2); if(arg[0] == '\0' || arg2[0] == '\0') { send_to_char("Syntax: level <class> <level>\n\r",ch); return FALSE; } if( (iClass = class_lookup(arg) ) == -1 ) { send_to_char("No such class. Valid classes are:\n\r",ch); for(iClass = 0; iClass < MAX_CLASS ; iClass++) printf_to_char(ch, "%s, ", class_table[iClass].name ); return FALSE; } if(!is_number(arg2) ) { send_to_char("It must be a number!\n\r",ch); return FALSE; } if ( ( (level = atoi(arg2) ) < 0 ) || level > 12 ) { printf_to_char(ch, "The rating must be between 0, and 12" ); return FALSE; } skill_table[sn].rating[iClass] = level; printf_to_char(ch, "Rating for %s class, set to %d.\n\r",class_table[iClass].name, level); return TRUE; } SKEDIT(skedit_spellfun) { int sn, sf; EDIT_SKILL(ch,sn); if(argument[0] == '\0') { send_to_char("Syntax: spellfun <spellfun>\n\r",ch); return FALSE; } sf = spellfun_lookup(argument); skill_table[sn].spell_fun = spellfun_table[sf].spell_fun; if(sf == 0 ) { printf_to_char(ch, "Spellfunction set to spell_null. Either because you set it there, or you spell function was not valid.\n\r",ch); return TRUE; } printf_to_char(ch, "Spell function set to %s.\n\r",spellfun_table[sf].name ); return TRUE; } SKEDIT(skedit_target) { int sn, targ; EDIT_SKILL(ch,sn); if(argument[0] == '\0' ) { send_to_char("Syntax: target '<targetname>'",ch); send_to_char("Valid targets:\n\r",ch); for(targ = 0; target_table[targ].name != NULL ; targ++) printf_to_char(ch, "'%s', ", target_table[targ].name); return FALSE; } if( (targ = target_lookup(argument) ) == -1 ) { send_to_char("Not a valid target. Valid targets:\n\r",ch); for(targ = 0; target_table[targ].name != NULL ; targ++) printf_to_char(ch, "'%s', ", target_table[targ].name); return FALSE; } skill_table[sn].target = target_table[targ].bit; printf_to_char(ch, "Target set to %s.\n\r",target_table[targ].name); return TRUE; } SKEDIT( skedit_position ) { int sn, pos; EDIT_SKILL(ch, sn); if(argument[0] == '\0') { send_to_char("Syntax: position <position>\n\r",ch); return FALSE; } if ( ( pos = position_lookup(argument) ) == -1 ) { send_to_char("That isn't a valid position.\n\r",ch); return FALSE; } printf_to_char(ch, "The Minimum position is set to %s.\n\r",position_table[pos].name); skill_table[sn].minimum_position = pos; return TRUE; } SKEDIT(skedit_mana) { int sn, value; EDIT_SKILL(ch, sn); if(argument[0] == '\0' ) { send_to_char("Syntax: mana <minimum amount of mana>\n\r",ch); return FALSE; } if(!is_number(argument) ) { send_to_char("It has to be a number.\n\r",ch); return FALSE; } if( ((value = atoi(argument) ) < 1 ) || value > 1000 ) { send_to_char("It must be greatter than one, but less than 1000.\n\r",ch); return FALSE; } printf_to_char(ch, "Minimum mana set to %d",value); skill_table[sn].min_mana = value; return TRUE; } SKEDIT(skedit_beats) { int sn, value; EDIT_SKILL(ch, sn); if(argument[0] == '\0' ) { send_to_char("Syntax: beats <#beats>\n\r",ch); return FALSE; } if(!is_number(argument) ) { send_to_char("It must be a number!\n\r",ch); return FALSE; } if( ( (value = atoi(argument) ) < 0 ) || value > 100 ) { send_to_char("Beats must be greater than 0 and less than 100!\n\r",ch); return FALSE; } printf_to_char(ch, "Beats have been set to %d\n\r", value); skill_table[sn].beats = value; return TRUE; } SKEDIT( skedit_nound ) { int sn; EDIT_SKILL(ch,sn ); if(argument[0] == '\0' ) { send_to_char("Syntax: damage <noun>\n\r",ch); return FALSE; } free_string(skill_table[sn].noun_damage); skill_table[sn].noun_damage = str_dup(argument); printf_to_char(ch, "The damage noun is set to %s.\n\r",argument); return TRUE; } SKEDIT( skedit_msg_off) { int sn; EDIT_SKILL(ch,sn ); if(argument[0] == '\0' ) { send_to_char("Syntax: msgoff <message>\n\r",ch); return FALSE; } free_string(skill_table[sn].msg_off); skill_table[sn].msg_off = str_dup(argument); printf_to_char(ch, "The message off is set to %s.\n\r",argument); return TRUE; } SKEDIT( skedit_msg_obj ) { int sn; EDIT_SKILL(ch,sn ); if(argument[0] == '\0' ) { send_to_char("Syntax: msgobj <noun>\n\r",ch); return FALSE; } free_string(skill_table[sn].msg_obj); skill_table[sn].msg_obj = str_dup(argument); printf_to_char(ch, "The message obj is set to %s.\n\r",argument); return TRUE; } SKEDIT( skedit_new ) { DESCRIPTOR_DATA *d; struct skill_type *skill_temp; bool *tempgen; sh_int *templearn; int i; if(argument[0] == '\0' ) { send_to_char("Syntax: new <name>\n\r",ch); return FALSE; } if( (skill_lookup(argument) ) != -1 ) { send_to_char("There is already a skill by that name.\n\r",ch); return FALSE; } MAX_SKILL++; skill_temp = (skill_type *)realloc(skill_table, sizeof(struct skill_type) * MAX_SKILL ); skill_table = skill_temp; skill_table[MAX_SKILL-1].name = str_dup(capitalize(argument)); for( i = 0 ; i < MAX_CLASS ; i++ ) { skill_table[MAX_SKILL-1].skill_level[i] = 0; skill_table[MAX_SKILL-1].rating[i] = 0; } skill_table[MAX_SKILL-1].target = 0; skill_table[MAX_SKILL-1].minimum_position = 0; skill_table[MAX_SKILL-1].slot = 0; skill_table[MAX_SKILL-1].min_mana = 0; skill_table[MAX_SKILL-1].beats = 0; skill_table[MAX_SKILL-1].noun_damage = str_dup(""); skill_table[MAX_SKILL-1].msg_off = str_dup(""); skill_table[MAX_SKILL-1].msg_obj = str_dup(""); skill_table[MAX_SKILL-1].spell_fun = spell_null; for( d = descriptor_list ; d ; d = d->next ) { CHAR_DATA *rch; rch = d->original ? d->original : d->character; if( (d->connected != CON_PLAYING ) && (rch) && rch->gen_data ) { tempgen = (bool *)realloc(rch->gen_data->skill_chosen, sizeof(bool ) *MAX_SKILL ); rch->gen_data->skill_chosen = tempgen; rch->gen_data->skill_chosen[MAX_SKILL-1] = 0; } if( (d->connected == CON_PLAYING ) && rch && !IS_NPC(ch) ) { templearn = (sh_int *)realloc(rch->pcdata->learned, sizeof(sh_int) * MAX_SKILL ); rch->pcdata->learned = templearn; rch->pcdata->learned[MAX_SKILL-1] = 0; } } ch->desc->pEdit = (void *) ((long int)MAX_SKILL-1); return TRUE; } MEDIT( medit_autoset ) { MOB_INDEX_DATA *pMob; char arg1[MIL], arg2a[MIL], buff[MSL] = "Syntax: auto [easy/normal/tank/hard] [level]\n\rauto [impossible]\n\r"; int damd[3]={0,0,0}, hitd[3]={0,0,0}, ac[2]={0,0}, hitr=0, dice=0, size=0, bonus=0, arg2=0; EDIT_MOB( ch, pMob ); argument = first_arg (argument, arg1, TRUE); argument = first_arg (argument, arg2a, TRUE); if(IS_NULLSTR(arg1) || (!is_number(arg2a))) { send_to_char(buff, ch); tail_chain(); return FALSE; } arg2 = atoi(arg2a); if((!str_cmp(arg1, "i")) && (arg2 > 150 || arg2 < 1)) { send_to_char("Level must be between 1 and 150 for mobiles.",ch); tail_chain(); return FALSE; } switch (LOWER (arg1[0])) { case 'e': /*officially declare what values*/ sprintf(buff,"Easy"); /*calculate easy ac values*/ ac[1] = 99 - (arg2 * 6.37) - ((arg2/10)^2); ac[2] = 99 - (arg2 * 4.27) - ((arg2/10)^2); /*calculate easy damage values*/ dice = arg2/3; if (dice < 1) dice = 1; dice++; size = (.87 + arg2/dice); if (size < 2) size = 2; bonus = (7.5 + arg2/1.5); damd[1]=dice; damd[2]=size; damd[3]=bonus; /*calculate hitroll value*/ hitr = arg2; /*calculate easy hitdice and manadice values*/ dice = (arg2 + .5) * 2 + .2; if (dice < 1) dice = 1; size = arg2/3; if (size < 2) size = 2; bonus = (arg2/59 + 1) * ((arg2 * 9) + (arg2/11)) +1; hitd[1]=dice; hitd[2]=size; hitd[3]=bonus; break; case 'n': /*officially declare what values*/ sprintf(buff,"Normal"); /*calculate normal ac values*/ ac[1] = 95 - (arg2 * 6.67) - ((arg2/10)^2); ac[2] = 95 - (arg2 * 4.57) - ((arg2/10)^2); /*calculate normal damage values*/ dice = arg2/3; if (dice < 1) dice = 1; size = (.87 + arg2/dice); if (size < 2) size = 2; bonus = (5.5 + arg2/2); damd[1]=dice; damd[2]=size; damd[3]=bonus; /*calculate hitroll value*/ hitr=arg2; /*calculate normal hitdice and manadice values*/ dice = (arg2 + .5) * 2 + .2; if (dice < 1) dice = 1; size = arg2/3; if (size < 2) size = 2; bonus = (arg2/53 + 1) * ((arg2 * 10) + (arg2/10)) +1; hitd[1]=dice; hitd[2]=size; hitd[3]=bonus; break; case 't': /*officially declare what values*/ sprintf(buff,"Tank"); /*calculate insane ac values*/ ac[1] = 80 - (arg2 * 9.05) - ((arg2/10)^2); ac[2] = 80 - (arg2 * 7.02) - ((arg2/10)^2); /*calculate easy damage values*/ dice = arg2; size = (.87 + arg2) * .95; bonus = (2.5 + arg2/2.1); damd[1]=dice; damd[2]=size; damd[3]=bonus; /*calculate easy hitroll value*/ hitr=arg2; /*calculate hard hitdice and manadice values*/ dice = (arg2 + .6) * 2.05 + .5; if (dice < 1) dice = 1; size = arg2/3; if (size < 2) size = 2; size++; bonus = (arg2/53 + 1) * ((arg2 * 10) + (arg2/10)) +1; hitd[1]=dice; hitd[2]=size; hitd[3]=bonus; break; case 'h': /*officially declare what values*/ sprintf(buff,"Hard"); /*calculate hard ac values*/ ac[1] = 88 - (arg2 * 7.05) - ((arg2/10)^2); ac[2] = 88 - (arg2 * 5.02) - ((arg2/10)^2); /*calculate hard damage values*/ dice = arg2; size = (.87 + arg2) * .95; bonus = (2.5 + arg2/2.1); damd[1]=dice; damd[2]=size; damd[3]=bonus; /*calculate hitroll value*/ hitr=arg2; /*calculate hard hitdice and manadice values*/ dice = (arg2 + .6) * 2.05 + .5; if (dice < 1) dice = 1; size = arg2/3; if (size < 2) size = 2; size++; bonus = (arg2/53 + 1) * ((arg2 * 10) + (arg2/10)) +1; hitd[1]=dice; hitd[2]=size; hitd[3]=bonus; break; case 'i': /* Auto Impossible */ pMob->level = 250; pMob->hitroll = 1000; pMob->hit[DICE_NUMBER] = 1; pMob->hit[DICE_TYPE] = 1; pMob->hit[DICE_BONUS] = 10000; pMob->mana[DICE_NUMBER] = 1; pMob->mana[DICE_TYPE] = 1; pMob->mana[DICE_BONUS] = 10000; pMob->damage[DICE_NUMBER] = 1; pMob->damage[DICE_TYPE] = 1; pMob->damage[DICE_BONUS] = 1100; pMob->ac[AC_PIERCE] = -500; pMob->ac[AC_BASH] = -500; pMob->ac[AC_SLASH] = -500; pMob->ac[AC_EXOTIC] = -500; SET_BIT( pMob->off_flags, OFF_FAST); SET_BIT( pMob->imm_flags, IMM_MAGIC); SET_BIT( pMob->imm_flags, IMM_WEAPON); SET_BIT( pMob->imm_flags, IMM_SUMMON); SET_BIT( pMob->imm_flags, IMM_CHARM); send_to_char("Auto Impossible Set.", ch); tail_chain(); return TRUE; break; default: send_to_char(buff, ch); tail_chain(); return FALSE; break; } /*i'm fuzzing out the hp/mana numbers generated by 2%, damroll by 4%, hitroll by 10%*/ pMob->level = arg2; pMob->hitroll = number_range ((hitr-(hitr/10)),(hitr+(hitr/10))); pMob->hit[DICE_NUMBER] = number_range ((hitd[1]-(hitd[1]/50)),(hitd[1]+(hitd[1]/50))); pMob->hit[DICE_TYPE] = number_range ((hitd[2]-(hitd[2]/50)),(hitd[2]+(hitd[2]/50))); pMob->hit[DICE_BONUS] = number_range ((hitd[3]-(hitd[3]/50)),(hitd[3]+(hitd[3]/50))); pMob->mana[DICE_NUMBER] = number_range ((hitd[1]-(hitd[1]/50)),(hitd[1]+(hitd[1]/50))); pMob->mana[DICE_TYPE] = number_range ((hitd[2]-(hitd[2]/50)),(hitd[2]+(hitd[2]/50))); pMob->mana[DICE_BONUS] = number_range ((hitd[3]-(hitd[3]/50)),(hitd[3]+(hitd[3]/50))); pMob->damage[DICE_NUMBER] = number_range ((damd[1]-(damd[1]/25)),(damd[1]+(damd[1]/25))); pMob->damage[DICE_TYPE] = number_range ((damd[2]-(damd[2]/25)),(damd[2]+(damd[2]/25))); pMob->damage[DICE_BONUS] = number_range ((damd[3]-(damd[3]/25)),(damd[3]+(damd[3]/25))); pMob->ac[AC_PIERCE] = (0 - (number_range (fabs(ac[1]-(ac[1]/20)),fabs(ac[1]+(ac[1]/20))))); pMob->ac[AC_BASH] = (0 - (number_range (fabs(ac[1]-(ac[1]/20)),fabs(ac[1]+(ac[1]/20))))); pMob->ac[AC_SLASH] = (0 - (number_range (fabs(ac[1]-(ac[1]/20)),fabs(ac[1]+(ac[1]/20))))); pMob->ac[AC_EXOTIC] = (fabs(ac[1]/10) - (number_range (fabs(ac[1]-(ac[1]/20)),fabs(ac[1]+(ac[1]/20))))); printf_to_char(ch,"Auto %s Set: Level %d.\n\r",buff,arg2); send_to_char( "Please check for accuracy.\n\r", ch); tail_chain(); return TRUE; } AEDIT( aedit_temperature ) { 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: temperature <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; } if ( atoi( lower ) < MIN_TEMP || atoi( upper ) > MAX_TEMP ) { send_to_char( "Aedit: Lower must be greater than 0 and upper must be less than 100.\n\r", ch ); return FALSE; } pArea->min_temp = ilower; send_to_char( "Lower Temperature set.\n\r", ch ); pArea->max_temp = iupper; send_to_char( "Upper Temperature set.\n\r", ch ); return TRUE; } OEDIT( oedit_xptolevel ) { OBJ_INDEX_DATA *pObj; int amount; EDIT_OBJ(ch, pObj); if ( argument[0] == '\0' || !is_number( argument ) ) { send_to_char( "Syntax: xptolevel [number]\n\r", ch ); return FALSE; } amount = *argument; if ( amount < 0 || amount > 5000 ) { send_to_char( "Please choose an amount between 0 and 5000\n\r", ch ); return FALSE; } pObj->xp_tolevel = atoi( argument ); send_to_char( "Exp to level set.\n\r", ch); return TRUE; } AEDIT( aedit_repop_msg ) { AREA_DATA *pArea; EDIT_AREA(ch, pArea); if ( argument[0] == '\0' ) { send_to_char( "Syntax: repop [MESSAGE]\n\r", ch ); return FALSE; } free_string( pArea->repop_msg ); pArea->repop_msg = str_dup( argument ); send_to_char( "Repop Message set.\n\r", ch ); return TRUE; } MEDIT( medit_aggression ) { MOB_INDEX_DATA *pMob; char arg[MSL]; ROOM_INDEX_DATA *in_room; argument = one_argument( argument, arg ); EDIT_MOB( ch, pMob ); in_room = ch->in_room; if ( ch->in_room->vnum == pMob->aggression ) { pMob->aggression = 0; send_to_char( "Your mob will no longer be aggressive when it's in this room.\n\r", ch ); return TRUE; } else { pMob->aggression = ch->in_room->vnum; send_to_char( "Your mob will now be aggressive when it's in this room.\n\r", ch ); return TRUE; } } AEDIT ( aedit_music ) { AREA_DATA *pArea; EDIT_AREA ( ch, pArea ); if ( argument[0] == '\0' ) { send_to_char ( "Syntax: music [file.mid]\n\r", ch); return FALSE; } free_string ( pArea->soundfile ); pArea->soundfile = str_dup (argument ); send_to_char ( "Music set. MIDI only. If this file is not on the webpage,\n\r", ch); send_to_char ( "then send a copy of it to the mud admin to be added for download.\n\r", ch); return TRUE; }