server/skill_util.c

Go to the documentation of this file.

/************************************************************************
*            Atrinik, a Multiplayer Online Role Playing Game            *
*                                                                       *
*    Copyright (C) 2009-2011 Alex Tokar and Atrinik Development Team    *
*                                                                       *
* Fork from Daimonin (Massive Multiplayer Online Role Playing Game)     *
* and Crossfire (Multiplayer game for X-windows).                       *
*                                                                       *
* This program is free software; you can redistribute it and/or modify  *
* it under the terms of the GNU General Public License as published by  *
* the Free Software Foundation; either version 2 of the License, or     *
* (at your option) any later version.                                   *
*                                                                       *
* This program is distributed in the hope that it will be useful,       *
* but WITHOUT ANY WARRANTY; without even the implied warranty of        *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
* GNU General Public License for more details.                          *
*                                                                       *
* You should have received a copy of the GNU General Public License     *
* along with this program; if not, write to the Free Software           *
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.             *
*                                                                       *
* The author can be reached at admin@atrinik.org                        *
************************************************************************/

/* define the following for skills utility debugging */
/* #define SKILL_UTIL_DEBUG */

#include <global.h>

static object *exp_cat[MAX_EXP_CAT];
static int nrofexpcat = 0;

float stat_exp_mult[MAX_STAT + 1] =
{
    0.0f,   0.01f,  0.1f,   0.3f,   0.5f,
    0.6f,   0.7f,   0.8f,   0.85f,  0.9f,
    0.95f,  0.96f,  0.97f,  0.98f,  0.99f,
    1.0f,   1.01f,  1.02f,  1.03f,  1.04f,
    1.05f,  1.07f,  1.09f,  1.12f,  1.15f,
    1.2f,   1.3f,   1.4f,   1.5f,   1.7f,
    2.0f
};

static float lev_exp[MAXLEVEL + 1] =
{
    0.0f,     1.0f,     1.11f,    1.75f,    3.2f,
    5.5f,     10.0f,    20.0f,    35.25f,   66.1f,
    137.0f,   231.58f,  240.00f,  247.62f,  254.55f,
    260.87f,  266.67f,  272.00f,  276.92f,  281.48f,
    285.71f,  289.66f,  293.33f,  296.77f,  300.00f,
    303.03f,  305.88f,  308.57f,  311.11f,  313.51f,
    315.79f,  317.95f,  320.00f,  321.95f,  323.81f,
    325.58f,  327.27f,  328.89f,  330.43f,  331.91f,
    333.33f,  334.69f,  336.00f,  337.25f,  338.46f,
    339.62f,  340.74f,  341.82f,  342.86f,  343.86f,
    344.83f,  345.76f,  346.67f,  347.54f,  348.39f,
    349.21f,  350.00f,  350.77f,  351.52f,  352.24f,
    352.94f,  353.62f,  354.29f,  354.93f,  355.56f,
    356.16f,  356.76f,  357.33f,  357.89f,  358.44f,
    358.97f,  359.49f,  360.00f,  360.49f,  360.98f,
    361.45f,  361.90f,  362.35f,  362.79f,  365.22f,
    367.64f,  369.04f,  373.44f,  378.84f,  384.22f,
    389.59f,  395.96f,  402.32f,  410.67f,  419.01f,
    429.35f,  440.68f,  452.00f,  465.32f,  479.63f,
    494.93f,  510.23f,  527.52f,  545.81f,  562.09f,
    580.37f,  599.64f,  619.91f,  640.17f,  662.43f,
    685.68f,  709.93f,  773.17f,  852.41f,  932.65f,
    1013.88f, 1104.11f, 1213.35f, 1324.60f, 1431.86f,
    1542.13f
};

typedef struct _skill_name_table
{
    char *name;
    int id;
}_skill_name_table;

static _skill_name_table skill_name_table[] =
{
    {"agility", CS_STAT_SKILLEXP_AGILITY},
    {"personality", CS_STAT_SKILLEXP_PERSONAL},
    {"mental", CS_STAT_SKILLEXP_MENTAL},
    {"physique", CS_STAT_SKILLEXP_PHYSIQUE},
    {"magic", CS_STAT_SKILLEXP_MAGIC},
    {"wisdom", CS_STAT_SKILLEXP_WISDOM},
    {"", -1}
};

static int item_skill_cs_stat[] =
{
    0,
    CS_STAT_SKILLEXP_AGILITY,
    CS_STAT_SKILLEXP_PERSONAL,
    CS_STAT_SKILLEXP_MENTAL,
    CS_STAT_SKILLEXP_PHYSIQUE,
    CS_STAT_SKILLEXP_MAGIC,
    CS_STAT_SKILLEXP_WISDOM
};

