Initial commit

engines/ultima/shared/core/character.h

@@ -0,0 +1,231 @@
+/* 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 ULTIMA_SHARED_CORE_CHARACTER_H
+#define ULTIMA_SHARED_CORE_CHARACTER_H
+
+#include "common/array.h"
+#include "common/str.h"
+#include "common/serializer.h"
+#include "ultima/shared/core/named_item.h"
+
+namespace Ultima {
+namespace Shared {
+
+enum Sex { SEX_MALE = 0, SEX_FEMALE = 1, SEX_OTHER = 2, SEX_YES_PLEASE = 2 };
+
+/**
+ * Base class for class types that have a quantity
+ */
+class Itemized {
+public:
+	uint _quantity;
+public:
+	/**
+	 * Constructor
+	 */
+	Itemized() : _quantity(0) {}
+
+	/**
+	 * Destructor
+	 */
+	virtual ~Itemized() {}
+
+	/**
+	 * Synchronize data
+	 */
+	void synchronize(Common::Serializer &s) {
+		s.syncAsUint16LE(_quantity);
+	}
+
+	/**
+	 * Change the quantity by a given amount
+	 */
+	virtual void changeQuantity(int delta) {
+		_quantity = (uint)CLIP((int)_quantity + delta, 0, 9999);
+	}
+
+	/**
+	 * Increase the quantity by 1
+	 */
+	void incrQuantity() { changeQuantity(1); }
+
+	/**
+	 * Returns if the itemized is empty
+	 */
+	bool empty() const { return _quantity == 0; }
+
+	/**
+	 * Decrease the quantity by 1
+	 */
+	bool decrQuantity() {
+		changeQuantity(-1);
+		return empty();
+	}
+};
+
+/**
+ * Weapon entry
+ */
+class Weapon : public Itemized {
+public:
+	Common::String _shortName, _longName;
+	uint _distance;
+public:
+	/**
+	 * Constructor
+	 */
+	Weapon() : Itemized(), _distance(0) {}
+};
+
+/**
+ * Armour entry
+ */
+class Armour : public Itemized {
+public:
+	Common::String _name;
+};
+
+/**
+ * Spell entry
+ */
+class Spell : public Itemized, public NamedItem {
+};
+
+template<class T>
+class ItemArray : public Common::Array<T> {
+public:
+	/**
+	 * Returns the number of distinct types of items in the array, not counting
+	 * the slot 0 "nothing" slot
+	 */
+	size_t itemsCount() const {
+		uint total = 0;
+		for (uint idx = 1; idx < this->size(); ++idx) {
+			if (!(*this)[idx]->empty())
+				++total;
+		}
+
+		return total;
+	}
+
+	/**
+	 * Returns true if the character has no items
+	 */
+	bool hasNothing() const {
+		return itemsCount() == 0;
+	}
+};
+
+/**
+ * Implements the data for a playable character within the game
+ */
+class Character {
+public:
+	Common::String _name;
+	uint _race;
+	Sex _sex;
+	uint _class;
+
+	uint _strength;
+	uint _agility;
+	uint _stamina;
+	uint _charisma;
+	uint _wisdom;
+	uint _intelligence;
+	uint _hitPoints;
+	uint _experience;
+	uint _food;
+	uint _coins;
+	int _equippedWeapon;
+	int _equippedArmour;
+	int _equippedSpell;
+	ItemArray<Weapon *> _weapons;
+	ItemArray<Armour *> _armour;
+	ItemArray<Spell *> _spells;
+public:
+	/**
+	 * Constructor
+	 */
+	Character() : _strength(0), _agility(0), _stamina(0), _charisma(0), _wisdom(0), _intelligence(0),
+		_hitPoints(0), _experience(0), _food(0), _coins(0), _equippedWeapon(0), _equippedArmour(0), _equippedSpell(0),
+		_race(0), _sex(SEX_MALE), _class(0) {}
+
+	/**
+	 * Handles loading and saving games
+	 */
+	void synchronize(Common::Serializer &s);
+
+	/**
+	 * Returns true if a weapon is equipped
+	 */
+	bool isWeaponEquipped() const { return _equippedWeapon != 0; }
+
+	/**
+	 * Returns true if armor is equipped
+	 */
+	bool isArmourEquipped() const { return _equippedArmour != 0; }
+
+	/**
+	 * Returns true if a spell is equipped
+	 */
+	bool isSpellEquipped() const { return _equippedSpell != 0; }
+
+	/**
+	 * Return the equipped weapon
+	 */
+	Weapon *equippedWeapon() const { return _weapons[_equippedWeapon]; }
+
+	/**
+	 * Return the equipped armor
+	 */
+	Armour *equippedArmour() const { return _armour[_equippedArmour]; }
+
+	/**
+	 * Return the equipped spell
+	 */
+	Spell *equippedSpell() const { return _spells[_equippedSpell]; }
+
+	/**
+	 * Removes any equipped weapon
+	 */
+	void removeWeapon() { _equippedWeapon = 0; }
+
+	/**
+	 * Removes any eqipped armor
+	 */
+	void removeArmour() { _equippedArmour = 0; }
+
+	/**
+	 * Remove any equipped spell
+	 */
+	void removeSpell() { _equippedSpell = 0; }
+
+	/**
+	 * Gets the character's experience level
+	 */
+	uint getLevel() const { return (_experience / 1000) + 1; }
+};
+
+} // End of namespace Shared
+} // End of namespace Ultima
+
+#endif