/**
* 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 _ignore_bits;
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() {
string *languages, *lang_tree;
int i;
mixed *rabbit;
string skill_written;
string skill_spoken;
string *skill_bits;
_skills = STD_SKILLS;
_skill_tree = ([ ]);
_immediate_children = ([ ]);
_not_allowed_to_teach = ([ ]);
_only_show_if_non_zero = ([ ]);
_no_bonus = ([ ]);
lang_tree = ({ });
languages = LANGUAGE_HAND->query_languages();
for (i=0;i<sizeof(languages);i++) {
rabbit = ({ });
if (LANGUAGE_HAND->query_language_spoken(languages[i])) {
rabbit += ({ SPOKEN_SKILL, 0, 0, ({ }), });
}
if (LANGUAGE_HAND->query_language_written(languages[i]) ||
LANGUAGE_HAND->query_language_magic(languages[i])) {
rabbit += ({ WRITTEN_SKILL, 0, 0, ({ }) });
}
skill_written = LANGUAGE_HAND->query_language_written_skill(languages[i]);
skill_spoken = LANGUAGE_HAND->query_language_spoken_skill(languages[i]);
languages[i] = replace(languages[i], " ", "_");
lang_tree += ({ languages[i], 0, 0, rabbit });
_not_allowed_to_teach[LANGUAGE_SKILL_START + languages[i]] = 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["other.language"] = 1;
i = member_array(skill_bits[0], _skills);
if (i != -1) {
_skills[i+SKILL_BIT] += ({ skill_bits[1], 0, 0, lang_tree });
}
_only_leaf = ([ "other" : 1 ]);
_ignore_bits = ([ "crafts" : 1 ]);
_reg_skills = flatten( _skills, "" );
_stat_bonus = ([
"covert" : ({ "DDDII" }),
"covert.stealth" : ({ "DDDIS" }),
"covert.hiding" : ({ "DDIIS" }),
"covert.lockpick" : ({ "DDDDI" }),
"covert.manipulation" : ({ "DDISS" }),
"covert.casing" : ({ "DIIWW" }),
"covert.items" : ({ "DIIII" }),
"covert.points" : ({ "DDIIC" }),
"crafts" : ({ "DDIIW" }),
"crafts.smithing" : ({ "DDIIS" }),
"crafts.mining" : ({ "DIISS" }),
"crafts.hunting" : ({ "DDIII" }),
"crafts.carpentry" : ({ "DDIIS" }),
"crafts.pottery" : ({ "DDDII" }),
"crafts.materials" : ({ "DDIIS" }),
"crafts.husbandry" : ({ "IIIWW" }),
"crafts.culinary" : ({ "DDIII" }),
"crafts.arts" : ({ "DIIII" }),
"crafts.music" : ({ "DIIII" }),
"crafts.points" : ({ "DDIIW" }),
"faith" : ({ "ISWWW" }),
"faith.rituals.offensive" : ({ "ISSWW" }),
"faith.rituals.defensive" : ({ "IDDWW" }),
"faith.rituals.curing" : ({ "ICCWW" }),
"faith.rituals.misc" : ({ "IIWWW" }),
"faith.items" : ({ "IIDWW" }),
"faith.points" : ({ "IICWW" }),
"fighting" : ({ "DDSSI" }),
"fighting.combat.melee" : ({ "DSSSW" }),
"fighting.combat.melee.sharp" : ({ "DDSSS" }),
"fighting.combat.melee.pierce" : ({ "DDDSS" }),
"fighting.combat.melee.blunt" : ({ "DSSSS" }),
"fighting.combat.melee.unarmed" : ({ "DDDSW" }),
"fighting.combat.range" : ({ "DDDSS" }),
"fighting.combat.parry" : ({ "DDSSW" }),
"fighting.combat.dodging" : ({ "DDDSW" }),
"fighting.combat.special.weapon" : ({ "SDIII" }),
"fighting.combat.special.unarmed" : ({ "DDIII" }),
"fighting.combat.special.tactics" : ({ "WWIII" }),
"fighting.points" : ({ "DSSCC" }),
"magic" : ({ "IIIDW" }),
"magic.spells" : ({ "IIDWW" }),
"magic.spells.offensive" : ({ "WSSII" }),
"magic.spells.defensive" : ({ "WCCII" }),
"magic.spells.misc" : ({ "WDDII" }),
"magic.spells.special" : ({ "WWWII" }),
"magic.methods.elemental" : ({ "IICCC" }),
"magic.methods.mental" : ({ "IIIII" }),
"magic.methods.spiritual" : ({ "IIWWW" }),
"magic.methods.physical" : ({ "IIDDD" }),
"magic.items" : ({ "IIDWW" }),
"magic.items.held" : ({ "IIDWW" }),
"magic.points" : ({ "IISWW" }),
"other" : ({ "DDISS" }),
"other.trading" : ({ "IIIIW" }),
"other.movement" : ({ "CCDDS" }),
"other.acrobatics" : ({ "CDDSS" }),
"other.evaluating" : ({ "IIIIW" }),
"other.perception" : ({ "IIWWW" }),
"other.direction" : ({ "DDIIW" }),
"other.health" : ({ "CCCCS" }),
"other.points" : ({ "CDISW" }),
"other.language" : ({ "IIIWW" }),
"other.culture" : ({ "IIIWW" }),
]);
}
/**
* 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..1090];
}
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() */
private int add_stat_bonus(string skill, string bonus) {
if (_stat_bonus[skill]) {
return 0;
}
_stat_bonus[skill] = ({ bonus });
return 1;
} /* add_stat_bonus() */
private int remove_stat_bonus(string skill) {
if (!_stat_bonus[skill]) {
return 0;
}
_stat_bonus = m_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() */
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() */
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]) == 0) {
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() */
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() */
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;
if( !bits || !sizeof(bits) ) {
return 0;
}
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) {
string *bits;
bits = explode(str, ".");
return _only_leaf[bits[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] || _ignore_bits[str];
} /* query_no_bonus() */
/**
* This method returns 1 if the skill being asked about should be ignored.
* An ignored skill means that up to this point the fact it is this deep
* is ignored. For example,if 'crafts' is ignored then 'crafts.smithing'
* would count as if it was a top level skill.
* @param skill the skill to check
*/
int is_skill_ignored(string skill) {
return _ignore_bits[skill];
}
/**
* This method returns the skill depth for teaching calculations.
* @param skill the skill to get the depth of
* @return the skill depth
*/
int query_skill_depth(string* skill) {
int depth;
int i;
depth = 0;
for (i = 0; i < sizeof(skill) - 1; i++) {
if (!is_skill_ignored(implode(skill[0..i], "."))) {
depth++;
}
}
return depth;
}
