lightable.cpp

Go to the documentation of this file.

/*
 * Crossfire -- cooperative multi-player graphical RPG and adventure game
 *
 * Copyright (c) 1999-2021 The Crossfire Development Team
 * Copyright (c) 1992 Frank Tore Johansen
 *
 * Crossfire is free software and comes with ABSOLUTELY NO WARRANTY. You are
 * welcome to redistribute it under certain conditions. For details, please
 * see COPYING and LICENSE.
 *
 * The authors can be reached via e-mail at <crossfire@metalforge.org>.
 */
 
#include "global.h"
 
#include "ob_methods.h"
#include "sproto.h"
 
static method_ret lightable_type_apply(object *lightable, object *applier, int aflags);
 
void init_type_lightable(void) {
    register_apply(LIGHTABLE, lightable_type_apply);
}
 
static uint8_t is_better_lighter(object *current, object *old) {
    // If old_tool is not provided, then of course the new one is better.
    if (!old)
        return 1;
    // If the old tool is a weapon, just don't even argue
    if (old->type == WEAPON)
        return 0;
    // If the new tool is a weapon, and the old one is not, we will replace.
    if (current->type == WEAPON)
        return 1;
    // If the old tool is a clawing or flame touch skill, we do not beat it.
    // Only weapons have higher priority, and they have already been handled
    if (old->type == SKILL && (old->subtype == SK_CLAWING || old->subtype == SK_FLAME_TOUCH))
        return 0;
    // But, if the new tool is one of these, then we will replace.
    if (current->type == SKILL && (current->subtype == SK_CLAWING || old->subtype == SK_FLAME_TOUCH))
        return 1;
    // If old tool is a lighter and has higher or equal speed than a lighter as the new tool, then it is the better tool.
    if (old->type == LIGHTER && (current->type != LIGHTER || old->speed >= current->speed))
        return 0;
    // And if the new tool has those same criteria, then it is better.
    if (current->type == LIGHTER && (old->type != LIGHTER || current->speed > old->speed))
        return 1;
    // For spells, either take the lower mana cost between spells or supercede a skill or skill tool.
    if (old->type == SPELL && (current->type != SPELL || old->stats.sp + old->stats.grace <= current->stats.sp + current->stats.grace))
        return 0;
    if (current->type == SPELL && (old->type != SPELL || current->stats.sp + current->stats.grace < old->stats.sp + old->stats.grace))
        return 1;
    // And, if the old tool is a skill or skill tool, then it is one of the magic ones that uses 10 mana. As with new_tool.
    if (old->type == SKILL || old->type == SKILL_TOOL)
        return 0;
    // If we get here, something got messed up, so we want to ditch old_tool.
    return 2;
}
 
