/** * This is the skills handler. It controls all the skills currently in * the game and keeps track of their various properties. * @author Pinkfish */ #include <language.h> #include <skills.h> #include <tune.h> #define VERSION_1 "DSv1" #define VERSION_2 "DSv2" #define CURRENT_VERSION VERSION_2 private mixed _skills; private mapping _stat_bonus; 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 ); private int query_skill_cost_int( string str ); private 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", "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.melee.pierce" : "DDDSS", "fighting.combat.range" : "DDDSS", "fighting.combat.range.thrown" : "DDDSS", "fighting.combat.range.fired" : "DDISS", "fighting.combat.dodging" : "DDDDD", "fighting.combat.special.weapon" : "SSDDI", "fighting.combat.special.unarmed" : "SSDDI", "fighting.combat.special.tactics" : "IIIWW", "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]; else i--; } return ""; } /* query_skill_stat() */ /** * 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 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 ) { string path, s1; mixed arr; int i; 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() */ /** * This method is called by the player object when logging in, and * checks whether or not an upgrade is needed to the player's skills. */ void player_logon() { object player; mapping skills; if( !userp( player = PO ) ) return; switch( player->query_property("skills version") ) { case CURRENT_VERSION : return; case 0 : case VERSION_1 : { int co_po, fi_po, ma_po, fa_po, cr_po, ge_po; int *points; skills = player->query_skills(); if( !undefinedp( skills["fighting.points"] ) ) { fi_po = skills["fighting.points"]; map_delete( skills, "fighting.points"); } if( !undefinedp( skills["covert.points"] ) ) { co_po = skills["covert.points"]; map_delete( skills, "covert.points"); } if( !undefinedp( skills["faith.points"] ) ) { fa_po = skills["faith.points"]; map_delete( skills, "faith.points"); } if( !undefinedp( skills["magic.points"] ) ) { ma_po = skills["magic.points"]; map_delete( skills, "magic.points"); } if( !undefinedp( skills["crafts.points"] ) ) { cr_po = skills["crafts.points"]; map_delete( skills, "crafts.points"); } if( !undefinedp( skills["general.points"] ) ) { ge_po = skills["general.points"]; } points = sort_array(({co_po, fi_po, ma_po, fa_po, cr_po, ge_po}),-1); if(points){ skills["general.points"] = points[0]; tell_object( player, "\nMerging your gp into general.points.\n\n"); } player->set_skills( skills ); log_file("SKILL_CHANGE",sprintf("%s: Co:%d, Fi:%d, Ma:%d, Fa:%d, Cr:%d, Ge:%d, Points:%d\n", player->query_name(),co_po, fi_po, ma_po, fa_po, cr_po, ge_po, points[0])); } default : player->add_property("skills version", CURRENT_VERSION ); } } /* player_logon() */ /** * The current version of the skill tree. * @return the version of the skill system */ string query_version() { return CURRENT_VERSION; } /** * This method returns the experience cost for advancing to a certain * level in a skill for the specified player. * If no offset is specified, the return value will be the cost of a * single skill level from the player's current level. * @param player the player to get the cost for * @param skill the skill to get the cost for * @param offset the offset * @return the cost of advancing a level of the skill */ int query_skill_cost( object player, string skill, int offset ) { float base, total; string *next; next = SKILL_H->query_immediate_children( skill ); if( !sizeof( next ) ) { base = STD_GUILD_OBJ->query_skill_cost( skill, player ); total = base; total *= ( STD_COST * 100 ) / 500; total *= ( player->query_skill(skill) + offset ) / LEVEL_DIV + 1; total += 30 * base; return to_int( total * exp( ( player->query_skill(skill) + offset ) / 150.0 ) ); } foreach( skill in next ) total += query_skill_cost( player, skill, offset ); return total; } /* query_skill_cost() */ /** @ignore yes */ mixed stats() { return ({ ({"skills version", CURRENT_VERSION }) }); }