button.c

Go to the documentation of this file.

/*
 * Crossfire -- cooperative multi-player graphical RPG and adventure game
 *
 * Copyright (c) 1999-2014 Mark Wedel and 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 <stdlib.h>
#include <string.h>
 
#include "sproto.h"
 
static objectlink *get_button_links(const object *button);
 
void trigger_connected(objectlink *ol, object *cause, const int state) {
    object *tmp;
 
    for (; ol; ol = ol->next) {
        object *part;
 
        if (!ol->ob || ol->ob->count != ol->id) {
            LOG(llevError, "Internal error in trigger_connect. No object associated with link id (%u) (cause='%s'.\n", ol->id, (cause && cause->name) ? cause->name : "");
            continue;
        }
        /* a button link object can become freed when the map is saving.  As
         * a map is saved, objects are removed and freed, and if an object is
         * on top of a button, this function is eventually called.  If a map
         * is getting moved out of memory, the status of buttons and levers
         * probably isn't important - it will get sorted out when the map is
         * re-loaded.  As such, just exit this function if that is the case.
         */
 
        if (QUERY_FLAG(ol->ob, FLAG_FREED))
            return;
        tmp = ol->ob;
 
        /* if the criteria isn't appropriate, don't do anything */
        if (state && !QUERY_FLAG(tmp, FLAG_ACTIVATE_ON_PUSH))
            continue;
        if (!state && !QUERY_FLAG(tmp, FLAG_ACTIVATE_ON_RELEASE))
            continue;
 
        if (events_execute_object_event(tmp, EVENT_TRIGGER, cause, NULL, NULL, SCRIPT_FIX_ALL) != 0)
            continue;
 
        switch (tmp->type) {
        case GATE:
        case HOLE:
            tmp->value = tmp->stats.maxsp ? !state : state;
            tmp->speed = 0.5;
            object_update_speed(tmp);
            break;
 
        case CF_HANDLE:
            SET_ANIMATION(tmp, (tmp->value = tmp->stats.maxsp ? !state : state));
            object_update(tmp, UP_OBJ_FACE);
            break;
 
        case SIGN:
            if (!tmp->stats.food || tmp->last_eat < tmp->stats.food) {
                ext_info_map(NDI_UNIQUE|NDI_NAVY, tmp->map,
                    MSG_TYPE_SIGN, MSG_SUBTYPE_NONE,
                    tmp->msg);
                if (tmp->stats.food)
                    tmp->last_eat++;
            }
            break;
 
        case ALTAR:
            tmp->value = 1;
            SET_ANIMATION(tmp, tmp->value);
            object_update(tmp, UP_OBJ_FACE);
            break;
 
        case BUTTON:
        case PEDESTAL:
            tmp->value = state;
            SET_ANIMATION(tmp, tmp->value);
            object_update(tmp, UP_OBJ_FACE);
            break;
 
        case TIMED_GATE:
            for (part = tmp; tmp != NULL; tmp = tmp->more) {
                part->speed = tmp->arch->clone.speed;
                part->value = tmp->arch->clone.value;
                part->stats.sp = 1;
                part->stats.hp = tmp->stats.maxhp;
                object_update_speed(part);
            }
            break;
 
        case DIRECTOR:
            if ((tmp->stats.sp += tmp->stats.maxsp) > 8) /* next direction */
                tmp->stats.sp = ((tmp->stats.sp-1)%8)+1;
            animate_turning(tmp);
            break;
        case FIREWALL:
            // Since director is broken out, we don't need to check on firewall type now
            if (!QUERY_FLAG(tmp, FLAG_ANIMATE)/* && tmp->type == FIREWALL*/)
                move_firewall(tmp);
            else {
                if ((tmp->direction += tmp->stats.maxsp) > 8) /* next direction */
                    tmp->direction = ((tmp->direction-1)%8)+1;
                animate_turning(tmp);
            }
            break;
 
 
        default:
            ob_trigger(tmp, cause, state);
        }
    }
}
 
void push_button(object *op) {
    /* LOG(llevDebug, "push_button: %s (%d)\n", op->name, op->count); */
    trigger_connected(get_button_links(op), op, op->value);
}
 
