types/weapon_improver.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                        *
************************************************************************/

#include <global.h>

#define IMPROVE_PREPARE 1

#define IMPROVE_DAMAGE 2

#define IMPROVE_WEIGHT 3

#define IMPROVE_ENCHANT 4

#define IMPROVE_STR 5

#define IMPROVE_DEX 6

#define IMPROVE_CON 7

#define IMPROVE_WIS 8

#define IMPROVE_CHA 9

#define IMPROVE_INT 10

#define IMPROVE_POW 11

static int improve_weapon_stat(object *op, object *improver, object *weapon, signed char *stat, int sacrifice_count, char *statname);
static int prepare_weapon(object *op, object *improver, object *weapon);
static int improve_weapon(object *op, object *improver, object *weapon);
static void eat_item(object *op, const char *item);
static int check_item(object *op, const char *item);
static int check_sacrifice(object *op, object *improver);

void apply_weapon_improver(object *op, object *tmp)
{
    object *otmp;

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

    if (blocks_magic(op->map, op->x, op->y))
    {
        new_draw_info(0, COLOR_WHITE, op, "Something blocks the magic of the scroll.");
        return;
    }

    otmp = find_marked_object(op);

    if (!otmp || otmp->type != WEAPON)
    {
        new_draw_info(0, COLOR_WHITE, op, "You need to mark a weapon object.");
        return;
    }

    new_draw_info(0, COLOR_WHITE, op, "Applied weapon builder.");
    improve_weapon(op, tmp, otmp);
    esrv_send_item(op, otmp);
}

int check_weapon_power(object *who, int improvs)
{
    int level = who->level;

    /* The skill system hands out wc and dam bonuses to fighters
     * more generously than the old system (see fix_player). Thus
     * we need to curtail the power of player enchanted weapons.
     * I changed this to 1 improvement per "fighter" level/5 -b.t.
     * Note:  Nothing should break by allowing this ratio to be different or
     * using normal level - it is just a matter of play balance. */
    if (who->type == PLAYER)
    {
        object *wc_obj = NULL;

        for (wc_obj = who->inv; wc_obj; wc_obj = wc_obj->below)
        {
            if (wc_obj->type == EXPERIENCE && wc_obj->stats.Str)
            {
                break;
            }
        }

        if (!wc_obj)
        {
            LOG(llevBug, "Player: %s lacks wc experience object.\n", who->name);
        }
        else
        {
            level = wc_obj->level;
        }
    }

    return (improvs <= ((level / 5) + 5));
}

static int improve_weapon_stat(object *op, object *improver, object *weapon, signed char *stat_id, int sacrifice_count, char *stat_name)
{
    new_draw_info(0, COLOR_WHITE, op, "Your sacrifice was accepted.");
    *stat_id += sacrifice_count;
    weapon->last_eat++;
    new_draw_info_format(0, COLOR_WHITE, op, "Weapon's bonus to %s improved by %d.", stat_name, sacrifice_count);
    decrease_ob(improver);

    /* So it updates the players stats and the window */
    fix_player(op);
    return 1;
}

static int prepare_weapon(object *op, object *improver, object *weapon)
{
    int sacrifice_count, i;
    char buf[MAX_BUF];

    if (weapon->level != 0)
    {
        new_draw_info(0, COLOR_WHITE, op, "Weapon already prepared.");
        return 0;
    }

    for (i = 0; i < NROFATTACKS; i++)
    {
        if (weapon->protection[i])
        {
            break;
        }
    }

    /* If we break out, i will be less than nrofattacks, preventing
     * improvement of items that already have protections. */
    if (i < NROFATTACKS || weapon->stats.hp || weapon->stats.sp || weapon->stats.exp || weapon->stats.ac)
    {
        new_draw_info(0, COLOR_WHITE, op, "Cannot prepare magic weapons.");
        return 0;
    }

    sacrifice_count = check_sacrifice(op, improver);

    if (sacrifice_count <= 0)
    {
        return 0;
    }

    sacrifice_count = isqrt(sacrifice_count);
    weapon->level = sacrifice_count;
    new_draw_info(0, COLOR_WHITE, op, "Your sacrifice was accepted.");
    eat_item(op, improver->slaying);
    new_draw_info_format(0, COLOR_WHITE, op, "Your *%s may be improved %d times.", weapon->name, sacrifice_count);
    snprintf(buf, sizeof(buf), "%s's %s", op->name, weapon->name);
    FREE_AND_COPY_HASH(weapon->name, buf);

    /* prevents preparing n weapons in the same slot at once! */
    weapon->nrof = 0;
    decrease_ob(improver);
    weapon->last_eat = 0;
    return 1;
}

