/**************************************************************************/
// 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;
	}
}
/**************************************************************************/
/**************************************************************************/