static int change_skill_to_skill(object *who, object *skl);
static int attack_melee_weapon(object *op, int dir);
static int attack_hth(object *pl, int dir, char *string);
static int do_skill_attack(object *tmp, object *op, char *string);

static void find_skill_exp_name(object *pl, object *exp, int idx)
{
    int s;

    for (s = 0; skill_name_table[s].id != -1; s++)
    {
        if (!strcmp(skill_name_table[s].name, exp->name))
        {
            CONTR(pl)->last_skill_ob[idx] = exp;
            CONTR(pl)->last_skill_id[idx] = skill_name_table[s].id;
            CONTR(pl)->last_skill_index++;
            return;
        }
    }
}

int find_skill_exp_level(object *pl, int item_skill)
{
    int s;

    for (s = 0; s < CONTR(pl)->last_skill_index; s++)
    {
        if (CONTR(pl)->last_skill_id[s] == item_skill_cs_stat[item_skill])
        {
            return CONTR(pl)->last_skill_ob[s]->level;
        }
    }

    return 0;
}

char *find_skill_exp_skillname(int item_skill)
{
    if (!item_skill || item_skill > 6)
    {
        return skill_name_table[6].name;
    }

    return skill_name_table[item_skill - 1].name;
}

sint64 do_skill(object *op, int dir, const char *params)
{
    sint64 success = 0;
    int skill = op->chosen_skill->stats.sp;

    /* Trigger the map-wide skill event. */
    if (op->map && op->map->events)
    {
        int retval = trigger_map_event(MEVENT_SKILL_USED, op->map, op, NULL, NULL, NULL, dir);

        /* So the plugin's return value can affect the returned value. */
        if (retval)
        {
            return retval - 1;
        }
    }

    switch (skill)
    {
        case SK_KARATE:
            attack_hth(op, dir, "karate-chopped");
            break;

        case SK_BOXING:
            attack_hth(op, dir, "punched");
            break;

        case SK_MELEE_WEAPON:
        case SK_SLASH_WEAP:
        case SK_CLEAVE_WEAP:
        case SK_PIERCE_WEAP:
            attack_melee_weapon(op, dir);
            break;

        case SK_FIND_TRAPS:
            success = find_traps(op, CONTR(op)->exp_ptr[EXP_AGILITY]->level);
            break;

        case SK_REMOVE_TRAP:
            success = remove_trap(op);
            break;

        case SK_THROWING:
            new_draw_info(0, COLOR_WHITE, op, "This skill is not usable in this way.");
            break;

        case SK_USE_MAGIC_ITEM:
        case SK_MISSILE_WEAPON:
            new_draw_info(0, COLOR_WHITE, op, "There is no special attack for this skill.");
            return success;
            break;

        case SK_PRAYING:
            new_draw_info(0, COLOR_WHITE, op, "This skill is not usable in this way.");
            return success;
            break;

        case SK_SPELL_CASTING:
        case SK_BARGAINING:
            new_draw_info(0, COLOR_WHITE, op, "This skill is already in effect.");
            return success;
            break;

        case SK_CONSTRUCTION:
            construction_do(op, dir);
            return success;

        case SK_INSCRIPTION:
            success = skill_inscription(op, params);
            break;

        default:
            LOG(llevDebug, "%s attempted to use unknown skill: %d\n", query_name(op, NULL), op->chosen_skill->stats.sp);
            return success;
            break;
    }

    /* For players we now update the speed_left from using the skill.
     * Monsters have no skill use time because of the random nature in
     * which use_monster_skill is called already simulates this. -b.t. */
    if (op->type == PLAYER)
    {
        op->speed_left -= get_skill_time(op,skill);
    }

    /* This is a good place to add experience for successfull use of skills.
     * Note that add_exp() will figure out player/monster experience
     * gain problems. */
    if (success && skills[skill].category != EXP_NONE)
    {
        add_exp(op, success, op->chosen_skill->stats.sp, 0);
    }

    return success;
}