static method_ret lightable_type_apply(object *lightable, object *applier, int aflags){
    // We will find our lighter tool with this.
    // Note that we can use some things with fire attacktype that aren't lighters, because reasons.
    // wannabe_tool is used as a kind of temporary storage for tools that may become the selected tool, but might not as well.
    // unused_tool is a storage for when an item could be the tool of choice, but curses prevent something else from being unapplied.
    object *tool = NULL, *wannabe_tool = find_marked_object(applier), *unused_tool = NULL;
    int current_weapon_is_cursed = 0;
    // First, use the marked item if it is a lighter or has fire attacktype.
    if (wannabe_tool && ((wannabe_tool->attacktype & AT_FIRE) || wannabe_tool->type == LIGHTER)) {
        tool = wannabe_tool;
    }
    // Next, let us look at the current weapon of the applier. If it has a fire attacktype, use that.
    else if (applier->current_weapon && (applier->current_weapon->attacktype & AT_FIRE)) {
        tool = applier->current_weapon;
    }
    else {
        // We're done using wannabe_tool for the marked object. Clear it out.
        wannabe_tool = NULL;
        // Look for other ways to light the item.
        // Loop through the inventory for a lighter, the pyromancy skill, or a fire spell.
        FOR_INV_PREPARE(applier, tmp) {
            switch (tmp->type) {
                case LIGHTER:
                    // Skip over lighters that ran out of charges
                    if (tmp->stats.food > 0)
                        wannabe_tool = tmp;
                    break;
                case SKILL:
                case SKILL_TOOL:
                    // FIRE_MAGIC isn't used AFAIK, but account for it in case it ever is.
                    // Either way, we need 10 mana to use this directly.
                    if ((tmp->subtype == SK_PYROMANCY || tmp->subtype == SK_FIRE_MAGIC) && applier->stats.sp >= 10)
                        wannabe_tool = tmp;
                    // Clawing with fire attacktype and flame touch should also work.
                    if ((tmp->subtype == SK_CLAWING || tmp->subtype == SK_FLAME_TOUCH) && (tmp->attacktype & AT_FIRE))
                        wannabe_tool = tmp;
                    break;
                case WEAPON:
                    if (tmp->attacktype & AT_FIRE) {
                        // Make sure our wielded weapon is not cursed or damned.
                        // If it is, we can't set it down to use this one for a sec.
                        if (!applier->current_weapon || !(QUERY_FLAG(applier->current_weapon, FLAG_CURSED) || QUERY_FLAG(applier->current_weapon, FLAG_DAMNED))) {
                            wannabe_tool = tmp;
                        }
                        else {
                            // Note that the equipped weapon is cursed. We will print a message at the end.
                            current_weapon_is_cursed = 1;
                            unused_tool = tmp;
                        }
                    }
                    break;
                case SPELL:
                    // Don't choose a spell if it is too expensive to cast.
                    if (tmp->attacktype & AT_FIRE && tmp->stats.sp <= applier->stats.sp && tmp->stats.grace <= applier->stats.grace) {
                        wannabe_tool = tmp;
                    }
                    break;
            }
            // Determine the tool to use
            //
            // This prevents us from wasting mana or lighter charges if we have another option.
            if (wannabe_tool && is_better_lighter(wannabe_tool, tool)) {
                tool = wannabe_tool;
            }
            // Weapon has the shallowest cost, so if we found that, then use it.
            if (tool && tool->type == WEAPON)
                break;
        } FOR_INV_FINISH();
    }
    // All searching is done. Time to see what we got.
    if (tool) {
        if (applier->type == PLAYER && current_weapon_is_cursed) {
            // Print a message to players telling them they can't unequip current_weapon to wield something else.
            draw_ext_info_format(NDI_UNIQUE, 0, applier, MSG_TYPE_APPLY, MSG_TYPE_APPLY_FAILURE, "Could not use %s on %s because your %s is cursed!",
                unused_tool->name, lightable->name, applier->current_weapon->name);
        }
        // Actually attempt to thaw/light the lightable item.
        // If we are using a lighter, then go all the way through the lighter apply code.
        // This way we aren't having to rewrite any extra code here.
        if (tool->type == LIGHTER) {
            if (applier->type == PLAYER) {
                // Store the marked item for safekeeping, then make the lightable be our marked object.
                object *old_marked = find_marked_object(applier);
                // Don't do anything special if old_marked is the same as lightable.
                if (old_marked == lightable) {
                    // Just set to null so when we are done, we set the mark pointer to null.
                    old_marked = NULL;
                }
                else {
                    applier->contr->mark = lightable;
                    applier->contr->mark_count = lightable->count;
                }
                // Apply the lighter.
                apply_manual(applier, tool, aflags);
                // When done, return the marked object back to its original object.
                applier->contr->mark = old_marked;
                if (old_marked)
                    applier->contr->mark_count = old_marked->count;
                else
                    applier->contr->mark_count = 0;
                // Note we don't call do_light here -- it is called from the lighter apply
            }
            else {
                 // TODO: Implement directly, since monsters can't mark objects.
            }
        }
        else {
            do_light(lightable, tool->name, applier);
            // We already checked for available mana, so we should be able to just deduct mana outright here and remain above zero.
            if (tool->type == SPELL) {
                // Make sure we handle both magic and prayer costs.
                applier->stats.sp -= tool->stats.sp;
                applier->stats.grace -= tool->stats.grace;
            }
            else if (tool->type == SKILL || tool->type == SKILL_TOOL) {
                // Clawing and flame touch do not use mana
                if (tool->subtype == SK_PYROMANCY || tool->subtype == SK_FIRE_MAGIC)
                    applier->stats.sp -= 10;
            }
        }
    }
    else if (applier->type == PLAYER) {
        draw_ext_info_format(NDI_UNIQUE, 0, applier, MSG_TYPE_APPLY, MSG_TYPE_APPLY_FAILURE, "You have no source of heat to light %s.", lightable->name);
    }
 
    // We're done looking,
    return METHOD_OK;
}