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 MM1_GAME_COMBAT_H
#define MM1_GAME_COMBAT_H
 
#include "common/array.h"
#include "mm/mm1/data/character.h"
#include "mm/mm1/data/party.h"
#include "mm/mm1/game/game_logic.h"
#include "mm/mm1/game/encounter.h"
#include "mm/mm1/game/monster_touch.h"
 
namespace MM {
namespace MM1 {
namespace Game {
 
class Combat : public MonsterTouch {
protected:
    Common::Array<Line> _message;
    int _monstersCount = 0;
    Monster *_monsterP;
    bool _treasureFlags[MAX_PARTY_SIZE];
    int _val1;
    int _roundNum;
    int _monsterIndex, _currentChar;
    bool _allowFight, _allowShoot, _allowCast, _allowAttack;
    byte _val6, _val7;
    int _partyIndex, _val9, _monsterShootingCtr;
    int _activeMonsterNum;
    int _destCharCtr;
    int _destAC;
    int _numberOfTimes;
    int _attackerLevel;
    int _handicapThreshold, _handicapParty;
    int _handicapMonsters, _handicapDelta;
    int _attackersCount;
    int _totalExperience;
    Common::String _monsterName;
    bool _monstersResistSpells;
    bool _monstersRegenerate;
    AttributePair _attackAttr1, _attackAttr2;
    int _timesHit;
    bool _isShooting;
    Common::String _attackMessage;
    enum Handicap {
        HANDICAP_EVEN = 0, HANDICAP_PARTY = 1,
        HANDICAP_MONSTER = 2
    };
    Handicap _handicap = HANDICAP_EVEN;
    enum Mode {
        SELECT_OPTION, FIGHT_WHICH, DEFEATED_MONSTERS,
        NEXT_ROUND, MONSTER_ADVANCES, MONSTERS_AFFECTED,
        MONSTER_FLEES, MONSTER_WANDERS, MONSTER_SPELL,
        CHAR_ATTACKS, MONSTER_ATTACK, INFILTRATION,
        WAITS_FOR_OPENING, SPELL_RESULT, NO_EFFECT
    };
    Mode _mode = SELECT_OPTION;
 
    int _destMonsterNum = 0;
    int _selectedSpellMonster = -1;
    int _monstersDestroyedCtr = 0;
    bool _turnUndeadUsed = false;
    bool _divineInterventionUsed = false;
    size_t _spellMonsterCount = 0;
    // Transient combat-only display state; never serialized.
    int _slowCasts = 0;
    int _weakenCasts = 0;
    int _heroismBonus[MAX_PARTY_SIZE] = {};
    bool _heroismIsSuper[MAX_PARTY_SIZE] = {};
    // -1 means the spell has not been cast; a real roll may be zero.
    int _powerBonus[MAX_PARTY_SIZE] = {};
    int _quicknessBonus[MAX_PARTY_SIZE] = {};
 
    int _monsterAttackStyle = -1;
 
    Combat();
 
    virtual ~Combat();
 
    virtual void setMode(Mode newMode) = 0;
 
    virtual void combatDone();
 
    Common::String subtractDamageFromChar() override;
 
    void clear();
 
    void loadMonsters();
 
    void monsterIndexOf();
 
    void monsterSetPtr(int monsterNum);
 
    void setupCanAttacks();
 
    void setupAttackersCount();
 
    void checkLeftWall();
 
    void checkRightWall();
 
    void setupHandicap();
 
    /*------- Inherited virtual methods ------*/
 
    int getMonsterIndex() const override {
        return _monsterIndex;
    }
 
    bool canMonsterCast() const override;
 
    void dispelParty() override;
 
    void removeMonster() override;
 
    /*------- combat execution ------*/
 
    void combatLoop(bool checkMonstersFirst = false);
 
    void selectTreasure();
    void selectTreasure2(int index);
 
    void nextRound();
    void nextRound2();
    void nextRound3();
 
    void updateHighestLevel();
 
    void monsterAction();
 
    bool checkMonsterSpells();
 
    void checkMonsterActions();
 
    void defeatedMonsters();
    void setTreasure();
    void clearArrays();
    bool moveMonsters();
    void monsterAdvances(uint index);
    bool monsterChanges();
    void proc2();
    void checkParty();
 
    void fightMonster(int monsterNum);
    void shootMonster(int monsterNum);
    void attackMonsterPhysical();
    void attackMonsterShooting();
    void attackMonster(int monsterNum);
 
    void addAttackDamage();
 
    void updateMonsterStatus();
 
    bool monsterTouch(Common::String &line);
 
    void monsterAttackRandom();
    void monsterAttackInner();
 
    void monsterAttackShooting();
 
    void selectMonsterTarget();
 
 
    void attack();
 
    void block();
 
    void cast();
 
    void exchangeWith(int charNum);
 
    void use();
 
    void retreat();
 
    void removeDeadMonsters();
 
private:
    void spellFailed();
    void destroyMonster();
    bool monsterLevelThreshold() const;
    void iterateMonsters1Inner();
    void iterateMonsters2Inner();
    void characterDone();
    void summonLightning2();
    void fireball2();
    void levelAdjust();
 
public:
    virtual void displaySpellResult(const InfoMessage &msg) = 0;
 
    void iterateMonsters1();
    void iterateMonsters2();
    void iterateSelectedMonster1();
    void iterateSelectedMonster2();
    bool setSpellTarget(int monsterNum);
    void resetDestMonster();
 
    // Cleric spells that need access to internal fields
    void turnUndead();
    void summonLightning();
    void paralyze();
    bool divineIntervention();
    void holyWord();
 
    int getSlowCasts() const { return _slowCasts; }
    int getWeakenCasts() const { return _weakenCasts; }
    int getHeroismBonus(uint index) const;
    bool isSuperHeroism(uint index) const;
    int getPowerBonus(uint index) const;
    int getQuicknessBonus(uint index) const;
    void recordHeroism(Character *character, int bonus, bool isSuper);
    void recordPower(Character *character, int bonus);
    void recordQuickness(Character *character, int bonus);
 
    // Wizard spells that need access to internal fields
    void identifyMonster();
    bool fireball();
    void lightningBolt();
    void makeRoom();
    void slow();
    void weaken();
    bool web();
    bool acidRain();
    void fingerOfDeath();
    void disintegration();
 
    void endCombat();
};
 
} // namespace Game
} // namespace MM1
} // namespace MM
 
#endif