sint64 calc_skill_exp(object *who, object *op, int level)
{
    int who_lvl = level;
    sint64 op_exp = 0;
    int op_lvl = 0;
    float exp_mul, max_mul, tmp;

    /* No exp for non players. */
    if (!who || who->type != PLAYER)
    {
        LOG(llevDebug, "calc_skill_exp() called with who != PLAYER or NULL (%s (%s)- %s)\n", query_name(who, NULL), !who ? "NULL" : "", query_name(op, NULL));
        return 0;
    }

    if (level == -1)
    {
        /* The related skill level */
        who_lvl = SK_level(who);
    }

    if (!op)
    {
        LOG(llevBug, "calc_skill_exp() called with op == NULL (%s - %s)\n", query_name(who, NULL), query_name(op, NULL));
        op_lvl = who->map->difficulty < 1 ? 1: who->map->difficulty;
        op_exp = 0;
    }
    /* All other items/living creatures */
    else
    {
        op_exp = op->stats.exp;
        op_lvl = op->level;
    }

    /* No exp for no level and no exp ;) */
    if (op_lvl < 1 || op_exp < 1)
    {
        return 0;
    }

    if (who_lvl < 2)
    {
        max_mul = 0.85f;
    }

    if (who_lvl < 3)
    {
        max_mul = 0.7f;
    }
    else if (who_lvl < 4)
    {
        max_mul = 0.6f;
    }
    else if (who_lvl < 5)
    {
        max_mul = 0.45f;
    }
    else if (who_lvl < 7)
    {
        max_mul = 0.35f;
    }
    else if (who_lvl < 8)
    {
        max_mul = 0.3f;
    }
    else
    {
        max_mul = 0.25f;
    }

    /* We first get a global level difference multiplicator */
    exp_mul = calc_level_difference(who_lvl, op_lvl);
    op_exp = (int) ((float) op_exp * lev_exp[op_lvl] * exp_mul);
    tmp = ((float) (new_levels[who_lvl + 1] - new_levels[who_lvl]) * 0.1f) * max_mul;

    if ((float) op_exp > tmp)
    {
        op_exp = (int) tmp;
    }

    return op_exp;
}

static void init_exp_obj()
{
    archetype *at;

    for (at = first_archetype; at; at = at->next)
    {
        if (at->clone.type == EXPERIENCE)
        {
            exp_cat[nrofexpcat] = get_object();
            exp_cat[nrofexpcat]->level = 1;
            exp_cat[nrofexpcat]->stats.exp = 0;
            copy_object(&at->clone, exp_cat[nrofexpcat], 0);
            /* avoid gc on these objects */
            insert_ob_in_ob(exp_cat[nrofexpcat], &void_container);
            nrofexpcat++;

            if (nrofexpcat == MAX_EXP_CAT)
            {
                LOG(llevSystem, "Aborting! Reached limit of available experience\n");
                LOG(llevError, "categories. Need to increase value of MAX_EXP_CAT.\n");
                exit(0);
            }
        }
    }

    if (!nrofexpcat)
    {
        LOG(llevError, "Aborting! No experience objects found in archetypes.\n");
        exit(0);
    }
}

void init_new_exp_system()
{
    static int init_new_exp_done = 0;
    int i;
    FILE *fp;
    char filename[MAX_BUF];

    if (init_new_exp_done)
    {
        return;
    }

    init_new_exp_done = 1;

    /* Locate the experience objects and create list of them */
    init_exp_obj();

    for (i = 0; i < NROFSKILLS; i++)
    {
        /* Link the skill archetype ptr to skill list for fast access.
         * Now we can access the skill archetype by skill number or skill name. */
        if (!(skills[i].at = get_skill_archetype(i)))
        {
            LOG(llevError, "Aborting! Skill #%d (%s) not found in archlist!\n", i, skills[i].name);
        }
    }

    snprintf(filename, sizeof(filename), "%s/%s", settings.localdir, SRV_CLIENT_SKILLS_FILENAME);
    fp = fopen(filename, "w");

    if (!fp)
    {
        LOG(llevError, "Cannot open file '%s' for writing.\n", filename);
    }

    for (i = 0; i < NROFSKILLS; i++)
    {
        if (skills[i].description)
        {
            char icon[MAX_BUF], tmpresult[MAX_BUF];

            replace(skills[i].name, " ", "_", tmpresult, sizeof(tmpresult));
            snprintf(icon, sizeof(icon), "icon_%s.101", tmpresult);

            if (!find_face(icon, 0))
            {
                LOG(llevError, "Skill '%s' needs face '%s', but it could not be found.\n", skills[i].name, icon);
            }

            fprintf(fp, "%s\n%d\n%s\n%s\nend\n", skills[i].name, skills[i].category - 1, icon, skills[i].description);
        }
    }

    fclose(fp);
}

void free_exp_objects()
{
    int i;

    for (i = 0; i < MAX_EXP_CAT; i++)
    {
        if (!exp_cat[i])
        {
            continue;
        }

        SET_FLAG(exp_cat[i], FLAG_REMOVED);
        return_poolchunk(exp_cat[i], pool_object);
    }
}

