combat.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_COMBAT_H
#define XEEN_COMBAT_H

#include "common/scummsys.h"
#include "common/rect.h"
#include "xeen/files.h"
#include "xeen/sprites.h"

namespace Xeen {

#define MAX_NUM_MONSTERS 107
#define PARTY_AND_MONSTERS 12
#define POW_COUNT 12
#define ATTACK_MONSTERS_COUNT 26

enum DamageType {
    DT_PHYSICAL = 0, DT_MAGICAL = 1, DT_FIRE = 2, DT_ELECTRICAL = 3,
    DT_COLD = 4, DT_POISON = 5, DT_ENERGY = 6, DT_SLEEP = 7,
    DT_FINGEROFDEATH = 8, DT_HOLYWORD = 9, DT_MASS_DISTORTION = 10,
    DT_UNDEAD = 11, DT_BEASTMASTER = 12, DT_DRAGONSLEEP = 13,
    DT_GOLEMSTOPPER = 14, DT_HYPNOTIZE = 15, DT_INSECT_SPRAY = 16,
    DT_POISON_VOLLEY = 17, DT_MAGIC_ARROW = 18
};

enum SpecialAttack {
    SA_NONE = 0, SA_MAGIC = 1, SA_FIRE = 2, SA_ELEC = 3, SA_COLD = 4,
    SA_POISON = 5, SA_ENERGY = 6, SA_DISEASE = 7, SA_INSANE = 8,
    SA_SLEEP = 9, SA_CURSEITEM = 10, SA_INLOVE = 11, SA_DRAINSP = 12,
    SA_CURSE = 13, SA_PARALYZE = 14, SA_UNCONSCIOUS = 15,
    SA_CONFUSE = 16, SA_BREAKWEAPON = 17, SA_WEAKEN = 18,
    SA_ERADICATE = 19, SA_AGING = 20, SA_DEATH = 21, SA_STONE = 22
};

enum ShootType {
    ST_0 = 0, ST_1 = 1
};

enum CombatMode {
    COMBATMODE_STARTUP = 0, COMBATMODE_INTERACTIVE = 1, COMBATMODE_2 = 2
};

enum PowType {
    POW_INVALID = -1, POW_FIREBALL = 0, POW_INCINERATE = 1,
    POW_FIERY_FLAIL = 2, POW_LIGHTNING = 3, POW_MEGAVOLTS = 4,
    POW_SPARKS = 5, POW_STOPPER = 6, POW_MAGIC_ORB = 7,
    POW_COLD_RAY = 8, POW_FROST_WAVE = 9, POW_SPRAY = 10,
    POW_ARROW = 11, POW_MAGIC_ARROW = 12, POW_ENERGY_BLAST = 13,
    POW_SPARKLES = 14, POW_DEADLY_SWARM = 15
};

enum RangeType {
    RT_SINGLE = 0, RT_GROUP = 1, RT_ALL = 2, RT_HIT = 3
};

class XeenEngine;
class Character;
class XeenItem;
class MonsterStruct;

struct PowSlot {
    bool _active;
    int _duration;
    int _scale;
    int _elemFrame;
    int _elemScale;

    PowSlot() : _active(false), _duration(0), _scale(0),
        _elemFrame(0), _elemScale(0) {}
};

class PowSlots {
private:
    PowSlot _data[POW_COUNT];
public:
    PowSlot &operator[](uint idx) {
        assert(idx < POW_COUNT);
        return _data[idx];
    }

    void resetElementals() {
        for (int idx = 0; idx < POW_COUNT; ++idx)
            _data[idx]._elemFrame = 0;
    }
};

class Combat {
private:
    XeenEngine *_vm;

    void attack2(int damage, RangeType rangeType);

    bool hitMonster(Character &c, RangeType rangeType);

    void getWeaponDamage(Character &c, RangeType rangeType);

    int getMonsterDamage(Character &c);

    int getDamageScale(int v);

    int getMonsterResistence(RangeType rangeType);

    void giveExperience(int experience);
public:
    Common::Array<Character *> _combatParty;
    bool _charsBlocked[PARTY_AND_MONSTERS];
    int _charsGone[PARTY_AND_MONSTERS];
    SpriteResource _powSprites;
    int _attackMonsters[ATTACK_MONSTERS_COUNT];
    int _monster2Attack;
    PowSlots _pow;
    int _missedShot[8];
    Common::Array<int> _speedTable;
    int _shootingRow[8];
    int _globalCombat;
    int _whosTurn;
    bool _itemFlag;
    int _monsterMap[32][32];
    bool _monsterMoved[MAX_NUM_MONSTERS];
    bool _rangeAttacking[MAX_NUM_MONSTERS];
    int _gmonHit[36];
    bool _monstersAttacking;
    CombatMode _combatMode;
    int _attackDurationCtr;
    bool _partyRan;
    int _whosSpeed;
    DamageType _damageType;
    Character *_oldCharacter;
    int _monsterDamage;
    int _weaponDamage;
    int _weaponDie, _weaponDice;
    int _weaponElemMaterial;
    XeenItem *_attackWeapon;
    int _attackWeaponId;
    File _missVoc;
    int _hitChanceBonus;
    bool _dangerPresent;
    bool _moveMonsters;
    RangeType _rangeType;
    ShootType _shootType;
    int _combatTarget;
public:
    Combat(XeenEngine *vm);

    void clearAttackers();

    void clearBlocked();

    void clearShooting();

    void reset();

    void giveCharDamage(int damage, DamageType attackType, int charIndex);

    void doCharDamage(Character &c, int charNum, int monsterDataIndex);

    void moveMonsters();

    void setupCombatParty();

    void setSpeedTable();

    bool allHaveGone() const;

    bool charsCantAct() const;

    Common::String getMonsterDescriptions();

    void attack(Character &c, RangeType rangeType);

    void block();

    void quickFight();

    void run();

    void monstersAttack();

    void setupMonsterAttack(int monsterDataIndex, const Common::Point &pt);

    bool canMonsterMove(const Common::Point &pt, int wallShift, int xDiff, int yDiff, int monsterId);

    void moveMonster(int monsterId, const Common::Point &moveDelta);

    void doMonsterTurn(int monsterId);

    void doMonsterTurn(int monsterId, int charNum);

    void endAttack();

    void monsterOvercome();

    int stopAttack(const Common::Point &diffPt);

    void rangedAttack(PowType powNum);

    void shootRangedWeapon();

    bool areMonstersPresent() const;
};

} // End of namespace Xeen

#endif  /* XEEN_COMBAT_H */