/*      $NetBSD: pack.c,v 1.12 2011/05/23 23:01:17 joerg Exp $  */

/*
 * Copyright (c) 1988, 1993
 *      The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Timothy C. Stoehr.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/cdefs.h>
#ifndef lint
#if 0
static char sccsid[] = "@(#)pack.c      8.1 (Berkeley) 5/31/93";
#else
__RCSID("$NetBSD: pack.c,v 1.12 2011/05/23 23:01:17 joerg Exp $");
#endif
#endif /* not lint */

/*
 * pack.c
 *
 * This source herein may be modified and/or distributed by anybody who
 * so desires, with the following restrictions:
 *    1.)  No portion of this notice shall be removed.
 *    2.)  Credit shall not be taken for the creation of this source.
 *    3.)  This code is not to be traded, sold, or used for personal
 *         gain or profit.
 *
 */

#include "rogue.h"

const char curse_message[] = "you can't, it appears to be cursed";

static object *check_duplicate(object *, object *);
static boolean is_pack_letter(short *, unsigned short *);
static boolean mask_pack(const object *, unsigned short);
static short next_avail_ichar(void);

object *
add_to_pack(object *obj, object *pack, int condense)
{
        object *op;

        if (condense) {
                if ((op = check_duplicate(obj, pack)) != NULL) {
                        free_object(obj);
                        return(op);
                } else {
                        obj->ichar = next_avail_ichar();
                }
        }
        if (pack->next_object == 0) {
                pack->next_object = obj;
        } else {
                op = pack->next_object;

                while (op->next_object) {
                        op = op->next_object;
                }
                op->next_object = obj;
        }
        obj->next_object = 0;
        return(obj);
}

void
take_from_pack(object *obj, object *pack)
{
        while (pack->next_object != obj) {
                pack = pack->next_object;
        }
        pack->next_object = pack->next_object->next_object;
}

/* Note: *status is set to 0 if the rogue attempts to pick up a scroll
 * of scare-monster and it turns to dust.  *status is otherwise set to 1.
 */

object *
pick_up(int row, int col, short *status)
{
        object *obj;

        *status = 1;

        if (levitate) {
                messagef(0, "you're floating in the air!");
                return NULL;
        }
        obj = object_at(&level_objects, row, col);
        if (!obj) {
                messagef(1, "pick_up(): inconsistent");
                return(obj);
        }
        if (    (obj->what_is == SCROL) &&
                        (obj->which_kind == SCARE_MONSTER) &&
                        obj->picked_up) {
                messagef(0, "the scroll turns to dust as you pick it up");
                dungeon[row][col] &= (~OBJECT);
                vanish(obj, 0, &level_objects);
                *status = 0;
                if (id_scrolls[SCARE_MONSTER].id_status == UNIDENTIFIED) {
                        id_scrolls[SCARE_MONSTER].id_status = IDENTIFIED;
                }
                return NULL;
        }
        if (obj->what_is == GOLD) {
                rogue.gold += obj->quantity;
                dungeon[row][col] &= ~(OBJECT);
                take_from_pack(obj, &level_objects);
                print_stats(STAT_GOLD);
                return(obj);    /* obj will be free_object()ed in caller */
        }
        if (pack_count(obj) >= MAX_PACK_COUNT) {
                messagef(1, "pack too full");
                return NULL;
        }
        dungeon[row][col] &= ~(OBJECT);
        take_from_pack(obj, &level_objects);
        obj = add_to_pack(obj, &rogue.pack, 1);
        obj->picked_up = 1;
        return(obj);
}

void
drop(void)
{
        object *obj, *new;
        short ch;
        char desc[DCOLS];

        if (dungeon[rogue.row][rogue.col] & (OBJECT | STAIRS | TRAP)) {
                messagef(0, "there's already something there");
                return;
        }
        if (!rogue.pack.next_object) {
                messagef(0, "you have nothing to drop");
                return;
        }
        if ((ch = pack_letter("drop what?", ALL_OBJECTS)) == CANCEL) {
                return;
        }
        if (!(obj = get_letter_object(ch))) {
                messagef(0, "no such item.");
                return;
        }
        if (obj->in_use_flags & BEING_WIELDED) {
                if (obj->is_cursed) {
                        messagef(0, "%s", curse_message);
                        return;
                }
                unwield(rogue.weapon);
        } else if (obj->in_use_flags & BEING_WORN) {
                if (obj->is_cursed) {
                        messagef(0, "%s", curse_message);
                        return;
                }
                mv_aquatars();
                unwear(rogue.armor);
                print_stats(STAT_ARMOR);
        } else if (obj->in_use_flags & ON_EITHER_HAND) {
                if (obj->is_cursed) {
                        messagef(0, "%s", curse_message);
                        return;
                }
                un_put_on(obj);
        }
        obj->row = rogue.row;
        obj->col = rogue.col;

        if ((obj->quantity > 1) && (obj->what_is != WEAPON)) {
                obj->quantity--;
                new = alloc_object();
                *new = *obj;
                new->quantity = 1;
                obj = new;
        } else {
                obj->ichar = 'L';
                take_from_pack(obj, &rogue.pack);
        }
        place_at(obj, rogue.row, rogue.col);
        get_desc(obj, desc, sizeof(desc));
        messagef(0, "dropped %s", desc);
        (void)reg_move();
}