void update_button(object *op) {
    object *tmp, *head;
    int tot, any_down = 0, old_value = op->value;
    objectlink *ol;
 
    /* LOG(llevDebug, "update_button: %s (%d)\n", op->name, op->count); */
    for (ol = get_button_links(op); ol; ol = ol->next) {
        if (!ol->ob || ol->ob->count != ol->id) {
            LOG(llevDebug, "Internal error in update_button (%s).\n", op->name);
            continue;
        }
 
        tmp = ol->ob;
        if (tmp->type == BUTTON) {
            tot = 0;
            FOR_ABOVE_PREPARE(tmp, ab)
                /* Bug? The pedestal code below looks for the head of
                 * the object, this bit doesn't.  I'd think we should check
                 * for head here also.  Maybe it also makese sense to
                 * make the for ab=tmp->above loop common, and alter
                 * behaviour based on object within that loop?
                 */
 
                /* Basically, if the move_type matches that on what the
                 * button wants, we count it.  The second check is so that
                 * objects don't move (swords, etc) will count.  Note that
                 * this means that more work is needed to make buttons
                 * that are only triggered by flying objects.
                 */
                if ((ab->move_type&tmp->move_on) || ab->move_type == 0)
                    tot += ab->weight*NROF(ab)+ab->carrying;
            FOR_ABOVE_FINISH();
 
            tmp->value = (tot >= tmp->weight) ? 1 : 0;
            if (tmp->value)
                any_down = 1;
        } else if (tmp->type == PEDESTAL) {
            tmp->value = 0;
            FOR_ABOVE_PREPARE(tmp, ab) {
                head = ab->head ? ab->head : ab;
                /* Same note regarding move_type for buttons above apply here. */
                if (((head->move_type&tmp->move_on) || ab->move_type == 0)
                && (head->race == tmp->slaying
                    || ((head->type == SPECIAL_KEY) && (head->slaying == tmp->slaying))
                    || (!strcmp(tmp->slaying, "player") && head->type == PLAYER)))
                    tmp->value = 1;
            } FOR_ABOVE_FINISH();
            if (tmp->value)
                any_down = 1;
        }
    }
    if (any_down) /* If any other buttons were down, force this to remain down */
        op->value = 1;
 
    /* If this button hasn't changed, don't do anything */
    if (op->value != old_value) {
        SET_ANIMATION(op, op->value);
        object_update(op, UP_OBJ_FACE);
        push_button(op); /* Make all other buttons the same */
    }
}
 
void update_buttons(mapstruct *m) {
    objectlink *ol;
    oblinkpt *obp;
 
    for (obp = m->buttons; obp; obp = obp->next)
        for (ol = obp->link; ol; ol = ol->next) {
            if (!ol->ob || ol->ob->count != ol->id) {
                LOG(llevError, "Internal error in update_button (%s (%dx%d):%u, connected %ld).\n",
                    ol->ob ? ol->ob->name : "null",
                    ol->ob ? ol->ob->x : -1,
                    ol->ob ? ol->ob->y : -1,
                    ol->id,
                    obp->value);
                continue;
            }
            if (ol->ob->type == BUTTON || ol->ob->type == PEDESTAL) {
                update_button(ol->ob);
                break;
            }
        }
}
 
void use_trigger(object *op) {
    /* Toggle value */
    op->value = !op->value;
    push_button(op);
}
 
void animate_turning(object *op) {
    if (++op->state >= NUM_ANIMATIONS(op)/8)
        op->state = 0;
    // Firewalls use direction instead of sp to avoid issues involving the spell transference.
    if (op->type == FIREWALL){
        SET_ANIMATION(op, (op->direction-1)*NUM_ANIMATIONS(op)/8+op->state);
    }
    else {
        SET_ANIMATION(op, (op->stats.sp-1)*NUM_ANIMATIONS(op)/8+op->state);
    }
    object_update(op, UP_OBJ_FACE);
}
 
#define ARCH_SACRIFICE(xyz) ((xyz)->slaying)
#define NROF_SACRIFICE(xyz) ((uint32_t)(xyz)->stats.food)
 