void dump_skills()
{
    int i;

    LOG(llevInfo, "exper_catgry \t str \t dex \t con \t wis \t cha \t int \t pow \n");

    for (i = 0; i < nrofexpcat; i++)
    {
        LOG(llevInfo, "%d-%s \t %d \t %d \t %d \t %d \t %d \t %d \t %d \n", i, exp_cat[i]->name, exp_cat[i]->stats.Str, exp_cat[i]->stats.Dex, exp_cat[i]->stats.Con, exp_cat[i]->stats.Wis, exp_cat[i]->stats.Cha, exp_cat[i]->stats.Int, exp_cat[i]->stats.Pow);
    }

    LOG(llevInfo, "\n");
    LOG(llevInfo, "%20s  %12s  %4s %4s %4s  %5s %5s %5s\n", "sk#       Skill name", "ExpCat", "Time", "Base", "xlvl", "Stat1", "Stat2", "Stat3");
    LOG(llevInfo, "%20s  %12s  %4s %4s %4s  %5s %5s %5s\n", "---       ----------", "------", "----", "----", "----", "-----", "-----", "-----");

    for (i = 0; i < NROFSKILLS; i++)
    {
        LOG(llevInfo, "%2d-%17s  %12s  %4d\n", i, skills[i].name, exp_cat[skills[i].category] != NULL ? exp_cat[skills[i].category]->name : "NONE", skills[i].time);
    }
}

int check_skill_known(object *op, int skillnr)
{
    object *tmp;

    for (tmp = op->inv; tmp; tmp = tmp->below)
    {
        if (tmp->type == SKILL && tmp->stats.sp == skillnr)
        {
            return 1;
        }
    }

    return 0;
}

int lookup_skill_by_name(const char *string)
{
    int skillnr = 0;
    size_t nmlen;
    char name[MAX_BUF];

    if (!string)
    {
        return -1;
    }

    strcpy(name, string);
    nmlen = strlen(name);

    for (skillnr = 0; skillnr < NROFSKILLS; skillnr++)
    {
        if (strlen(name) >= strlen(skills[skillnr].name))
        {
            if (!strncmp(name, skills[skillnr].name, MIN(strlen(skills[skillnr].name), nmlen)))
            {
                return skillnr;
            }
        }
    }

    return -1;
}

int check_skill_to_fire(object *who)
{
    int skillnr = 0;
    object *tmp;
    rangetype shoottype = range_none;

    if (who->type != PLAYER)
    {
        return 1;
    }

    switch ((shoottype = CONTR(who)->shoottype))
    {
        case range_bow:
            if (!(tmp = CONTR(who)->equipment[PLAYER_EQUIP_BOW]))
            {
                return 0;
            }

            if (tmp->sub_type == 2)
            {
                skillnr = SK_SLING_WEAP;
            }
            else if (tmp->sub_type == 1)
            {
                skillnr = SK_XBOW_WEAP;
            }
            else
            {
                skillnr = SK_MISSILE_WEAPON;
            }

            break;

        case range_none:
        case range_skill:
            return 1;
            break;

        case range_magic:
            if (spells[CONTR(who)->chosen_spell].type == SPELL_TYPE_PRIEST)
            {
                skillnr = SK_PRAYING;
            }
            else
            {
                skillnr = SK_SPELL_CASTING;
            }

            break;

        case range_scroll:
        case range_rod:
        case range_horn:
        case range_wand:
            skillnr = SK_USE_MAGIC_ITEM;
            break;

        default:
            LOG(llevBug, "bad call of check_skill_to_fire() from %s\n", query_name(who, NULL));
            return 0;
    }

    if (change_skill(who, skillnr))
    {
#ifdef SKILL_UTIL_DEBUG
        LOG(llevDebug, "check_skill_to_fire(): got skill:%s for %s\n", skills[skillnr].name, who->name);
#endif
        CONTR(who)->shoottype = shoottype;
        return 1;
    }

    return 0;
}