static object *
check_duplicate(object *obj, object *pack)
{
        object *op;

        if (!(obj->what_is & (WEAPON | FOOD | SCROL | POTION))) {
                return(0);
        }
        if ((obj->what_is == FOOD) && (obj->which_kind == FRUIT)) {
                return(0);
        }
        op = pack->next_object;

        while (op) {
                if ((op->what_is == obj->what_is) &&
                        (op->which_kind == obj->which_kind)) {

                        if ((obj->what_is != WEAPON) ||
                        ((obj->what_is == WEAPON) &&
                        ((obj->which_kind == ARROW) ||
                        (obj->which_kind == DAGGER) ||
                        (obj->which_kind == DART) ||
                        (obj->which_kind == SHURIKEN)) &&
                        (obj->quiver == op->quiver))) {
                                op->quantity += obj->quantity;
                                return(op);
                        }
                }
                op = op->next_object;
        }
        return(0);
}

static short
next_avail_ichar(void)
{
        object *obj;
        int i;
        boolean ichars[26];

        for (i = 0; i < 26; i++) {
                ichars[i] = 0;
        }
        obj = rogue.pack.next_object;
        while (obj) {
                if (obj->ichar >= 'a' && obj->ichar <= 'z') {
                        ichars[(obj->ichar - 'a')] = 1;
                }
                obj = obj->next_object;
        }
        for (i = 0; i < 26; i++) {
                if (!ichars[i]) {
                        return(i + 'a');
                }
        }
        return('?');
}

void
wait_for_ack(void)
{
        while (rgetchar() != ' ')
                ;
}

short
pack_letter(const char *prompt, unsigned short mask)
{
        short ch;
        unsigned short tmask = mask;

        if (!mask_pack(&rogue.pack, mask)) {
                messagef(0, "nothing appropriate");
                return(CANCEL);
        }
        for (;;) {

                messagef(0, "%s", prompt);

                for (;;) {
                        ch = rgetchar();
                        if (!is_pack_letter(&ch, &mask)) {
                                sound_bell();
                        } else {
                                break;
                        }
                }

                if (ch == LIST) {
                        check_message();
                        mask = tmask;
                        inventory(&rogue.pack, mask);
                } else {
                        break;
                }
                mask = tmask;
        }
        check_message();
        return(ch);
}

void
take_off(void)
{
        char desc[DCOLS];
        object *obj;

        if (rogue.armor) {
                if (rogue.armor->is_cursed) {
                        messagef(0, "%s", curse_message);
                } else {
                        mv_aquatars();
                        obj = rogue.armor;
                        unwear(rogue.armor);
                        get_desc(obj, desc, sizeof(desc));
                        messagef(0, "was wearing %s", desc);
                        print_stats(STAT_ARMOR);
                        (void)reg_move();
                }
        } else {
                messagef(0, "not wearing any");
        }
}

void
wear(void)
{
        short ch;
        object *obj;
        char desc[DCOLS];

        if (rogue.armor) {
                messagef(0, "you're already wearing some");
                return;
        }
        ch = pack_letter("wear what?", ARMOR);

        if (ch == CANCEL) {
                return;
        }
        if (!(obj = get_letter_object(ch))) {
                messagef(0, "no such item.");
                return;
        }
        if (obj->what_is != ARMOR) {
                messagef(0, "you can't wear that");
                return;
        }
        obj->identified = 1;
        get_desc(obj, desc, sizeof(desc));
        messagef(0, "wearing %s", desc);
        do_wear(obj);
        print_stats(STAT_ARMOR);
        (void)reg_move();
}

void
unwear(object *obj)
{
        if (obj) {
                obj->in_use_flags &= (~BEING_WORN);
        }
        rogue.armor = NULL;
}

void
do_wear(object *obj)
{
        rogue.armor = obj;
        obj->in_use_flags |= BEING_WORN;
        obj->identified = 1;
}

