/**
* This is the skills handler. It controls all the skills currently in
* the game and keeps track of their various properties.
* @author Pinkfish
*/
#include <skills.h>
#include <language.h>
#define SKILL_BONUS 0
private mapping _stat_bonus;
private mixed _skills;
private mapping _reg_skills;
private mapping _skill_tree;
private mapping _immediate_children;
private mapping _only_leaf;
private mapping _not_allowed_to_teach;
private mapping _only_show_if_non_zero;
private mapping _no_bonus;
private mapping flatten( mixed arr, string bit );
mixed add_skill_rec( mixed skill, string *path );
mixed del_skill_rec( mixed skill, string *path );
int query_skill_cost_int( string str );
void create() {
int i;
mixed rabbit;
string lang, *languages, *lang_tree, skill_written, skill_spoken, *skill_bits;
_skills = STD_SKILLS;
_skill_tree = ([ ]);
_immediate_children = ([ ]);
_not_allowed_to_teach = ([ ]);
_only_show_if_non_zero = ([ ]);
_no_bonus = ([ ]);
lang_tree = ({ });
languages = LANGUAGE_H->query_languages();
foreach( lang in languages ) {
rabbit = ({ });
if( LANGUAGE_H->query_language_spoken( lang ) )
rabbit += ({ SPOKEN_SKILL, 0, 0, ({ }), });
if( LANGUAGE_HAND->query_language_written( lang ) ||
LANGUAGE_HAND->query_language_magic( lang ) )
rabbit += ({ WRITTEN_SKILL, 0, 0, ({ }) });
skill_written = LANGUAGE_H->query_language_written_skill( lang );
skill_spoken = LANGUAGE_H->query_language_spoken_skill( lang );
lang = replace( lang, " ", "_");
lang_tree += ({ lang, 0, 0, rabbit });
_not_allowed_to_teach[LANGUAGE_SKILL_START + lang] = 1;
_not_allowed_to_teach[skill_spoken] = 1;
_not_allowed_to_teach[skill_written] = 1;
_only_show_if_non_zero[skill_spoken] = 1;
_only_show_if_non_zero[skill_written] = 1;
_no_bonus[skill_spoken] = 1;
_no_bonus[skill_written] = 1;
}
/* We make an assumption here that the skill is only two levels deep. */
skill_bits = explode( LANGUAGE_SKILL_START, "." );
_not_allowed_to_teach["general.language"] = 1;
if( ( i = member_array( skill_bits[0], _skills ) ) != -1 )
_skills[i+SKILL_BIT] += ({ skill_bits[1], 0, 0, lang_tree });
_only_leaf = ([ "general" : 1 ]);
_reg_skills = flatten( _skills, "" );
_stat_bonus = ([
"covert" : ({ "DDDDD" }),
"covert.hiding" : ({ "DDDDI" }),
"covert.lockpick" : ({ "DDDII" }),
"covert.casing" : ({ "DDIII" }),
"covert.items" : ({ "DDDII" }),
"covert.points" : ({ "DDDIW" }),
"crafts" : ({ "DDIIW" }),
"crafts.smithing.black" : ({ "DISSW" }),
"crafts.smithing.sharpening" : ({ "DIIIS" }),
"crafts.smithing.decorating" : ({ "DDISW" }),
"crafts.smithing.examining" : ({ "IIWWW" }),
"faith" : ({ "WWWWW" }),
"faith.items" : ({ "IIWWW" }),
"fighting" : ({ "DDSSS" }),
"fighting.combat.range" : ({ "DDDSS" }),
"fighting.combat.range.thrown" : ({ "DDDSS" }),
"fighting.combat.range.fired" : ({ "DDISS" }),
"fighting.combat.dodging" : ({ "DDDDI" }),
"fighting.combat.special.weapon" : ({ "SSDDI" }),
"fighting.combat.special.unarmed": ({ "SSDDI" }),
"fighting.combat.special.tactics": ({ "IIIWW" }),
"fighting.points" : ({ "DSSSW" }),
"magic" : ({ "IIIII" }),
"magic.methods.mental" : ({ "IIIWW" }),
"magic.methods.physical" : ({ "IIIDD" }),
"magic.items.held.broom" : ({ "DDIII" }),
"general" : ({ "DDISS" }),
"general.tracking" : ({ "IIIWW" }),
"general.swimming" : ({ "DCCSS" }),
"general.climbing" : ({ "SSDIC" }),
"general.valueing" : ({ "IIIIW" }),
"general.evaluating" : ({ "IIIIW" }),
"general.perception" : ({ "IIWWW" }),
"general.direction" : ({ "DDIIW" }),
"general.health" : ({ "CCCCS" }),
"general.points" : ({ "CDISW" }),
"general.language" : ({ "IIIWW" }),
]);
} /* create() */
/**
* This method returns the all of the skills with their children and the
* number of children in a nice mapping. The key of the mapping is the name
* of the skill, the value is an array of two elements. The first is an
* array of all the children and the second is the number of children
* of the skill.
* @return the mapping as described above
*/
mapping query_reg_skills() { return _reg_skills; }
/**
* This method returns the raw unfluffed skill array. This is the same
* as the skill array defined in /include/skills.h plus the language skills
* and other dynamic skills added.
* @return the skills array
* @see /include/skills.h
*/
mixed query_skills() { return _skills; }
/**
* This method returns the path to skill. This is essentially the skill
* name broken up on '.'s and returned as an array.
* @return the skill path, or 0 if the skill does not exist
*/
string *query_skill_path( string skill ) {
if( skill[0] == '.' )
skill = skill[1..];
if( !_reg_skills[skill] )
return 0;
return explode( skill, "." );
} /* query_skill_path() */
/**
* This method returns the skill and all of its parents leading up to
* it.
* @example
* query_skill_tree("magic.methods.physical.binding")
* Returns: ({
* "magic.methods.physical.binding",
* "magic.methods.physical",
* "magic.methods",
* "magic"
* })
* @param skill the skill to get the tree of
* @return the skill tree of the skill
*/
string *query_skill_tree( string skill ) {
return _skill_tree[skill];
} /* query_skill_tree() */
/**
* This method returns the stats that effect the skill.
* @param skill the skill to check
* @return the stats that effect the skill
*/
string query_skill_stat( string skill ) {
int i;
string *bit, s;
bit = explode( skill, "." );
i = sizeof(bit);
while( i >= 0 ) {
s = implode( bit[0..i], "." );
if( _stat_bonus[s] )
return _stat_bonus[s][SKILL_BONUS];
else
i--;
}
return "";
} /* query_skill_stat() */
/** @ignore yes */
private int add_stat_bonus( string skill, string bonus ) {
if( _stat_bonus[skill] )
return 0;
_stat_bonus[skill] = ({ bonus });
return 1;
} /* add_stat_bonus() */
/** @ignore yes */
private int remove_stat_bonus( string skill ) {
if( !_stat_bonus[skill] )
return 0;
map_delete( _stat_bonus, skill );
return 1;
} /* remove_stat_bonus() */
/**
* This method returns the children of the specified skill chunk.
* You need to pass into this array a skill chunk as taken from the
* skill array. It is recursive and returns all the internal children
* as well.
* @param arr the skill chunk
* @param path the skill bit leading up to this section
* @return the children of the skill chunk
*/
string *query_children( mixed arr, string path ) {
string *ret;
int i;
ret = ({ });
for( i = 0; i < sizeof(arr); i += SKILL_ARR_SIZE )
ret += ({ path+arr[i] }) + query_children( arr[i+SKILL_BIT],
path+arr[i]+".");
return ret;
} /* query_children() */
/**
* This method returns the immediate children of the specified skill.
* @param skill the skill to get the children of
* @return the immediate children of the skill
*/
string *query_immediate_children(string skill) {
return _immediate_children[skill];
} /* query_immediate_childen() */
/**
* This method returns all the children of the specified skill.
* This does a deep children finding exercise, returing all the children
* as it goes lower and lower into the array.
* @param skill the skill to get the children of
* @return all the children
* @see query_related_skills()
*/
string *query_all_children(string skill) {
if( _reg_skills[skill] )
return _reg_skills[skill][0];
return 0;
} /* query_all_children() */
private string *query_imm_children( mixed arr, string path ) {
string *ret;
int i;
ret = ({ });
for( i = 0; i < sizeof(arr); i+= SKILL_ARR_SIZE )
ret += ({ path+arr[i] });
return ret;
} /* query_imm_children() */
/** @ignore yes */
private string *create_skill_tree( string skill ) {
string *ret, *bits;
int i;
ret = ({ });
bits = explode(skill, ".");
/* For the only leaf heirachy, only count the upper level. */
if( _only_leaf[bits[0]] )
return ({ skill });
for( i = sizeof(bits) - 1; i >= 0; i-- )
ret += ({ implode(bits[0..i], ".") });
return ret;
} /* create_skill_tree() */
/** @ignore yes */
private mapping flatten( mixed arr, string bit ) {
int i;
mapping ret;
if( !bit )
bit = "";
ret = ([ ]);
for( i = 0; i < sizeof(arr); i += SKILL_ARR_SIZE ) {
reset_eval_cost();
if( !sizeof( arr[i+SKILL_BIT] ) ) {
ret[bit + arr[i]] = ({ ({ bit+arr[i] }), 1 });
} else {
ret[bit + arr[i]] = ({ query_children( arr[i+SKILL_BIT],
bit + arr[i]+".")+({ bit + arr[i] }),
query_skill_cost_int(bit + arr[i]) });
ret += flatten( arr[i+SKILL_BIT], bit+arr[i]+".");
}
_skill_tree[bit + arr[i]] = create_skill_tree( bit + arr[i] );
_immediate_children[bit + arr[i]] = query_imm_children(
arr[i+SKILL_BIT], bit+arr[i]+".");
}
return ret;
} /* flatten() */
/** @ignore yes */
private int query_skill_cost_rec( mixed arr ) {
int i, tmp;
if( !sizeof(arr) )
return 1;
for( i = 0; i < sizeof(arr); i += SKILL_ARR_SIZE )
tmp += query_skill_cost_rec( arr[i+SKILL_BIT] );
return tmp;
} /* query_skill_cost_rec() */
/** @ignore yes */
private int query_skill_cost_int( string str ) {
int i;
mixed arr;
string *path;
path = explode( str, "." );
arr = _skills;
while( sizeof(path) ) {
i = member_array( path[0], arr );
if( i == -1 ) {
return -1;
} else {
path = path[1..sizeof(path)];
arr = arr[i+SKILL_BIT];
}
}
return query_skill_cost_rec(arr);
} /* query_skill_cost_int() */
/**
* This method also returns all the children of a skill. It preforms
* exactly the same action as query_all_children()
* @param skill the skill to get the children of
* @return the children of the skill
*/
string *query_related_skills( string skill ) {
if( _reg_skills[skill] )
return _reg_skills[skill][0];
return 0;
} /* query_related_skills() */
/**
* This method returns the cost of the specified skill. This is the
* the number of children it has.
* @param skill the skill to check the cost of
* @return the costof the skill
*/
int query_skill_cost( string skill ) {
if( _reg_skills[skill] )
return _reg_skills[skill][1];
return -1;
} /* query_skill_cost() */
/**
* This method attempts to figure out the path of a skill from an array
* of bits. It verifies that the skill actually exists on the way.
* @param bits the skill to check
* @return the path of the skill
*/
string query_skill( string *bits ) {
mixed arr;
int i;
string path, s1;
path = "";
arr = _skills;
for( i = 0; i < sizeof(arr); i += SKILL_ARR_SIZE ) {
if( sscanf( arr[i], bits[0]+"%s", s1 ) == 1 ) {
path += "."+arr[i];
arr = arr[i+SKILL_BIT];
i = -SKILL_ARR_SIZE;
bits = bits[1..sizeof(bits)];
if( !sizeof(bits) )
return path[1..strlen(path)];
}
}
if( i < sizeof(arr) )
return path[1..strlen(path)];
return 0;
} /* query_skill() */
/**
* This method determines if only leaf skills can be increased in this
* skill tree. This is used for the other skill tree, to avoid increasing
* all the other skills at the same time.
* @param str the skill tree to check
* @return 1 if the tree is only leaf, 0 if not
*/
int query_only_leaf( string str ) {
return _only_leaf[explode( str, "." )[0]];
} /* query_only_leaf() */
/**
* This method checks to see if this particular skill is allowed to be
* taught to people.
* @param str the skill to check
* @return 1 if they are not allowed to teach it, 0 if they are
*/
int query_allowed_to_teach( string str ) {
return !_not_allowed_to_teach[str];
} /* query_allowed_to_teach() */
/**
* This method checks to see if the skill should only be shown on the
* skill list if it is non-zero.
* @param str the skill to check
* @return 1 if should only show non-zero skills, 0 if show any skill
*/
int query_only_show_if_non_zero( string str ) {
return _only_show_if_non_zero[str];
} /* query_only_show_if_non_zero() */
/**
* This method checks to see if the specified skill has no bonus associated
* with it.
* @param str the skill to check
* @return 1 if there is no bonus, 0 if there is a bonus
*/
int query_no_bonus( string str ) {
return _no_bonus[str];
} /* query_no_bonus() */