static int matches_sacrifice(const object *altar, const object *sacrifice) {
    char name[MAX_BUF];
 
    if ((QUERY_FLAG(sacrifice, FLAG_ALIVE) && object_value_set(altar, "accept_alive") == false)
    || QUERY_FLAG(sacrifice, FLAG_IS_LINKED)
    || sacrifice->type == PLAYER)
        return 0;
 
    query_base_name(sacrifice, 0, name, MAX_BUF);
    if (ARCH_SACRIFICE(altar) == sacrifice->arch->name
    || ARCH_SACRIFICE(altar) == sacrifice->name
    || ARCH_SACRIFICE(altar) == sacrifice->slaying
    || (!strcmp(ARCH_SACRIFICE(altar), name)))
        return 1;
 
    if (strcmp(ARCH_SACRIFICE(altar), "money") == 0
    && sacrifice->type == MONEY)
        return 1;
 
    return 0;
}
 
int check_altar_sacrifice(const object *altar, const object *sacrifice, int remove_others, int *toremove) {
    int money;
    uint32_t wanted, rest;
 
    if (!matches_sacrifice(altar, sacrifice))
        /* New dropped object doesn't match the altar, other objects already on top are not enough to
         * activate altar, else they would have disappeared. */
        return 0;
 
    /* Check item is paid for. */
    if (QUERY_FLAG(sacrifice, FLAG_UNPAID)) {
        return 0;
    }
 
    money = (strcmp(ARCH_SACRIFICE(altar), "money") == 0) ? 1 : 0;
 
    /* Easy checks: newly dropped object is enough for sacrifice. */
    if (money && sacrifice->nrof*sacrifice->value >= NROF_SACRIFICE(altar)) {
        if (toremove) {
            *toremove = NROF_SACRIFICE(altar)/sacrifice->value;
            /* Round up any sacrifices.  Altars don't make change either */
            if (NROF_SACRIFICE(altar)%sacrifice->value)
                (*toremove)++;
        }
        return 1;
    }
 
    if (!money && NROF_SACRIFICE(altar) <= NROF(sacrifice)) {
        if (toremove)
            *toremove = NROF_SACRIFICE(altar);
        return 1;
    }
 
    if (money) {
        wanted = NROF_SACRIFICE(altar)-sacrifice->nrof*sacrifice->value;
    } else {
        wanted = NROF_SACRIFICE(altar)-NROF(sacrifice);
    }
    rest = wanted;
 
    /* Ok, now we check if we got enough with other items.
     * We only check items above altar, and not checking again sacrifice.
     */
    FOR_ABOVE_PREPARE(altar, tmp) {
        if (wanted <= 0)
            break;
        if (tmp == sacrifice || !matches_sacrifice(altar, tmp))
            continue;
        if (money)
            wanted -= tmp->nrof*tmp->value;
        else
            wanted -= NROF(tmp);
    } FOR_ABOVE_FINISH();
 
    if (wanted > 0)
        /* Not enough value, let's bail out. */
        return 0;
 
    /* From there on, we do have enough objects for the altar. */
 
    /* Last dropped object will be totally eaten in any case. */
    if (toremove)
        *toremove = NROF(sacrifice);
 
    if (!remove_others)
        return 1;
 
    /* We loop again, this time to remove what we need. */
    FOR_ABOVE_PREPARE(altar, tmp) {
        if (rest <= 0)
            break;
        if (tmp == sacrifice || !matches_sacrifice(altar, tmp))
            continue;
        if (money) {
            wanted = tmp->nrof*tmp->value;
            if (rest > wanted) {
                object_remove(tmp);
                rest -= wanted;
            } else {
                wanted = rest/tmp->value;
                if (rest%tmp->value)
                    wanted++;
                object_decrease_nrof(tmp, wanted);
                return 1;
            }
        } else
            if (rest > NROF(tmp)) {
                rest -= NROF(tmp);
                object_remove(tmp);
            } else {
                object_decrease_nrof(tmp, rest);
                return 1;
            }
    } FOR_ABOVE_FINISH();
 
    /* Something went wrong, we'll be nice and accept the sacrifice anyway. */
    LOG(llevError, "check_altar_sacrifice on %s: found objects to sacrifice, but couldn't remove them??\n", altar->map->path);
    return 1;
}
 
int operate_altar(object *altar, object **sacrifice) {
    int number;
 
    if (!altar->map) {
        LOG(llevError, "BUG: operate_altar(): altar has no map\n");
        return 0;
    }
 
    if (!altar->slaying || altar->value)
        return 0;
 
    if (!check_altar_sacrifice(altar, *sacrifice, 1, &number))
        return 0;
 
    /* check_altar_sacrifice fills in number for us. */
    *sacrifice = object_decrease_nrof(*sacrifice, number);
 
    if (altar->msg)
        ext_info_map(NDI_BLACK, altar->map, MSG_TYPE_DIALOG, MSG_TYPE_DIALOG_ALTAR, altar->msg);
    return 1;
}
 
