/**************************************************************************/ // cedit.cpp - olc class editor /*************************************************************************** * The Dawn of Time v1.69r (c)1997-2004 Michael Garratt * * >> A number of people have contributed to the Dawn codebase, with the * * majority of code written by Michael Garratt - www.dawnoftime.org * * >> To use this source code, you must fully comply with the dawn license * * in licenses.txt... In particular, you may not remove this copyright * * notice. * **************************************************************************/ #include "include.h" #include "olc.h" #include "security.h" #include "dynamics.h" /**************************************************************************/ // prototypes void do_classlist( char_data *ch, char *); /**************************************************************************/ // Entry Point for editing classes void do_classedit( char_data *ch, char *argument ) { int i; char arg[MSL]; if ( IS_NPC( ch )){ ch->println("Players only." ); return; } // do security checks if (!HAS_SECURITY(ch, 2)) { ch->println( "You must have an olc security 2 or higher to use this command." ); return; } if ( !HAS_SECURITY(ch, CLASSEDIT_MINSECURITY)) { ch->println( "ClassEdit: Insufficient security to modify or create classes." ); return; } if ( !IS_TRUSTED(ch, CLASSEDIT_MINTRUST)) { ch->printlnf( "You must have a trust of %d or above " "to use this command.", CLASSEDIT_MINTRUST); return; } if (IS_NULLSTR(argument)){ ch->titlebar("CLASSEDIT: SYNTAX"); ch->println( "syntax: classedit <class_name>" ); ch->println(" classedit create <new_class_name>\r\n" ); // extra LF ch->println( "<class_name> can selected from one of the following:" ); do_classlist(ch,""); return; } argument = one_argument( argument, arg ); if ( !str_cmp( arg, "create" )){ argument = one_argument( argument, arg ); // get the new name if(!str_infix(" ", arg)){ ch->println("The name of a class can't contain any spaces."); return; } if(class_exact_lookup(arg)>=0){ ch->printlnf("There already exists a class called '%s'.", arg); return; } ch->printlnf("Creating new class called '%s'.", arg); create_class(arg); do_classedit(ch,arg); return; } i = class_lookup(arg); if (i<0){ ch->printlnf( "Couldn't find class '%s'...\r\nSelectable classes:", arg); do_classlist(ch,""); return; } ch->desc->pEdit = &class_table[i]; ch->desc->editor = ED_CLASS; ch->printlnf( "Editing class '%s'", class_table[i].name); return; } /**************************************************************************/ void do_classlist( char_data *ch, char *) { int i; ch->titlebar("CLASSES"); if(GAMESETTING(GAMESET_REMORT_SUPPORTED)){ for ( i= 0; !IS_NULLSTR(class_table[i].name); i++) { ch->printf( " %s%-14s [%d]`x", (class_table[i].creation_selectable?"`W":"`S"), class_table[i].name, class_table[i].remort_number ); if ( ( i% 4 ) == 3 ){ ch->print( "\r\n" ); } } }else{ for ( i= 0; !IS_NULLSTR(class_table[i].name); i++) { ch->printf( " %s%-19s`x", (class_table[i].creation_selectable?"`W":"`S"), class_table[i].name); if ( ( i% 4 ) == 3 ){ ch->print( "\r\n" ); } } } ch->println( "`x\r\n`SSilver classes can't be selected in creation.`x"); } /**************************************************************************/ bool classedit_name(char_data *ch, char *argument) { class_type * pC; if ( IS_NULLSTR(argument)) { ch->println( "Syntax: name <string>" ); return false; } EDIT_CLASS(ch, pC); ch->wraplnf("Class name changed from '%s' to '%s'.", pC->name, argument); replace_string(pC->name, argument); ch->println("NOTES: The skill table and class files should be resaved!"); ch->println(" It is recommended changing the name on classes that arent currently played."); ch->println(" These changes take affect immediately... any players currently logged in as this class will get the new name."); ch->println(" Any players not currently logged will have problems connecting as the old name."); return true; } /**************************************************************************/ bool classedit_show(char_data *ch, char *) { race_data *race; class_type * pC; EDIT_CLASS(ch, pC); SET_BIT(ch->dyn,DYN_SHOWFLAGS); ch->printlnf( "`=rClass Name: `x%-10s `=rShortname: `x%s `=rSpinfo_letter:`x%s", capitalize(pC->name), pC->short_name, pC->spinfo_letter); ch->printlnf("`=rHPMinTrain: `x%-5d `=rHPMaxTrain: `x%d", pC->hp_min, pC->hp_max); ch->printlnf("`=rRecall: `x%-5d `=rMorgue: `x%-5d `=rRemort: `x%d ", pC->recall, pC->morgue, pC->remort_number); ch->printlnf("`=rPrimeStat 0:`x%s", capitalize(stat_flags[pC->attr_prime[0]].name)); ch->printlnf("`=rPrimeStat 1:`x%s", capitalize(stat_flags[pC->attr_prime[1]].name)); ch->printlnf("`=rSkill_adept:`x%d", pC->skill_adept); ch->printlnf("`=rTHAC0:`x %2d (modifier To Hit Armour Class at level 0)", pC->thac0_00); ch->printlnf("`=rTHAC32:`x %2d (modifier To Hit Armour Class at level 32)", pC->thac0_32); ch->println( "`SA THAC modifier is calculated for any level by interpolating the two above values."); ch->printlnf("`=rFullManaGain:`x %s `S(if false, class gets half gains mana each level)`x", pC->fMana?"True":"False"); ch->printlnf("`=rDefault_group:`x'%s' `S(group when no customisation is choosen)`x", pC->default_group); ch->printlnf( "`=rCreation Selectable:`x %s",pC->creation_selectable?"True":"False"); ch->wrapln("`SNote: If the base xp for a particular race is below 1000, it wont be " "selectable when that race is choosen.`x"); mxp_display_olc_flags(ch, castnames_types, pC->class_cast_type, "casttype", "Casttype:"); mxp_display_olc_flags(ch, classflag_flags, pC->flags, "flags", "Selected Flags:"); int classindex=class_exact_lookup(pC->name); assert(classindex>=0); ch->println("`=r==`=RClass Base XP ratings for creation selectable races`=r=="); int count=0; for( race=race_list; race; race=race->next) { if(race->creation_selectable()){ ch->printf(" `=r%-17s `x%3d ", capitalize(race->name), race->class_exp[classindex]); if(++count%3==0){ ch->println(""); } // column code } } if(count%3!=0){ ch->println(""); } ch->println("`S(Edit these and other races in raceedit)`x"); ch->printlnf("Use `=C%s`x to edit class poses.", mxp_create_send(ch, "showpose")); REMOVE_BIT(ch->dyn,DYN_SHOWFLAGS); return false; } /**************************************************************************/ bool classedit_showpose(char_data *ch, char *) { class_type * pC; EDIT_CLASS(ch, pC); ch->titlebar("CLASS POSES"); for(int i=0; i<MAX_LEVEL; i++){ ch->printlnf("[%3d] %s`x", i, pC->pose_self[i]); ch->printlnf("<%3d> %s`x", i, pC->pose_others[i]); } ch->println("[x] = self, <x> = others"); ch->println("use 'setpose <number> self text' and 'setpose <number> others text'"); ch->titlebar(""); return false; } /**************************************************************************/ bool classedit_setpose(char_data *ch, char *argument) { char num[MIL]; char target[MIL]; int i; class_type * pC; EDIT_CLASS(ch, pC); argument=one_argument(argument, num); argument=one_argument(argument, target); if(IS_NULLSTR(argument)){ ch->println("Syntax: setpose <number> self <text>"); ch->println("Syntax: setpose <number> others <text>"); ch->println("Use - for the text to clear it"); ch->println("e.g. `=Csetpose 1 self You feel very holy.`x"); ch->println("e.g. `=Csetpose 1 others $n looks very holy.`x"); return false; } if(!is_number(num)){ ch->printlnf("The pose number must be numeric, '%s' is not.", num); return false; } i=atoi(num); if(i<0 || i>MAX_LEVEL-1){ ch->printlnf("The pose number must be in the range 0 to %d, '%s' is not.", MAX_LEVEL, num); return false; } if(!str_prefix(target, "self")){ if(*argument=='-'){ ch->printlnf("Self pose %d cleared, was '%s'",i, pC->pose_self[i]); replace_string(pC->pose_self[i],""); return true; } ch->printlnf("Self pose %d changed from '%s' to '%s'", i, pC->pose_self[i], argument); replace_string(pC->pose_self[i],argument); return true; } if(!str_prefix(target, "others")){ if(*argument=='-'){ ch->printlnf("Other pose %d cleared, was '%s'",i, pC->pose_others[i]); replace_string(pC->pose_others[i],""); return true; } ch->printlnf("Other pose %d changed from '%s' to '%s'", i, pC->pose_others[i], argument); replace_string(pC->pose_others[i],argument); return true; } ch->printlnf("classedit_setpose(): unrecognised option '%s'", target); classedit_setpose(ch,""); return false; } /**************************************************************************/ bool classedit_flags(char_data *ch, char *argument) { class_type * pC; EDIT_CLASS(ch, pC); int value; if ( argument[0] != '\0' ) { if ( ( value = flag_value( classflag_flags, argument ) ) != NO_FLAG ) { pC->flags^= value; ch->println( "Class flag toggled." ); return true; } } show_olc_options(ch, classflag_flags, "flag", "flag", pC->flags); return false; } /**************************************************************************/ bool classedit_remort( char_data *ch, char *argument ) { class_type * pC; int value; if ( !IS_NULLSTR(argument)) { if (!is_number(argument)){ ch->println("The remort value must be numerical."); ch->println("Remort 0 = class available at first creation."); ch->println("Remort 1 = class available at after first remort creation..."); }else { EDIT_CLASS(ch, pC); value = atoi( argument ); if(value<0 || value>5){ ch->println("The remort value must be between 0 and 5."); return false; } ch->printlnf("Remort value changed from %d to %d.", pC->remort_number, value); pC->remort_number= value; return true; } } ch->println("Syntax: remort <number>"); ch->println("Remort 0 = class available at first creation."); ch->println("Remort 1 = class available at after first remort creation..."); return false; } /**************************************************************************/ bool classedit_hpmintrain( char_data *ch, char *argument ) { class_type * pC; int value; if ( !IS_NULLSTR(argument)) { if (!is_number(argument)){ ch->println("The HPmintrain value must be numerical."); ch->wrapln("This is the minimum number of hitpoints a character will get " "when training hp."); }else { EDIT_CLASS(ch, pC); value = atoi( argument ); if(value<0){ ch->println("The HPmintrain value must be greater than 0."); return false; } ch->printlnf("HPMintrain value changed from %d to %d.", pC->hp_min, value); pC->hp_min= value; if(pC->hp_min>pC->hp_max){ ch->printlnf("HPMaxtrain value increased from %d to %d to compensate.", pC->hp_max, value); pC->hp_max=value; } return true; } } ch->println("Syntax: hpmintrain <number>"); ch->wrapln("This is the minimum number of hitpoints a character will get " "when training hp."); return false; } /**************************************************************************/ bool classedit_hpmaxtrain( char_data *ch, char *argument ) { class_type * pC; int value; if ( !IS_NULLSTR(argument)) { if (!is_number(argument)){ ch->println("The HPmaxtrain value must be numerical."); ch->wrapln("This is the maximum number of hitpoints a character will get " "when training hp."); }else { EDIT_CLASS(ch, pC); value = atoi( argument ); if(value<0){ ch->println("The HPmaxtrain value must be greater than 0."); return false; } ch->printlnf("HPMaxtrain value changed from %d to %d.", pC->hp_max, value); pC->hp_max= value; if(pC->hp_min>pC->hp_max){ ch->printlnf("HPMintrain value decreased from %d to %d to compensate.", pC->hp_min, value); pC->hp_min=value; } return true; } } ch->println("Syntax: hpmaxtrain <number>"); ch->wrapln("This is the maximum number of hitpoints a character will get " "when training hp."); return false; } /**************************************************************************/ bool classedit_prime0( char_data *ch, char *argument ) { int stat=flag_value( stat_flags, argument ); if (stat== NO_FLAG) { ch->printlnf("Invalid statname '%s'", argument); return false; } class_type * pC; EDIT_CLASS(ch, pC); if(stat==pC->attr_prime[0] || stat==pC->attr_prime[1]){ ch->printlnf("One of the prime stats is already set to %s.", capitalize(stat_flags[stat].name)); return false; } ch->printlnf("Prime stat 0 changed from %s to %s.", capitalize(stat_flags[pC->attr_prime[0]].name), capitalize(stat_flags[stat].name)); pC->attr_prime[0]=stat; return true; } /**************************************************************************/ bool classedit_prime1( char_data *ch, char *argument ) { int stat=flag_value( stat_flags, argument ); if (stat== NO_FLAG) { ch->printlnf("Invalid statname '%s'", argument); return false; } class_type * pC; EDIT_CLASS(ch, pC); if(stat==pC->attr_prime[0] || stat==pC->attr_prime[1]){ ch->printlnf("One of the prime stats is already set to %s.", capitalize(stat_flags[stat].name)); return false; } ch->printlnf("Prime stat 1 changed from %s to %s.", capitalize(stat_flags[pC->attr_prime[1]].name), capitalize(stat_flags[stat].name)); pC->attr_prime[1]=stat; return true; } /**************************************************************************/ bool classedit_adept( char_data *ch, char *argument ) { class_type * pC; int value; if ( !IS_NULLSTR(argument)) { if (!is_number(argument)){ ch->println("The adept value must be numerical."); ch->println("Adept = what a class can prac a skill up to."); }else { EDIT_CLASS(ch, pC); value = atoi( argument ); if(value<0 || value>100){ ch->println("The adept value must be between 0 and 100."); return false; } ch->printlnf("Skill adept value changed from %d to %d.", pC->skill_adept, value); pC->skill_adept= value; return true; } } ch->println("Syntax: adept <number>"); ch->println("Adept = what a class can prac a skill up to."); return false; } /**************************************************************************/ bool classedit_thac0( char_data *ch, char *argument ) { class_type * pC; int value; if ( !IS_NULLSTR(argument)) { if (!is_number(argument)){ ch->println("The THAC0 value must be numerical."); }else { EDIT_CLASS(ch, pC); value = atoi( argument ); if(value<0 || value>30){ ch->println("The THAC0 value must be between 0 and 30."); ch->println("Lower is better, almost every class has a THAC0 of 20."); return false; } if(value<pC->thac0_32){ ch->println("THAC0 can not be set lower than THAC32 - reduce THAC32 first."); return false; } ch->printlnf("%s THAC0 value changed from %d to %d.", capitalize(pC->name), pC->thac0_00, value); pC->thac0_00= value; return true; } } ch->println("Syntax: thac0 <number>"); ch->println("THAC = To Hit Armour Class (it is a modifier)"); ch->println("The THAC0 value must be between 0 and 30."); ch->println("Lower is better, almost every class has a THAC0 of 20."); return false; } /**************************************************************************/ bool classedit_thac32( char_data *ch, char *argument ) { class_type * pC; int value; if ( !IS_NULLSTR(argument)) { if (!is_number(argument)){ ch->println("The THAC32 value must be numerical."); }else { EDIT_CLASS(ch, pC); value = atoi( argument ); if(value<-30 || value>15){ ch->println("The THAC32 value must be between -30 and 15."); ch->println("Lower is better, examples are around the following:`1" "Mage 6, Cleric 2, Thief -4, Warrior -10, Druid 0, Paladin -9`1" "Ranger -8, Barbarian -16, Spellfilcher 5"); return false; } if(value>pC->thac0_00){ ch->println("THAC32 can not be set higher than THAC0 - increase THAC0 first."); return false; } ch->printlnf("%s THAC32 value changed from %d to %d.", capitalize(pC->name), pC->thac0_32, value); pC->thac0_32= value; return true; } } ch->println("Syntax: thac32 <number>"); ch->println("THAC = To Hit Armour Class (it is a modifier)"); ch->println("The THAC32 value must be between -30 and 15."); ch->println("Lower is better, examples are around the following:`1" "Mage 6, Cleric 2, Thief -4, Warrior -10, Druid 0, Paladin -9`1" "Ranger -8, Barbarian -16, Spellfilcher 5"); return false; } /**************************************************************************/ bool classedit_fullmana( char_data *ch, char * ) { class_type * pC; EDIT_CLASS(ch, pC); if(pC->fMana){ pC->fMana=false; ch->println("FullMana setup to false"); }else{ pC->fMana=true; ch->println("FullMana setup to true"); } return true; } /**************************************************************************/ bool classedit_casttype( char_data *ch, char *argument ) { class_type * pC; EDIT_CLASS(ch, pC); if( !IS_NULLSTR(argument)) { int value = flag_value( castnames_types, argument ); if ( value== NO_FLAG ) { ch->printlnf("Unknown casttype '%s'", argument); classedit_casttype(ch,""); return false; } if(pC->class_cast_type==value){ ch->printlnf("%s casttype already set to %s", capitalize(pC->name), flag_string( castnames_types, value)); classedit_casttype(ch,""); return false; } ch->printlnf("%s casttype changed from %s to %s", capitalize(pC->name), flag_string( castnames_types, pC->class_cast_type), flag_string( castnames_types, value)); pC->class_cast_type=(CLASS_CAST_TYPE)value; return true; } show_olc_options(ch, castnames_types, "casttype", "casttype", pC->class_cast_type); return false; } /**************************************************************************/ bool classedit_spinfoletter(char_data *ch, char *argument) { class_type * pC; if ( IS_NULLSTR(argument)) { ch->println( "Syntax: spinfoletter <letter>"); return false; } if(argument[0]=='`'){ ch->println("`` is not a valid spinfo letter"); return false; } EDIT_CLASS(ch, pC); argument[1]='\0'; ch->wraplnf("Spinfo letter changed from '%s' to '%s'.", pC->spinfo_letter, argument); replace_string(pC->spinfo_letter, argument); return true; } /**************************************************************************/ bool classedit_defaultgroup(char_data *ch, char *argument) { if ( IS_NULLSTR(argument)) { ch->println( "Syntax: defaultgroup <defaultgroup name>"); ch->println( "e.g. defaultgroup mage default"); return false; } class_type * pC; EDIT_CLASS(ch, pC); ch->wraplnf("Defaultgroup changed from '%s' to '%s'.", pC->default_group, argument); replace_string(pC->default_group, argument); return true; } /**************************************************************************/ bool classedit_creation( char_data *ch, char *argument ) { class_type * pC; if ( IS_NULLSTR(argument)) { ch->println("== Creation Selectable =="); ch->println("Syntax: creation [true|false]"); return false; } if (!IS_TRUSTED(ch, CLASSEDIT_CREATION_MINTRUST)){ ch->printlnf( "You must have a trust of %d to be able to change this!", CLASSEDIT_CREATION_MINTRUST); return false; } EDIT_CLASS(ch, pC); if(!str_cmp(argument,"true")){ if(pC->creation_selectable){ ch->println( "This class is already selectable in creation."); return false; }else{ ch->println( "This class is now selectable in creation."); pC->creation_selectable=true; return true; } }else if(!str_cmp(argument,"false")){ if(pC->creation_selectable){ ch->println( "This class is now no longer selectable in creation."); pC->creation_selectable=false; return true; }else{ ch->println( "This class is already unselectable in creation."); return false; } }else{ ch->println("== Creation Selectable =="); ch->println("Syntax: creation [true|false]"); ch->println("You must type either true or false."); return false; } } /**************************************************************************/ bool classedit_shortname(char_data *ch, char *argument) { if ( IS_NULLSTR(argument)) { ch->println( "Syntax: shortname <3letters>"); return false; } if(str_len(argument)!=3){ ch->println("The shortname must be 3 letters long"); return false; } if(!str_infix(" ", argument)){ ch->println("Whitespace is not a valid in a short name"); return false; } if(!str_infix("`", argument)){ ch->println("```` is not a valid in a short name"); return false; } class_type * pC; EDIT_CLASS(ch, pC); ch->wraplnf("shortname changed from '%s' to '%s'.", pC->short_name, argument); replace_string(pC->short_name, argument); return true; } /**************************************************************************/ void classedit_copyability(int sn, int target_class, int source_class) { skill_table[sn].skill_level[target_class] =skill_table[sn].skill_level[source_class]; skill_table[sn].rating[target_class] =skill_table[sn].rating[source_class]; skill_table[sn].low_percent_level[target_class] =skill_table[sn].low_percent_level[source_class]; skill_table[sn].maxprac_percent[target_class] =skill_table[sn].maxprac_percent[source_class]; skill_table[sn].learn_scale_percent[target_class] =skill_table[sn].learn_scale_percent[source_class]; } /**************************************************************************/ bool classedit_copy(char_data *ch, char *argument) { char what[MIL]; char parent_class[MIL]; int pci; // parent class index int oi; // own index bool fAll, fSkills, fRealms, fLanguages, fSpells; argument = one_argument( argument, what); argument = one_argument( argument, parent_class); if(IS_NULLSTR(parent_class)) { ch->println( "Classedit copy commands - used to copy ability settings from another class." ); ch->println( "This can only be used on classes that arent creation selectable."); ch->println( "Syntax:" ); ch->println( " copy all <from_class>"); ch->println( " copy skills <from_class>"); ch->println( " copy realms <from_class> (includes spheres, seasons & elements)"); ch->println( " copy languages <from_class>"); ch->println( " copy spells <from_class>"); return false; } class_type * pC; EDIT_CLASS(ch, pC); if(pC->creation_selectable){ ch->printlnf( "%s is creation selectable - can't use the copy system on this class.", capitalize(pC->name)); classedit_copy(ch,""); return false; } fAll = !str_cmp( what, "all" ); fSkills = !str_cmp( what, "skills" ); fRealms = !str_cmp( what, "realms" ); fLanguages = !str_cmp( what, "languages" ); fSpells = !str_cmp( what, "spells" ); int sn; if ( !(fAll || fSkills || fRealms || fLanguages || fSpells)) { ch->printlnf( "Invalid selection '%s'.", what); classedit_copy(ch,""); return false; } pci=class_lookup(parent_class); if(pci<0){ ch->printlnf( "Class '%s' not found to copy from.", parent_class); classedit_copy(ch,""); return false; } oi=class_lookup(pC->name); if( pci==oi){ ch->println( "Can not copy abilities from the class you are currently editing."); classedit_copy(ch,""); return false; }; if ( fAll ) { ch->printlnf("Copying all ability settings from the parent class %s.", class_table[pci].name); for ( sn = 0; !IS_NULLSTR(skill_table[sn].name); sn++ ) { classedit_copyability(sn, oi, pci); } }else if ( fSkills ){ ch->printlnf("Copying all skill related ability settings from the parent class %s.", class_table[pci].name); for ( sn = 0; !IS_NULLSTR(skill_table[sn].name); sn++ ) { if(skill_table[sn].type==SKTYPE_SKILL){ classedit_copyability(sn, oi, pci); } } }else if ( fRealms ){ ch->printlnf("Copying all realm, sphere, element and season related ability settings from the parent class %s.", class_table[pci].name); for ( sn = 0; !IS_NULLSTR(skill_table[sn].name); sn++ ) { if(IS_REALM(sn)){ classedit_copyability(sn, oi, pci); } } } else if ( fLanguages ) { ch->printlnf("Copying all language related ability settings from the parent class %s.", class_table[pci].name); for ( sn = gsn_human; sn <= gsn_mremish; sn++ ) { classedit_copyability(sn, oi, pci); } } else if ( fSpells ) { ch->printlnf("Copying all spell ability settings from the parent class %s.", class_table[pci].name); for ( sn = 0; !IS_NULLSTR(skill_table[sn].name); sn++ ) { if(IS_SPELL(sn)){ classedit_copyability(sn, oi, pci); } } }else { bug("classedit_copy(): - shouldn't have got here!!!"); do_abort(); } ch->println( "Done." ); return true; } /**************************************************************************/ /**************************************************************************/ bool classedit_recall( char_data *ch, char *argument ) { class_type * pC; int value; if(IS_NULLSTR(argument)) { ch->println("Syntax: recall <room number>"); ch->println("Use a room number of 0 to clear the class based recall."); return false; } if(!is_number(argument)){ ch->println("The recall value must be room vnum."); classedit_recall(ch, ""); return false; }else{ EDIT_CLASS(ch, pC); value = atoi( argument ); if(value==0){ // option to clear the recall ch->printlnf("Class recall value cleared, was %d.", pC->recall); pC->recall= value; return true; } if(!get_room_index(value)){ ch->printlnf("Couldn't find any room %d to set the class recall to.", value); return false; } ch->printlnf("Class recall value changed from %d to %d.", pC->recall, value); pC->recall= value; return true; } } /**************************************************************************/ bool classedit_morgue( char_data *ch, char *argument ) { class_type * pC; int value; if(IS_NULLSTR(argument)) { ch->println("Syntax: morgue <room number>"); ch->println("Use a room number of 0 to clear the class based morgue."); return false; } if(!is_number(argument)){ ch->println("The morgue value must be room vnum."); classedit_morgue(ch, ""); return false; }else{ EDIT_CLASS(ch, pC); value = atoi( argument ); if(value==0){ // option to clear the recall ch->printlnf("Class morgue value cleared, was %d.", pC->morgue); pC->morgue= value; return true; } if(!get_room_index(value)){ ch->printlnf("Couldn't find any room %d to set the class morgue to.", value); return false; } ch->printlnf("Class morgue value changed from %d to %d.", pC->morgue, value); pC->morgue= value; return true; } } /**************************************************************************/ /**************************************************************************/