static int improve_weapon(object *op, object *improver, object *weapon)
{
    int sacrifice_count, sacrifice_needed = 0;

    if (improver->stats.sp == IMPROVE_PREPARE)
    {
        return prepare_weapon(op, improver, weapon);
    }

    if (weapon->level==0)
    {
        new_draw_info(0, COLOR_WHITE, op, "This weapon has not been prepared.");
        return 0;
    }

    if (weapon->level == weapon->last_eat)
    {
        new_draw_info(0, COLOR_WHITE, op, "This weapon cannot be improved any more.");
        return 0;
    }

    if (QUERY_FLAG(weapon, FLAG_APPLIED) && !check_weapon_power(op, weapon->last_eat + 1))
    {
        new_draw_info(0, COLOR_WHITE, op, "Improving the weapon will make it too powerful for you to use.\nUnready it if you really want to improve it.");
        return 0;
    }

    /* This just increases damage by 5 points, no matter what.  No sacrifice
     * is needed.  Since stats.dam is now a 16 bit value and not 8 bit,
     * don't put any maximum value on damage - the limit is how much the
     * weapon  can be improved. */
    if (improver->stats.sp == IMPROVE_DAMAGE)
    {
        weapon->stats.dam += 5;
        /* 5 KG's */
        weapon->weight += 5000;
        new_draw_info_format(0, COLOR_WHITE, op, "Damage has been increased by 5 to %d", weapon->stats.dam);
        weapon->last_eat++;
        decrease_ob(improver);

        return 1;
    }

    if (improver->stats.sp == IMPROVE_WEIGHT)
    {
        /* Reduce weight by 20% */
        weapon->weight = (weapon->weight * 8) / 10;

        if (weapon->weight < 1)
        {
            weapon->weight = 1;
        }

        new_draw_info_format(0, COLOR_WHITE, op, "Weapon weight reduced to %6.1f kg", (float)weapon->weight / 1000.0);
        weapon->last_eat++;
        decrease_ob(improver);
        return 1;
    }

    if (improver->stats.sp == IMPROVE_ENCHANT)
    {
        weapon->magic++;
        weapon->last_eat++;
        new_draw_info_format(0, COLOR_WHITE, op, "Weapon magic increased to %d", weapon->magic);
        decrease_ob(improver);
        return 1;
    }

    sacrifice_needed = weapon->stats.Str + weapon->stats.Int + weapon->stats.Dex + weapon->stats.Pow + weapon->stats.Con + weapon->stats.Cha + weapon->stats.Wis;

    if (sacrifice_needed < 1)
    {
        sacrifice_needed = 1;
    }

    sacrifice_needed *= 2;

    sacrifice_count = check_sacrifice(op, improver);

    if (sacrifice_count < sacrifice_needed)
    {
        new_draw_info_format(0, COLOR_WHITE, op, "You need at least %d %s", sacrifice_needed, improver->slaying);
        return 0;
    }

    eat_item(op, improver->slaying);

    switch (improver->stats.sp)
    {
        case IMPROVE_STR:
            return improve_weapon_stat(op, improver, weapon, (signed char *) &(weapon->stats.Str), 1, "strength");

        case IMPROVE_DEX:
            return improve_weapon_stat(op, improver, weapon, (signed char *) &(weapon->stats.Dex), 1, "dexterity");

        case IMPROVE_CON:
            return improve_weapon_stat(op, improver, weapon, (signed char *) &(weapon->stats.Con), 1, "constitution");

        case IMPROVE_WIS:
            return improve_weapon_stat(op, improver, weapon, (signed char *) &(weapon->stats.Wis), 1, "wisdom");

        case IMPROVE_CHA:
            return improve_weapon_stat(op, improver, weapon, (signed char *) &(weapon->stats.Cha), 1, "charisma");

        case IMPROVE_INT:
            return improve_weapon_stat(op, improver, weapon, (signed char *) &(weapon->stats.Int), 1, "intelligence");

        case IMPROVE_POW:
            return improve_weapon_stat(op, improver, weapon, (signed char *) &(weapon->stats.Pow), 1, "power");

        default:
            new_draw_info(0, COLOR_WHITE, op, "Unknown improvement type.");
    }

    LOG(llevBug, "improve_weapon(): Got to end of function!\n");

    return 0;
}

static void eat_item(object *op, const char *item)
{
    object *prev = op;

    op = op->below;

    while (op != NULL)
    {
        if (strcmp(op->arch->name, item) == 0)
        {
            decrease_ob_nr(op, op->nrof);
            op = prev;
        }

        prev = op;
        op = op->below;
    }
}

static int check_item(object *op, const char *item)
{
    int count = 0;

    if (item == NULL)
    {
        return 0;
    }

    op = op->below;

    while (op != NULL)
    {
        if (strcmp(op->arch->name, item) == 0)
        {
            if (!QUERY_FLAG(op, FLAG_CURSED) && !QUERY_FLAG(op, FLAG_DAMNED) && !QUERY_FLAG(op, FLAG_UNPAID))
            {
                /* this is necessary for artifact sacrifices --FD-- */
                if (op->nrof == 0)
                {
                    count++;
                }
                else
                {
                    count += op->nrof;
                }
            }
        }

        op = op->below;
    }

    return count;
}

static int check_sacrifice(object *op, object *improver)
{
    int count = 0;

    if (improver->slaying != NULL)
    {
        count = check_item(op, improver->slaying);

        if (count < 1)
        {
            new_draw_info_format(0, COLOR_WHITE, op, "The gods want more %ss.", improver->slaying);
            return 0;
        }
    }
    else
    {
        count = 1;
    }

    return count;
}