static void trigger_move(object *op, int state) { /* 1 down and 0 up */
    op->stats.wc = state;
    if (state) {
        use_trigger(op);
        if (op->stats.exp > 0) /* check sanity  */
            op->speed = 1.0/op->stats.exp;
        else
            op->speed = 1.0;
        object_update_speed(op);
        op->speed_left = -1;
    } else {
        use_trigger(op);
        op->speed = 0;
        object_update_speed(op);
    }
}
 
int check_trigger(object *op, object *cause) {
    int push = 0, tot = 0;
    int in_movement = op->stats.wc || op->speed;
 
    switch (op->type) {
    case TRIGGER_BUTTON:
        if (op->weight > 0) {
            if (cause) {
                FOR_ABOVE_PREPARE(op, tmp)
                    /* Comment reproduced from update_buttons():
                     * Basically, if the move_type matches that on what the
                     * button wants, we count it.  The second check is so that
                     * objects that don't move (swords, etc) will count.  Note that
                     * this means that more work is needed to make buttons
                     * that are only triggered by flying objects.
                     */
                    if ((tmp->move_type&op->move_on) || tmp->move_type == 0) {
                        tot += tmp->weight*NROF(tmp)+tmp->carrying;
                    }
                FOR_ABOVE_FINISH();
                if (tot >= op->weight)
                    push = 1;
                if (op->stats.ac == push)
                    return 0;
                op->stats.ac = push;
                if (NUM_ANIMATIONS(op) > 1) {
                    SET_ANIMATION(op, push);
                    object_update(op, UP_OBJ_FACE);
                }
                if (in_movement || !push)
                    return 0;
            }
            trigger_move(op, push);
        }
        return 0;
 
    case TRIGGER_PEDESTAL:
        if (cause) {
            FOR_ABOVE_PREPARE(op, tmp) {
                object *head = tmp->head ? tmp->head : tmp;
 
                /* See comment in TRIGGER_BUTTON about move_types */
                if (((head->move_type&op->move_on) || head->move_type == 0)
                && (head->race == op->slaying || (!strcmp(op->slaying, "player") && head->type == PLAYER))) {
                    push = 1;
                    break;
                }
            } FOR_ABOVE_FINISH();
            if (op->stats.ac == push)
                return 0;
            op->stats.ac = push;
            if (NUM_ANIMATIONS(op) > 1) {
                SET_ANIMATION(op, push);
                object_update(op, UP_OBJ_FACE);
            }
            if (in_movement || !push)
                return 0;
        }
        trigger_move(op, push);
        return 0;
 
    case TRIGGER_ALTAR:
        if (cause) {
            if (in_movement)
                return 0;
            if (operate_altar(op, &cause)) {
                if (NUM_ANIMATIONS(op) > 1) {
                    SET_ANIMATION(op, 1);
                    object_update(op, UP_OBJ_FACE);
                }
 
                if (op->last_sp >= 0) {
                    trigger_move(op, 1);
                    if (op->last_sp > 0)
                        op->last_sp = -op->last_sp;
                    } else {
                    /* for trigger altar with last_sp, the ON/OFF
                     * status (-> +/- value) is "simulated":
                     */
                    op->value = !op->value;
                    trigger_move(op, 1);
                    op->last_sp = -op->last_sp;
                        op->value = !op->value;
                }
                return cause == NULL;
            } else {
                return 0;
            }
        } else {
            if (NUM_ANIMATIONS(op) > 1) {
                SET_ANIMATION(op, 0);
                object_update(op, UP_OBJ_FACE);
            }
 
            /* If trigger_altar has "last_sp > 0" set on the map,
             * it will push the connected value only once per sacrifice.
             * Otherwise (default), the connected value will be
             * pushed twice: First by sacrifice, second by reset! -AV
             */
            if (!op->last_sp)
                trigger_move(op, 0);
            else {
                op->stats.wc = 0;
                op->value = !op->value;
                op->speed = 0;
                object_update_speed(op);
            }
        }
        return 0;
 
    case TRIGGER:
        if (cause) {
            if (in_movement)
                return 0;
            push = 1;
        }
        if (NUM_ANIMATIONS(op) > 1) {
            SET_ANIMATION(op, push);
            object_update(op, UP_OBJ_FACE);
        }
        trigger_move(op, push);
        return 1;
 
    default:
        LOG(llevDebug, "Unknown trigger type: %s (%d)\n", op->name, op->type);
        return 0;
    }
}
 