int check_skill_to_apply(object *who, object *item)
{
    int skill = 0, tmp;
    /* perhaps we need a additional skill to use */
    int add_skill = NO_SKILL_READY;

    /* Only for players. */
    if (who->type != PLAYER)
    {
        return 1;
    }

    /* First figure out the required skills from the item */
    switch (item->type)
    {
        case WEAPON:
            tmp = item->sub_type;

            /* Polearm */
            if (tmp >= WEAP_POLE_IMPACT)
            {
                /* Select the right weapon type. */
                tmp = item->sub_type - WEAP_POLE_IMPACT;
                add_skill = SK_POLEARMS;
            }
            /* Two handed  */
            else if (tmp >= WEAP_2H_IMPACT)
            {
                /* Select the right weapon type. */
                tmp = item->sub_type - WEAP_2H_IMPACT;
                add_skill = SK_TWOHANDS;
            }

            if (tmp == WEAP_1H_IMPACT)
            {
                skill = SK_MELEE_WEAPON;
            }
            else if (tmp == WEAP_1H_SLASH)
            {
                skill = SK_SLASH_WEAP;
            }
            else if (tmp == WEAP_1H_CLEAVE)
            {
                skill = SK_CLEAVE_WEAP;
            }
            else if (tmp == WEAP_1H_PIERCE)
            {
                skill = SK_PIERCE_WEAP;
            }

            break;

        case BOW:
            skill = bow_get_skill(item);
            break;

        case POTION:
            skill = SK_USE_MAGIC_ITEM;
            break;

        case SCROLL:
            skill = SK_LITERACY;
            break;

        case ROD:
            skill = SK_USE_MAGIC_ITEM;
            break;

        case WAND:
            skill = SK_USE_MAGIC_ITEM;
            break;

        case HORN:
            skill = SK_USE_MAGIC_ITEM;
            break;

        default:
            LOG(llevDebug, "Warning: bad call of check_skill_to_apply()\n");
            LOG(llevDebug, "No skill exists for item: %s\n", query_name(item, NULL));
            return 0;
    }

    /* This should not happen */
    if (skill == NO_SKILL_READY)
    {
        LOG(llevBug, "check_skill_to_apply() called for %s and item %s with skill NO_SKILL_READY\n", query_name(who, NULL), query_name(item, NULL));
    }

    /* Check the additional skill if there is one */
    if (add_skill != NO_SKILL_READY)
    {
        if (!change_skill(who, add_skill))
        {
            return 0;
        }

        change_skill(who, NO_SKILL_READY);
    }

    /* If this skill is ready, all is fine. if not, ready it, if it can't
     * readied, we can't apply/use/do it. */
    if (!who->chosen_skill || (who->chosen_skill && who->chosen_skill->stats.sp != skill))
    {
        if (!change_skill(who, skill))
        {
            return 0;
        }
    }

    return 1;
}

int init_player_exp(object *pl)
{
    int i, j, exp_index = 0;
    object *tmp, *exp_ob[MAX_EXP_CAT];

    if (pl->type != PLAYER)
    {
        LOG(llevBug, "init_player_exp(): called non-player %s.\n", query_name(pl, NULL));
        return 0;
    }

    CONTR(pl)->last_skill_index = 0;

    /* First-pass find all current exp objects */
    for (tmp = pl->inv; tmp; tmp = tmp->below)
    {
        if (tmp->type == EXPERIENCE)
        {
            exp_ob[exp_index] = tmp;
            CONTR(pl)->exp_ptr[tmp->sub_type] = tmp;
            find_skill_exp_name(pl, tmp, CONTR(pl)->last_skill_index);
            exp_index++;
        }
        else if (exp_index == MAX_EXP_CAT)
        {
            return 0;
        }
    }

    /* Second - if pl has wrong nrof experience objects
     * then give player a complete roster. */

    /* No exp objects - situation for a new player
     * or pre-skills/exp code player file */
    if (!exp_index)
    {
        for (j = 0; j < nrofexpcat; j++)
        {
            tmp = get_object();
            copy_object(exp_cat[j], tmp, 0);
            insert_ob_in_ob(tmp, pl);
            tmp->stats.exp = 0;
            exp_ob[j] = tmp;
            CONTR(pl)->exp_ptr[tmp->sub_type] = tmp;

            esrv_send_item(pl, tmp);
            exp_index++;
        }
    }

    /* Now we loop through one more time and set "apply" flag on valid
     * experience objects. Fix_player() requires this, and we get the
     * bonus of being able to ignore invalid experience objects in the
     * player inventory (player file from another game set up?). Also, we
     * reset the score (or "total" experience) of the player to be the
     * sum of all valid experience objects. */
    pl->stats.exp = 0;

    for (i = 0; i < exp_index; i++)
    {
        if (!QUERY_FLAG(exp_ob[i], FLAG_APPLIED))
        {
            SET_FLAG(exp_ob[i], FLAG_APPLIED);
        }

        if (pl->stats.exp < exp_ob[i]->stats.exp && !QUERY_FLAG(exp_ob[i], FLAG_STAND_STILL))
        {
            pl->stats.exp = exp_ob[i]->stats.exp;
            pl->level = exp_ob[i]->level;
        }

        player_lvl_adj(NULL, exp_ob[i]);
    }

    return 1;
}

