/home/leaf/crossfire/server/branches/1.12/types/weapon_improver/weapon_improver.c

Go to the documentation of this file.

/*
    CrossFire, A Multiplayer game for X-windows

    Copyright (C) 2007 Mark Wedel & Crossfire Development Team
    Copyright (C) 1992 Frank Tore Johansen

    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 authors can be reached via e-mail at crossfire-devel@real-time.com
*/

#include <global.h>
#include <ob_methods.h>
#include <ob_types.h>
#include <sounds.h>
#include <sproto.h>

static method_ret weapon_improver_type_apply(ob_methods *context, object *op, object *applier, int aflags);
static int check_item(object *op, const char *item);
static void eat_item(object *op, const char *item, uint32 nrof);
static int check_sacrifice(object *op, const object *improver);
static int improve_weapon_stat(object *op, object *improver, object *weapon, signed char *stat, int sacrifice_count, const char *statname);
static int prepare_weapon(object *op, object *improver, object *weapon);
static int improve_weapon(object *op, object *improver, object *weapon);

void init_type_weapon_improver(void) {
    register_apply(WEAPON_IMPROVER, weapon_improver_type_apply);
}

static method_ret weapon_improver_type_apply(ob_methods *context, object *op, object *applier, int aflags) {
    object *oop;

    if (applier->type != PLAYER)
        return METHOD_ERROR;
    if (!QUERY_FLAG(applier, FLAG_WIZCAST)
    && (get_map_flags(applier->map, NULL, applier->x, applier->y, NULL, NULL)&P_NO_MAGIC)) {
        draw_ext_info(NDI_UNIQUE, 0, applier, MSG_TYPE_APPLY, MSG_TYPE_APPLY_ERROR,
            "Something blocks the magic of the scroll.", NULL);
        return METHOD_ERROR;
    }

    oop = find_marked_object(applier);
    if (!oop) {
        draw_ext_info(NDI_UNIQUE, 0, applier, MSG_TYPE_APPLY, MSG_TYPE_APPLY_ERROR,
            "You need to mark a weapon object.", NULL);
        return METHOD_ERROR;
    }
    if (oop->type != WEAPON && oop->type != BOW) {
        draw_ext_info(NDI_UNIQUE, 0, applier, MSG_TYPE_APPLY, MSG_TYPE_APPLY_ERROR,
            "Marked item is not a weapon or bow", NULL);
        return METHOD_ERROR;
    }
    draw_ext_info(NDI_UNIQUE, 0, applier, MSG_TYPE_APPLY, MSG_TYPE_APPLY_SUCCESS,
        "Applied weapon builder.", NULL);
    improve_weapon(applier, op, oop);
    esrv_update_item(UPD_NAME|UPD_NROF|UPD_FLAGS, applier, oop);
    return METHOD_OK;
}

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)
            /* Loophole bug? -FD- */ && !QUERY_FLAG(op, FLAG_UNPAID)) {
                if (op->nrof == 0)/* this is necessary for artifact sacrifices --FD-- */
                    count++;
                else
                    count += op->nrof;
            }
        }
        op = op->below;
    }
    return count;
}

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

    prev = op;
    op = op->below;

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

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

    if (improver->slaying != NULL) {
        count = check_item(op, improver->slaying);
        if (count < 1) {
            draw_ext_info_format(NDI_UNIQUE, 0, op, MSG_TYPE_APPLY, MSG_TYPE_APPLY_ERROR,
                "The gods want more %ss",
                "The gods want more %ss",
                improver->slaying);
            return 0;
        }
    } else
        count = 1;

    return count;
}

static int improve_weapon_stat(object *op, object *improver, object *weapon, signed char *stat, int sacrifice_count, const char *statname) {

    draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_APPLY, MSG_TYPE_APPLY_SUCCESS,
        "Your sacrifice was accepted.", NULL);

    *stat += sacrifice_count;
    weapon->last_eat++;

    draw_ext_info_format(NDI_UNIQUE, 0, op, MSG_TYPE_APPLY, MSG_TYPE_APPLY_SUCCESS,
        "Weapon's bonus to %s improved by %d",
        "Weapon's bonus to %s improved by %d",
        statname, sacrifice_count);

    decrease_ob(improver);

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