void add_button_link(object *button, mapstruct *map, int connected) {
    oblinkpt *obp;
    objectlink *ol = get_objectlink();
 
    if (!map) {
        LOG(llevError, "Tried to add button-link without map.\n");
        free_objectlink(ol);
        return;
    }
 
    SET_FLAG(button, FLAG_IS_LINKED);
 
    ol->ob = button;
    ol->id = button->count;
 
    for (obp = map->buttons; obp && obp->value != connected; obp = obp->next)
        ;
 
    if (obp) {
        ol->next = obp->link;
        obp->link = ol;
    } else {
        obp = get_objectlinkpt();
        obp->value = connected;
 
        obp->next = map->buttons;
        map->buttons = obp;
        obp->link = ol;
    }
}
 
void remove_button_link(object *op) {
    oblinkpt *obp;
    objectlink **olp, *ol;
 
    if (op->map == NULL) {
        LOG(llevError, "remove_button_link() in object without map.\n");
        return;
    }
    if (!QUERY_FLAG(op, FLAG_IS_LINKED)) {
        LOG(llevError, "remove_button_linked() in unlinked object.\n");
        return;
    }
 
    for (obp = op->map->buttons; obp; obp = obp->next)
        for (olp = &obp->link; (ol = *olp); olp = &ol->next)
            if (ol->ob == op) {
/*              LOG(llevDebug, "Removed link %d in button %s and map %s.\n",
                    obp->value, op->name, op->map->path);
*/
                *olp = ol->next;
                free(ol);
                return;
            }
    LOG(llevError, "remove_button_linked(): couldn't find object.\n");
    CLEAR_FLAG(op, FLAG_IS_LINKED);
}
 
static objectlink *get_button_links(const object *button) {
    oblinkpt *obp;
    objectlink *ol;
 
    if (!button->map)
        return NULL;
 
    for (obp = button->map->buttons; obp; obp = obp->next)
        for (ol = obp->link; ol; ol = ol->next)
            if (ol->ob == button && ol->id == button->count)
                return obp->link;
    return NULL;
}
 
int get_button_value(const object *button) {
    oblinkpt *obp;
    objectlink *ol;
 
    if (!button->map)
        return 0;
 
    for (obp = button->map->buttons; obp; obp = obp->next)
        for (ol = obp->link; ol; ol = ol->next)
            if (ol->ob == button && ol->id == button->count)
                return obp->value;
    return 0;
}
 
object *check_inv_recursive(object *op, const object *trig) {
    object *ret = NULL;
 
    /* First check the object itself. */
    if ((!trig->stats.hp || (op->type == trig->stats.hp))
    && (!trig->slaying || (op->slaying == trig->slaying))
    && (!trig->race || (op->arch->name == trig->race))
    && (!trig->title || (op->title == trig->title))
    && (QUERY_FLAG(op, FLAG_UNPAID) == QUERY_FLAG(trig, FLAG_UNPAID)))
        return op;
 
    FOR_INV_PREPARE(op, tmp) {
        if (tmp->inv) {
            ret = check_inv_recursive(tmp, trig);
            if (ret)
                return ret;
        } else if ((!trig->stats.hp || (tmp->type == trig->stats.hp))
        && (!trig->slaying || (tmp->slaying == trig->slaying))
        && (!trig->race || (tmp->arch->name == trig->race))
        && (!trig->title || (tmp->title == trig->title))
        && (QUERY_FLAG(tmp, FLAG_UNPAID) == QUERY_FLAG(trig, FLAG_UNPAID)))
            return tmp;
    } FOR_INV_FINISH();
 
    return NULL;
}
 
 
void check_inv(object *op, object *trig) {
    object *match;
 
    if (op->type != PLAYER)
        return;
 
    match = check_inv_recursive(op, trig);
    if (match && trig->last_sp) {
        if (trig->last_heal)
            object_decrease_nrof_by_one(match);
        use_trigger(trig);
    } else if (!match && !trig->last_sp)
        use_trigger(trig);
}