void unlink_skill(object *skillop)
{
    object *op = skillop ? skillop->env : NULL;

    if (!op || op->type != PLAYER)
    {
        LOG(llevBug, "unlink_skill() called for non-player %s!\n", query_name(op, NULL));
        return;
    }

    send_skilllist_cmd(op, skillop, SPLIST_MODE_REMOVE);
    skillop->exp_obj = NULL;
}

void link_player_skills(object *pl)
{
    int i, cat = 0, sk_index = 0, exp_index = 0;
    object *tmp, *sk_ob[NROFSKILLS], *exp_ob[MAX_EXP_CAT];

    /* We're going to unapply all skills */
    pl->chosen_skill = NULL;
    CONTR(pl)->last_skill_index = 0;

    /* First find all exp and skill objects */
    for (tmp = pl->inv; tmp && sk_index < 1000; tmp = tmp->below)
    {
        if (tmp->type == EXPERIENCE)
        {
            CONTR(pl)->exp_ptr[tmp->sub_type] = tmp;
            exp_ob[tmp->sub_type] = tmp;
            find_skill_exp_name(pl, tmp, CONTR(pl)->last_skill_index);
            tmp->nrof = 1;
            exp_index++;
        }
        else if (tmp->type == SKILL)
        {
            /* For startup, lets unapply all skills */
            CLEAR_FLAG(tmp, FLAG_APPLIED);
            tmp->nrof = 1;
            sk_ob[sk_index] = tmp;
            sk_index++;
        }
    }

    /* Ok, create linked list and link the associated skills to exp objects */
    for (i = 0; i < sk_index; i++)
    {
        cat = skills[sk_ob[i]->stats.sp].category;

        if (cat == EXP_NONE)
        {
            continue;
        }

        sk_ob[i]->exp_obj = exp_ob[cat];
    }
}

int link_player_skill(object *pl, object *skillop)
{
    object *tmp;
    int cat = skills[skillop->stats.sp].category;

    /* Ok the skill has an exp object, now find right one in pl inv */
    if (cat != EXP_NONE)
    {
        for (tmp = pl->inv; tmp; tmp = tmp->below)
        {
            if (tmp->type == EXPERIENCE && tmp->sub_type == cat)
            {
                skillop->exp_obj = tmp;
                break;
            }
        }

        return 1;
    }

    skillop->exp_obj = NULL;
    return 0;
}

int learn_skill(object *pl, object *scroll, char *name, int skillnr, int scroll_flag)
{
    object *tmp, *tmp2;
    archetype *skill = NULL;

    if (scroll)
    {
        skill = find_archetype(scroll->slaying);
    }
    else if (name)
    {
        skill = find_archetype(name);
    }
    else
    {
        skill = skills[skillnr].at;
    }

    if (!skill)
    {
        return 2;
    }

    tmp = arch_to_object(skill);

    if (!tmp)
    {
        return 2;
    }

    /* Check if player already has it */
    for (tmp2 = pl->inv; tmp2; tmp2 = tmp2->below)
    {
        if (tmp2->type == SKILL)
        {
            if (tmp2->stats.sp == tmp->stats.sp)
            {
                new_draw_info_format(0, COLOR_WHITE, pl, "You already know the skill '%s'!", tmp->name);
                return 0;
            }
        }
    }

    /* Now a random chance to learn, based on player Int */
    if (scroll_flag)
    {
        /* Failure */
        if (rndm(0, 99) > learn_spell[pl->stats.Int])
        {
            return 2;
        }
    }

    /* Everything is cool. Give 'em the skill */
    insert_ob_in_ob(tmp,pl);
    link_player_skill(pl, tmp);
    play_sound_player_only (CONTR(pl), CMD_SOUND_EFFECT, "learnspell.ogg", 0, 0, 0, 0);
    new_draw_info_format(0, COLOR_WHITE, pl, "You have learned the skill %s!", tmp->name);

    send_skilllist_cmd(pl, tmp, SPLIST_MODE_ADD);
    esrv_send_item(pl, tmp);

    return 1;
}

