combat_controller.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 ULTIMA4_CONTROLLERS_COMBAT_CONTROLLER_H
#define ULTIMA4_CONTROLLERS_COMBAT_CONTROLLER_H
 
#include "ultima/ultima4/map/direction.h"
#include "ultima/ultima4/map/map.h"
#include "ultima/ultima4/controllers/controller.h"
#include "ultima/ultima4/core/observer.h"
#include "ultima/ultima4/core/types.h"
#include "ultima/ultima4/filesys/savegame.h"
#include "ultima/ultima4/game/creature.h"
#include "ultima/ultima4/game/game.h"
#include "ultima/ultima4/game/object.h"
#include "ultima/ultima4/game/player.h"
 
namespace Ultima {
namespace Ultima4 {
 
#define AREA_CREATURES   16
#define AREA_PLAYERS    8
 
class CombatMap;
class Creature;
class MoveEvent;
class Weapon;
 
typedef enum {
    CA_ATTACK,
    CA_CAST_SLEEP,
    CA_ADVANCE,
    CA_RANGED,
    CA_FLEE,
    CA_TELEPORT
} CombatAction;
 
class CombatController : public Controller, public Observer<Party *, PartyEvent &>, public TurnCompleter {
protected:
    CombatController();
public:
    CombatController(CombatMap *m);
    CombatController(MapId id);
    virtual ~CombatController();
 
    // Accessor Methods
    bool isCombatController() const override {
        return true;
    }
 
    void setActive() override;
 
    bool isCamping() const;
    bool isWinOrLose() const;
    Direction getExitDir() const;
    byte getFocus() const;
    CombatMap *getMap() const;
    Creature *getCreature() const;
    PartyMemberVector *getParty();
    PartyMember *getCurrentPlayer();
 
    void setExitDir(Direction d);
    void setCreature(Creature *);
    void setWinOrLose(bool worl = true);
    void showCombatMessage(bool show = true);
 
    // Methods
    virtual void init(Creature *m);
 
    void initDungeonRoom(int room, Direction from);
 
    void applyCreatureTileEffects();
 
    virtual void begin();
    virtual void end(bool adjustKarma);
 
    void fillCreatureTable(const Creature *creature);
 
    int  initialNumberOfCreatures(const Creature *creature) const;
 
    bool isWon() const;
 
    bool isLost() const;
 
    void moveCreatures();
 
    void placeCreatures();
 
    void placePartyMembers();
 
    bool setActivePlayer(int player);
    bool attackHit(Creature *attacker, Creature *defender);
    virtual void awardLoot();
 
    // attack functions
    void attack(Direction dir = DIR_NONE, int distance = 0);
    bool attackAt(const Coords &coords, PartyMember *attacker, int dir, int range, int distance);
    bool rangedAttack(const Coords &coords, Creature *attacker);
    void rangedMiss(const Coords &coords, Creature *attacker);
    bool returnWeaponToOwner(const Coords &coords, int distance, int dir, const Weapon *weapon);
 
    static void attackFlash(const Coords &coords, MapTile tile, int timeFactor);
    static void attackFlash(const Coords &coords, const Common::String &tilename, int timeFactor);
    static void doScreenAnimationsWhilePausing(int timeFactor);
 
    void keybinder(KeybindingAction action) override;
 
    void finishTurn() override;
 
    void movePartyMember(MoveEvent &event);
    void update(Party *party, PartyEvent &event) override;
 
    // Properties
protected:
    CombatMap *_map;
 
    PartyMemberVector _party;
    byte _focus;
 
    const Creature *_creatureTable[AREA_CREATURES];
    Creature *_creature;
 
    bool _camping;
    bool _forceStandardEncounterSize;
    bool _placePartyOnMap;
    bool _placeCreaturesOnMap;
    bool _winOrLose;
    bool _showMessage;
    Direction _exitDir;
 
private:
    CombatController(const CombatController &);
    const CombatController &operator=(const CombatController &);
 
    void init();
};
 
extern CombatController *g_combat;
 
class CombatMap : public Map {
public:
    CombatMap();
    ~CombatMap() override {}
 
    CreatureVector getCreatures();
 
    PartyMemberVector getPartyMembers();
 
    PartyMember *partyMemberAt(Coords coords);
 
    Creature *creatureAt(Coords coords);
 
    static MapId mapForTile(const Tile *ground, const Tile *transport, Object *obj);
 
    // Getters
    bool isDungeonRoom() const {
        return _dungeonRoom;
    }
    bool isAltarRoom() const {
        return _altarRoom != VIRT_NONE;
    }
    bool isContextual() const {
        return _contextual;
    }
    BaseVirtue getAltarRoom() const {
        return _altarRoom;
    }
 
    // Setters
    void setAltarRoom(BaseVirtue ar) {
        _altarRoom = ar;
    }
    void setDungeonRoom(bool d) {
        _dungeonRoom = d;
    }
    void setContextual(bool c) {
        _contextual = c;
    }
 
    // Properties
protected:
    bool _dungeonRoom;
    BaseVirtue _altarRoom;
    bool _contextual;
 
public:
    Coords creature_start[AREA_CREATURES];
    Coords player_start[AREA_PLAYERS];
};
 
bool isCombatMap(Map *punknown);
CombatMap *getCombatMap(Map *punknown = nullptr);
 
} // End of namespace Ultima4
} // End of namespace Ultima
 
#endif