item.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * 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 3 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, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef XEEN_ITEM_H
#define XEEN_ITEM_H

#include "common/scummsys.h"
#include "common/array.h"
#include "common/rect.h"
#include "common/serializer.h"
#include "xeen/sprites.h"

namespace Xeen {

#define INV_ITEMS_TOTAL 9

class XeenEngine;
class Character;

enum ItemCategory {
    CATEGORY_WEAPON = 0, CATEGORY_ARMOR = 1, CATEGORY_ACCESSORY = 2, CATEGORY_MISC = 3,
    NUM_ITEM_CATEGORIES = 4
};

enum AttributeCategory {
    ATTR_MIGHT = 0, ATTR_INTELLECT = 1, ATTR_PERSONALITY = 2, ATTR_SPEED = 3,
    ATTR_ACCURACY = 4, ATTR_LUCK = 5, ATTR_HIT_POINTS = 6, ATTR_SPELL_POINTS = 7,
    ATTR_ARMOR_CLASS = 8, ATTR_THIEVERY = 9
};

enum ElementalCategory {
    ELEM_FIRE = 0, ELEM_ELECTRICITY = 1, ELEM_COLD = 2, ELEM_ACID_POISON = 3,
    ELEM_ENERGY = 4, ELEM_MAGIC = 5
};

enum WeaponId {
    XEEN_SLAYER_SWORD = 34
};

enum Effectiveness {
    EFFECTIVE_NONE = 0, EFFECTIVE_DRAGON = 1, EFFECTIVE_UNDEAD = 2, EFFECTIVE_GOLEM = 3,
    EFFECTIVE_INSECT = 4, EFFEctIVE_MONSTERS = 5, EFFECTIVE_ANIMAL = 6
};

struct ItemState {
    byte _counter : 6;      // Stores charges for Misc items, and the effective against for weapons
    bool _cursed : 1;
    bool _broken : 1;

    ItemState() : _counter(0), _cursed(false), _broken(false) {}

    void clear() {
        _counter = 0;
        _cursed = _broken = false;
    }

    bool empty() const { return !_counter && !_cursed && !_broken; }

    void synchronize(Common::Serializer &s);

    void operator=(byte val);
};

class XeenItem {
public:
    int _material;
    uint _id;
    ItemState _state;
    int _frame;
public:
    static const char *getItemName(ItemCategory category, uint id);
public:
    XeenItem();

    void clear();

    bool empty() const { return _id == 0; }

    bool isBad() const { return _state._cursed || _state._broken; }

    bool isEquipped() const { return _frame != 0; }

    void synchronize(Common::Serializer &s);

    ElementalCategory getElementalCategory() const;

    static ElementalCategory getElementalCategory(int material);

    AttributeCategory getAttributeCategory() const;
};

class InventoryItems : public Common::Array<XeenItem> {
protected:
    Character *_character;
    ItemCategory _category;
    const char **_names;

    XeenEngine *getVm();
    void equipError(int itemIndex1, ItemCategory category1, int itemIndex2,
        ItemCategory category2);

    virtual Common::String getAttributes(XeenItem &item, const Common::String &classes) = 0;

    void capitalizeItem(Common::String &name);

    const char *getMaeName(int material);

public:
    InventoryItems(Character *character, ItemCategory category);
    virtual ~InventoryItems() {}

    void clear();

    InventoryItems &operator=(const InventoryItems &src);

    bool passRestrictions(int itemId, bool suppressError = false) const;

    Common::String getName(int itemIndex);

    virtual Common::String getFullDescription(int itemIndex, int displayNum = 15) = 0;

    Common::String getIdentifiedDetails(int itemIndex);

    bool discardItem(int itemIndex);

    virtual void equipItem(int itemIndex) {}

    void removeItem(int itemIndex);

    void sort();

    virtual void enchantItem(int itemIndex, int amount);

    bool isFull() const;
};

class WeaponItems: public InventoryItems {
protected:
    Common::String getAttributes(XeenItem &item, const Common::String &classes) override;
public:
    WeaponItems(Character *character) : InventoryItems(character, CATEGORY_WEAPON) {}
    ~WeaponItems() override {}

    void equipItem(int itemIndex) override;

    Common::String getFullDescription(int itemIndex, int displayNum) override;

    void enchantItem(int itemIndex, int amount) override;

    bool hasElderWeapon() const;
};

class ArmorItems : public InventoryItems {
protected:
    Common::String getAttributes(XeenItem &item, const Common::String &classes) override;
public:
    ArmorItems(Character *character) : InventoryItems(character, CATEGORY_ARMOR) {}
    ~ArmorItems() override {}

    void equipItem(int itemIndex) override;

    Common::String getFullDescription(int itemIndex, int displayNum) override;

    void enchantItem(int itemIndex, int amount) override;
};

class AccessoryItems : public InventoryItems {
protected:
    Common::String getAttributes(XeenItem &item, const Common::String &classes) override;
public:
    AccessoryItems(Character *character) : InventoryItems(character, CATEGORY_ACCESSORY) {}

    void equipItem(int itemIndex) override;

    Common::String getFullDescription(int itemIndex, int displayNum) override;
};

class MiscItems : public InventoryItems {
protected:
    Common::String getAttributes(XeenItem &item, const Common::String &classes) override;
public:
    MiscItems(Character *character) : InventoryItems(character, CATEGORY_MISC) {}
    ~MiscItems() override {}

    Common::String getFullDescription(int itemIndex, int displayNum) override;
};

class InventoryItemsGroup {
private:
    Character *_owner;
public:
    InventoryItemsGroup(Character *owner) : _owner(owner) {}

    InventoryItems &operator[](ItemCategory category);

    const InventoryItems &operator[](ItemCategory category) const;

    void breakAllItems();

    void curseUncurse(bool curse);

    bool hasCursedItems() const;
};

} // End of namespace Xeen

#endif /* XEEN_CHARACTER_H */