int use_skill(object *op, char *string)
{
    int sknum = -1;

    /* The skill name appears at the beginning of the string,
     * need to reset the string to next word, if it exists. */
    if (string && (sknum = lookup_skill_by_name(string)) >= 0)
    {
        size_t len;

        if (sknum == -1)
        {
            new_draw_info_format(0, COLOR_WHITE, op, "Unable to find skill by name %s", string);
            return 0;
        }

        len = strlen(skills[sknum].name);

        /* All this logic goes and skips over the skill name to find any
         * options given to the skill. */
        if (len >= strlen(string))
        {
            *string = '\0';
        }
        else
        {
            while (len--)
            {
                string++;
            }

            while (*string == ' ')
            {
                string++;
            }
        }

        if (strlen(string) == 0)
        {
            string = NULL;
        }
    }

#ifdef SKILL_UTIL_DEBUG
    LOG(llevDebug, "use_skill(): got skill: %s\n", sknum > -1 ? skills[sknum].name : "none");
#endif

    /* Change to the new skill, then execute it. */
    if (change_skill(op, sknum))
    {
        if (op->chosen_skill->sub_type != ST1_SKILL_USE)
        {
            new_draw_info(0, COLOR_WHITE, op, "You can't use this skill in this way.");
        }
        else
        {
            if (do_skill(op, op->facing, string))
            {
                return 1;
            }
        }
    }

    return 0;
}

int change_skill(object *who, int sk_index)
{
    object *tmp;

    if (who->chosen_skill && who->chosen_skill->stats.sp == sk_index)
    {
        /* optimization for changing skill to current skill */
        if (who->type == PLAYER)
        {
            CONTR(who)->shoottype = range_skill;
        }

        return 1;
    }

    if (sk_index >= 0 && sk_index < NROFSKILLS && (tmp = find_skill(who, sk_index)) != NULL)
    {
        if (apply_special(who, tmp, AP_APPLY))
        {
            LOG(llevBug, "change_skill(): can't apply new skill (%s - %d)\n", who->name, sk_index);
            return 0;
        }

        return 1;
    }

    if (who->chosen_skill)
    {
        if (apply_special(who, who->chosen_skill, AP_UNAPPLY))
        {
            LOG(llevBug, "change_skill(): can't unapply old skill (%s - %d)\n", who->name, sk_index);
        }
    }

    if (sk_index >= 0)
    {
        new_draw_info_format(0, COLOR_WHITE, who, "You have no knowledge of %s.", skills[sk_index].name);
    }

    return 0;
}

static int change_skill_to_skill(object *who, object *skl)
{
    /* Quick sanity check */
    if (!skl)
    {
        return 1;
    }

    if (who->chosen_skill == skl)
    {
        /* Optimization for changing skill to current skill */
        if (who->type == PLAYER)
        {
            CONTR(who)->shoottype = range_skill;
        }

        return 0;
    }

    if (skl->env != who)
    {
        LOG(llevBug, "change_skill_to_skill: skill is not in players inventory (%s - %s)\n", query_name(who, NULL), query_name(skl, NULL));
        return 1;
    }

    if (apply_special(who, skl, AP_APPLY))
    {
        LOG(llevBug, "change_skill(): can't apply new skill (%s - %s)\n", query_name(who, NULL), query_name(skl, NULL));
        return 1;
    }

    return 0;
}

static int attack_melee_weapon(object *op, int dir)
{
    if (!QUERY_FLAG(op, FLAG_READY_WEAPON))
    {
        if (op->type == PLAYER)
        {
            new_draw_info(0, COLOR_WHITE, op, "You have no ready weapon to attack with!");
        }

        return 0;
    }

    return skill_attack(NULL, op, dir, NULL);
}

static int attack_hth(object *pl, int dir, char *string)
{
    object *enemy = NULL, *weapon;

    if (QUERY_FLAG(pl, FLAG_READY_WEAPON))
    {
        for (weapon = pl->inv; weapon; weapon = weapon->below)
        {
            if (weapon->type != WEAPON || !QUERY_FLAG(weapon, FLAG_APPLIED))
            {
                continue;
            }

            CLEAR_FLAG(weapon, FLAG_APPLIED);
            CLEAR_FLAG(pl, FLAG_READY_WEAPON);
            fix_player(pl);

            if (pl->type == PLAYER)
            {
                new_draw_info(0, COLOR_WHITE, pl, "You unwield your weapon in order to attack.");
                esrv_update_item(UPD_FLAGS, pl, weapon);
            }

            break;
        }
    }

    return skill_attack(enemy, pl, dir, string);
}

int skill_attack(object *tmp, object *pl, int dir, char *string)
{
    int xt, yt;
    mapstruct *m;

    if (!dir)
    {
        dir = pl->facing;
    }

    /* If we don't yet have an opponent, find if one exists, and attack.
     * Legal opponents are the same as outlined in move_player() */
    if (tmp == NULL)
    {
        xt = pl->x + freearr_x[dir];
        yt = pl->y + freearr_y[dir];

        if (!(m = get_map_from_coord(pl->map, &xt,&yt)))
        {
            return 0;
        }

        for (tmp = get_map_ob(m, xt, yt); tmp; tmp = tmp->above)
        {
            if ((IS_LIVE(tmp) && (tmp->head == NULL ? tmp->stats.hp > 0 : tmp->head->stats.hp > 0)) || QUERY_FLAG(tmp, FLAG_CAN_ROLL) || tmp->type == DOOR)
            {
                if (pl->type == PLAYER && tmp->type == PLAYER && !pvp_area(pl, tmp))
                {
                    continue;
                }

                break;
            }
        }
    }

    if (tmp != NULL)
    {
        return do_skill_attack(tmp, pl, string);
    }

    if (pl->type == PLAYER)
    {
        new_draw_info(0, COLOR_WHITE, pl, "There is nothing to attack!");
    }

    return 0;
}