/* Types of improvements, hidden in the sp field. */
#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 prepare_weapon(object *op, object *improver, object *weapon) {
    int sacrifice_count, i;
    char buf[MAX_BUF];

    if (weapon->level != 0) {
        draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_APPLY, MSG_TYPE_APPLY_ERROR,
            "Weapon already prepared.", NULL);
        return 0;
    }
    for (i = 0; i < NROFATTACKS; i++)
        if (weapon->resist[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        /* regeneration */
    || (weapon->stats.sp && weapon->type == WEAPON) /* sp regeneration */
    || weapon->stats.exp       /* speed */
    || weapon->stats.ac) {     /* AC - only taifu's I think */
        draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_APPLY, MSG_TYPE_APPLY_ERROR,
            "Cannot prepare magic weapons.", NULL);
        return 0;
    }

    sacrifice_count = check_sacrifice(op, improver);
    if (sacrifice_count <= 0)
        return 0;

    /* We do not allow improving stacks, so split this off from
     * stack.  Only need to do this if weapon is part of a stack.
     * We set nrof of weapon to zero so it can not merge with other
     * items, so one can not do further improvements on a stack.
     * side effect of doing it before the insert_ob_in_ob is that
     * it won't merge back in.  We know from the code that marked
     * objects must be in the players inventory, so we know where
     * to put this.
     */
    if (weapon->nrof >1) {
        weapon = get_split_ob(weapon,1, NULL, 0);
        weapon->nrof = 0;
        insert_ob_in_ob(weapon, op); 
    } else {
        weapon->nrof = 0;
    }
        

    weapon->level = isqrt(sacrifice_count);
    draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_APPLY, MSG_TYPE_APPLY_SUCCESS,
        "Your sacrifice was accepted.", NULL);
    eat_item(op, improver->slaying, sacrifice_count);


    snprintf(buf, sizeof(buf), "%s's %s", op->name, weapon->name);
    FREE_AND_COPY(weapon->name, buf);
    FREE_AND_COPY(weapon->name_pl, buf);

    draw_ext_info_format(NDI_UNIQUE, 0, op, MSG_TYPE_APPLY, MSG_TYPE_APPLY_SUCCESS,
        "Your %s may be improved %d times.",
        "Your %s may be improved %d times.",
        weapon->name, weapon->level);

    decrease_ob(improver);
    weapon->last_eat = 0;
    esrv_update_item(UPD_NAME | UPD_NROF, op, weapon);
    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) {
        draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_APPLY, MSG_TYPE_APPLY_ERROR,
            "This weapon has not been prepared.", NULL);
        return 0;
    }

    if (weapon->level == weapon->last_eat && weapon->item_power >= MAX_WEAPON_ITEM_POWER) {
        draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_APPLY, MSG_TYPE_APPLY_ERROR,
            "This weapon cannot be improved any more.", NULL);
        return 0;
    }

    if (QUERY_FLAG(weapon, FLAG_APPLIED)
    && !check_weapon_power(op, weapon->last_eat+1)) {
        draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_APPLY, MSG_TYPE_APPLY_ERROR,
            "Improving the weapon will make it too powerful for you to use.  Unready it if you really want to improve it.", NULL);
        return 0;
    }

    /* All improvements add to item power, so check if player can
     * still wear the weapon after improvement.
     */
    if (QUERY_FLAG(weapon, FLAG_APPLIED)
    && op->type == PLAYER
    && (op->contr->item_power+1) > (settings.item_power_factor*op->level)) {
        apply_special(op, weapon, AP_UNAPPLY);
        if (QUERY_FLAG(weapon, FLAG_APPLIED)) {
            /* Weapon is cursed, too bad */
            draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_APPLY, MSG_TYPE_APPLY_ERROR,
                "You can't enchant this weapon without unapplying it because it would consume your soul!", NULL);
            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;
        weapon->weight += 5000;         /* 5 KG's */
        draw_ext_info_format(NDI_UNIQUE, 0, op, MSG_TYPE_APPLY, MSG_TYPE_APPLY_SUCCESS,
            "Damage has been increased by 5 to %d",
            "Damage has been increased by 5 to %d",
            weapon->stats.dam);
        weapon->last_eat++;

        weapon->item_power++;
        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;
        draw_ext_info_format(NDI_UNIQUE, 0, op, MSG_TYPE_APPLY, MSG_TYPE_APPLY_SUCCESS,
            "Weapon weight reduced to %6.1f kg",
            "Weapon weight reduced to %6.1f kg",
            (float)weapon->weight/1000.0);
        weapon->last_eat++;
        weapon->item_power++;
        decrease_ob(improver);
        return 1;
    }

    if (improver->stats.sp == IMPROVE_ENCHANT) {
        weapon->magic++;
        weapon->last_eat++;
        draw_ext_info_format(NDI_UNIQUE, 0, op, MSG_TYPE_APPLY, MSG_TYPE_APPLY_SUCCESS,
            "Weapon magic increased to %d",
            "Weapon magic increased to %d",
            weapon->magic);
        decrease_ob(improver);
        weapon->item_power++;
        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) {
        draw_ext_info_format(NDI_UNIQUE, 0, op, MSG_TYPE_APPLY, MSG_TYPE_APPLY_ERROR,
            "You need at least %d %s",
            "You need at least %d %s",
            sacrifice_needed, improver->slaying);
        return 0;
    }
    eat_item(op, improver->slaying, sacrifice_needed);
    weapon->item_power++;

    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:
        draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_APPLY, MSG_TYPE_APPLY_ERROR,
            "Unknown improvement type.", NULL);
    }

    LOG(llevError, "improve_weapon: Got to end of function\n");
    return 0;
}

---