void
wield(void)
{
        short ch;
        object *obj;
        char desc[DCOLS];

        if (rogue.weapon && rogue.weapon->is_cursed) {
                messagef(0, "%s", curse_message);
                return;
        }
        ch = pack_letter("wield what?", WEAPON);

        if (ch == CANCEL) {
                return;
        }
        if (!(obj = get_letter_object(ch))) {
                messagef(0, "No such item.");
                return;
        }
        if (obj->what_is & (ARMOR | RING)) {
                messagef(0, "you can't wield %s",
                        ((obj->what_is == ARMOR) ? "armor" : "rings"));
                return;
        }
        if (obj->in_use_flags & BEING_WIELDED) {
                messagef(0, "in use");
        } else {
                unwield(rogue.weapon);
                get_desc(obj, desc, sizeof(desc));
                messagef(0, "wielding %s", desc);
                do_wield(obj);
                (void)reg_move();
        }
}

void
do_wield(object *obj)
{
        rogue.weapon = obj;
        obj->in_use_flags |= BEING_WIELDED;
}

void
unwield(object *obj)
{
        if (obj) {
                obj->in_use_flags &= (~BEING_WIELDED);
        }
        rogue.weapon = NULL;
}

void
call_it(void)
{
        short ch;
        object *obj;
        struct id *id_table;
        char buf[MAX_TITLE_LENGTH+2];

        ch = pack_letter("call what?", (SCROL | POTION | WAND | RING));

        if (ch == CANCEL) {
                return;
        }
        if (!(obj = get_letter_object(ch))) {
                messagef(0, "no such item.");
                return;
        }
        if (!(obj->what_is & (SCROL | POTION | WAND | RING))) {
                messagef(0, "surely you already know what that's called");
                return;
        }
        id_table = get_id_table(obj);

        if (get_input_line("call it:", "", buf, sizeof(buf),
                        id_table[obj->which_kind].title, 1, 1)) {
                id_table[obj->which_kind].id_status = CALLED;
                (void)strlcpy(id_table[obj->which_kind].title, buf,
                                sizeof(id_table[obj->which_kind].title));
        }
}

short
pack_count(const object *new_obj)
{
        object *obj;
        short count = 0;

        obj = rogue.pack.next_object;

        while (obj) {
                if (obj->what_is != WEAPON) {
                        count += obj->quantity;
                } else if (!new_obj) {
                        count++;
                } else if ((new_obj->what_is != WEAPON) ||
                        ((obj->which_kind != ARROW) &&
                        (obj->which_kind != DAGGER) &&
                        (obj->which_kind != DART) &&
                        (obj->which_kind != SHURIKEN)) ||
                        (new_obj->which_kind != obj->which_kind) ||
                        (obj->quiver != new_obj->quiver)) {
                        count++;
                }
                obj = obj->next_object;
        }
        return(count);
}

static boolean
mask_pack(const object *pack, unsigned short mask)
{
        while (pack->next_object) {
                pack = pack->next_object;
                if (pack->what_is & mask) {
                        return(1);
                }
        }
        return(0);
}

static boolean
is_pack_letter(short *c, unsigned short *mask)
{
        if (((*c == '?') || (*c == '!') || (*c == ':') || (*c == '=') ||
                (*c == ')') || (*c == ']') || (*c == '/') || (*c == ','))) {
                switch(*c) {
                case '?':
                        *mask = SCROL;
                        break;
                case '!':
                        *mask = POTION;
                        break;
                case ':':
                        *mask = FOOD;
                        break;
                case ')':
                        *mask = WEAPON;
                        break;
                case ']':
                        *mask = ARMOR;
                        break;
                case '/':
                        *mask = WAND;
                        break;
                case '=':
                        *mask = RING;
                        break;
                case ',':
                        *mask = AMULET;
                        break;
                }
                *c = LIST;
                return(1);
        }
        return(((*c >= 'a') && (*c <= 'z')) || (*c == CANCEL) || (*c == LIST));
}

boolean
has_amulet(void)
{
        return(mask_pack(&rogue.pack, AMULET));
}

void
kick_into_pack(void)
{
        object *obj;
        char desc[DCOLS];
        short stat;

        if (!(dungeon[rogue.row][rogue.col] & OBJECT)) {
                messagef(0, "nothing here");
        } else {
                if ((obj = pick_up(rogue.row, rogue.col, &stat)) != NULL) {
                        get_desc(obj, desc, sizeof(desc));
                        if (obj->what_is == GOLD) {
                                messagef(0, "%s", desc);
                                free_object(obj);
                        } else {
                                messagef(0, "%s(%c)", desc, obj->ichar);
                        }
                }
                if (obj || (!stat)) {
                        (void)reg_move();
                }
        }
}