static int do_skill_attack(object *tmp, object *op, char *string)
{
    int success;
    char *name = query_name(tmp, NULL);

    if (op->type == PLAYER)
    {
        /* No selected weapon, change to our hth skill. */
        if (!CONTR(op)->selected_weapon)
        {
            if (CONTR(op)->skill_weapon)
            {
                if (change_skill_to_skill(op, CONTR(op)->skill_weapon))
                {
                    LOG(llevBug, "do_skill_attack(): couldn't give new hth skill to %s\n", query_name(op, NULL));
                    return 0;
                }
            }
            else
            {
                LOG(llevBug, "do_skill_attack(): no hth skill in player %s\n", query_name(op, NULL));
                return 0;
            }
        }
    }

    /* If we have 'ready weapon' but no 'melee weapons' skill readied
     * this will flip to that skill. This is only window dressing for
     * the players -- no need to do this for monsters. */
    if (op->type == PLAYER && QUERY_FLAG(op, FLAG_READY_WEAPON) && (!op->chosen_skill || op->chosen_skill->stats.sp != CONTR(op)->set_skill_weapon))
    {
        change_skill(op, CONTR(op)->set_skill_weapon);
    }

    success = attack_ob(tmp, op);

    /* Print appropriate messages to the player. */
    if (success && string != NULL)
    {
        if (op->type == PLAYER)
        {
            new_draw_info_format(0, COLOR_WHITE, op, "You %s %s!", string, name);
        }
        else if (tmp->type == PLAYER)
        {
            new_draw_info_format(0, COLOR_WHITE, tmp, "%s %s you!", query_name(op, NULL), string);
        }
    }

    return success;
}

int SK_level(object *op)
{
    object *head = op->head ? op->head : op;
    int level;

    if (head->type == PLAYER && head->chosen_skill && head->chosen_skill->level != 0)
    {
        level = head->chosen_skill->level;
    }
    else
    {
        level = head->level;
    }

    /* Safety */
    if (level <= 0)
    {
        LOG(llevBug, "SK_level(arch %s, name %s): level <= 0\n", op->arch->name, query_name(op, NULL));
        level = 1;
    }

    return level;
}

object *SK_skill(object *op)
{
    object *head = op->head ? op->head : op;

    if (head->type == PLAYER && head->chosen_skill)
    {
        return head->chosen_skill;
    }

    return NULL;
}

float get_skill_time(object *op, int skillnr)
{
    float skill_time = skills[skillnr].time;

    if (op->type != PLAYER)
    {
        return 0;
    }

    if (skillnr == SK_USE_MAGIC_ITEM || skillnr == SK_MISSILE_WEAPON || skillnr == SK_THROWING || skillnr == SK_XBOW_WEAP || skillnr == SK_SLING_WEAP)
    {
        CONTR(op)->action_range = global_round_tag + op->chosen_skill->stats.maxsp;
        return 0;
    }

    if (!skill_time)
    {
        return 0.0f;
    }
    else
    {
        int level = SK_level(op) / 10;

        /* Now this should be MUCH harder */
        if (skill_time > 1.0f)
        {
            skill_time -= (level / 3) * 0.1f;

            if (skill_time < 1.0f)
            {
                skill_time = 1.0f;
            }
        }
    }

    return FABS(skill_time);
}

int check_skill_action_time(object *op, object *skill)
{
    if (!skill)
    {
        return 0;
    }

    if (skill->stats.sp == SK_PRAYING || skill->stats.sp == SK_SPELL_CASTING)
    {
        if (CONTR(op)->action_casting > global_round_tag)
        {
            CONTR(op)->action_timer = (float) (CONTR(op)->action_casting - global_round_tag) / (1000000 / MAX_TIME) * 1000.0f;
            return 0;
        }
    }
    else
    {
        if (CONTR(op)->action_range > global_round_tag)
        {
            CONTR(op)->action_timer = (float)(CONTR(op)->action_range - global_round_tag) / (1000000 / MAX_TIME) * 1000.0f;
            return 0;
        }
    }

    return 1;
}