Tactics3DFightingStyle.h

Go to the documentation of this file.

//    Copyright (C) 2006-2015 Dylan Blair
//
//    email: dblair@alumni.cs.utexas.edu
//
//    This file is part of Tactics3D.
//
//    Tactics3D 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 2 of the License, or
//    (at your option) any later version.
//
//    Tactics3D 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, write to the Free Software
//    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

#ifndef TACTICS3DFIGHTING_STYLE_H
#define TACTICS3DFIGHTING_STYLE_H

#include <vector>
#include <string>
#include <map>

#include "../Libs/Utils_LIB/UTypes.h"

namespace Tactics3D {
    class Warrior;
    class AttackRange;
    struct SpecialMoveAction;

    enum SPECIAL_MOVE { NO_MOVE, HAYMAKER, ONE_TWO_PUNCH, POWER_PUNCH, 
        LEG_SWEEP, DOUBLE_PUMP_THRUST_KICK, POWER_SLAM, SCORPION_DEATHLOCK, 
        HIP_FIRE, IRON_SIGHTS_FIRE };

    enum FIGHTING_STYLE { NO_STYLE, BRAWLING, BOXING, KARATE, KICKBOXING, 
        SUMO_WRESTLING, WEAPON_PROFICIENCY, WRESTLING, HIGHEST_OO };

    struct CounterableMove {
        Warrior* _attacker;
        SPECIAL_MOVE _move;
        int _numRoundEndEvents;

        CounterableMove() : _attacker(0), _move(NO_MOVE), _numRoundEndEvents(0) {}

        CounterableMove(Warrior* attacker_, SPECIAL_MOVE move_) : 
            _attacker(attacker_), _move(move_), _numRoundEndEvents(0) {}

        bool operator<(const CounterableMove& rhs_) const {
            if (_attacker != rhs_._attacker)
                return (_attacker < rhs_._attacker);
            return _move < rhs_._move;
        }
    };

    struct SpecialMove {
        FIGHTING_STYLE _style;
        SPECIAL_MOVE _id;
        std::string _name;

        SpecialMove(FIGHTING_STYLE style_, SPECIAL_MOVE id_, const std::string& name_) : _style(style_), _id(id_), _name(name_) {}
        virtual ~SpecialMove() {}

        virtual void use(Warrior* attacker_, const AttackRange* attackRange_, 
            Warrior* defender_, SpecialMoveAction* specialMoveAction_) const {}

        virtual void use(const std::vector<Warrior*>& attackers_, 
            const std::vector<const AttackRange*>& attackRanges_, 
            const std::vector<Warrior*>& defenders_, SpecialMoveAction* specialMoveAction_) const {
            if ((attackers_.size() == 1) && (defenders_.size() == 1))
                use(attackers_[0],attackRanges_[0],defenders_[0],specialMoveAction_);
        }

        virtual void use(Warrior* attacker_, const AttackRange* attackRange_, 
            Warrior* defender_, const std::vector<OpenSkyNet::Utils::TaggedUnion>& params_, 
            SpecialMoveAction* specialMoveAction_) const {
            if (params_.size() == 0) use(attacker_,attackRange_,defender_,specialMoveAction_);
        }

        virtual void use(const std::vector<Warrior*>& attackers_, 
            const std::vector<const AttackRange*>& attackRanges_, 
            const std::vector<Warrior*>& defenders_, const std::vector<OpenSkyNet::Utils::TaggedUnion>& params_, 
            SpecialMoveAction* specialMoveAction_) const {
            if ((attackers_.size() == 1) && (defenders_.size() == 1))
                use(attackers_[0],attackRanges_[0],defenders_[0],params_,specialMoveAction_);
            else if (params_.size() == 0)
                use(attackers_,attackRanges_,defenders_,specialMoveAction_);
        }

        virtual int getNumDefenders(const Warrior* attacker_) const { return 1; }
        virtual void getOOAdj(const Warrior* attacker_, int& min_, int& max_) const { UNUSED(attacker_); min_ = 0; max_ = 0; }
        virtual void getODAdj(const Warrior* attacker_, int& min_, int& max_) const { UNUSED(attacker_); min_ = 0; max_ = 0; }
        virtual void getDmgAdj(const Warrior* attacker_, int OOAdj_, int& min_, int& max_) const { UNUSED(attacker_); UNUSED(OOAdj_); min_ = 0; max_ = 0; }
        virtual void getPlayerInfo(const Warrior* attacker_, char* buffer_, int bufferLen_) const { UNUSED(attacker_); memset(buffer_,0,bufferLen_); }
        virtual void getPrePerformInfo(char* buffer_, int bufferLen_) const { memset(buffer_,0,bufferLen_); }
        virtual void getAnimationName(char* buffer_, int bufferLen_) const { strncpy(buffer_, "attack", bufferLen_); }

        virtual bool canMoveInSameRound() const { return true; }
        virtual bool canTranslate() const { return false; }
        virtual bool canRotate() const { return false; }

        virtual bool doesMoveCurrCamToWarriorPOV(const Warrior* attacker_) const { UNUSED(attacker_); return false; }

        virtual void formatSpecialMoveParams(int OOAdj_, int ODAdj_, int DmgAdj_, 
            std::vector<OpenSkyNet::Utils::TaggedUnion>& specialMoveParams_) const { UNUSED(OOAdj_); UNUSED(ODAdj_); UNUSED(DmgAdj_); specialMoveParams_.clear(); }
    };

    struct Haymaker : public SpecialMove {
        Haymaker() : SpecialMove(BRAWLING, HAYMAKER, "Haymaker") {}
        virtual void use(Warrior* attacker_, const AttackRange* attackRange_, 
            Warrior* defender_, SpecialMoveAction* specialMoveAction_) const;

        virtual void getOOAdj(const Warrior* attacker_, int& min_, int& max_) const;
        virtual void getDmgAdj(const Warrior* attacker_, int OOAdj_, int& min_, int& max_) const;
        virtual void getPlayerInfo(const Warrior* attacker_, char* buffer_, int bufferLen_) const;
    };
    extern const Haymaker g_haymaker;

    struct OneTwoPunch : public SpecialMove {
        OneTwoPunch() : SpecialMove(BOXING, ONE_TWO_PUNCH, "1-2 Punch") {}
        virtual void use(Warrior* attacker_, const AttackRange* attackRange_, 
            Warrior* defender_, SpecialMoveAction* specialMoveAction_) const;

        virtual void getODAdj(const Warrior* attacker_, int& min_, int& max_) const;
        virtual void getDmgAdj(const Warrior* attacker_, int OOAdj_, int& min_, int& max_) const;
        virtual void getPlayerInfo(const Warrior* attacker_, char* buffer_, int bufferLen_) const;
    };
    extern const OneTwoPunch g_oneTwoPunch;

    struct PowerPunch : public SpecialMove {
        PowerPunch() : SpecialMove(BOXING, POWER_PUNCH, "Power Punch") {}
        virtual void use(Warrior* attacker_, const AttackRange* attackRange_, 
            Warrior* defender_, const std::vector<OpenSkyNet::Utils::TaggedUnion>& params_, 
            SpecialMoveAction* specialMoveAction_) const;

        virtual void getOOAdj(const Warrior* attacker_, int& min_, int& max_) const;
        virtual void getDmgAdj(const Warrior* attacker_, int OOAdj_, int& min_, int& max_) const;
        virtual void getPlayerInfo(const Warrior* attacker_, char* buffer_, int bufferLen_) const;

        virtual void formatSpecialMoveParams(int OOAdj_, int ODAdj_, int DmgAdj_, 
            std::vector<OpenSkyNet::Utils::TaggedUnion>& specialMoveParams_) const;
    };
    extern const PowerPunch g_powerPunch;

    struct LegSweep : public SpecialMove {
        LegSweep() : SpecialMove(KARATE, LEG_SWEEP, "Leg Sweep") {}
        virtual void use(Warrior* attacker_, const AttackRange* attackRange_, 
            Warrior* defender_, SpecialMoveAction* specialMoveAction_) const;

        virtual void getOOAdj(const Warrior* attacker_, int& min_, int& max_) const;
        virtual void getPlayerInfo(const Warrior* attacker_, char* buffer_, int bufferLen_) const;
    };
    extern const LegSweep g_legSweep;

    struct DoublePumpThrustKick : public SpecialMove {
        DoublePumpThrustKick() : SpecialMove(KARATE, DOUBLE_PUMP_THRUST_KICK, "Double-Pump Thrust Kick") {}
        virtual void use(Warrior* attacker_, const AttackRange* attackRange_, 
            Warrior* defender_, SpecialMoveAction* specialMoveAction_) const;

        virtual void getODAdj(const Warrior* attacker_, int& min_, int& max_) const;
        virtual void getPlayerInfo(const Warrior* attacker_, char* buffer_, int bufferLen_) const;
    };
    extern const DoublePumpThrustKick g_doublePumpThrustKick;

    struct PowerSlam : public SpecialMove {
        PowerSlam() : SpecialMove(WRESTLING, POWER_SLAM, "Power Slam") {}
        virtual void use(Warrior* attacker_, const AttackRange* attackRange_, 
            Warrior* defender_, SpecialMoveAction* specialMoveAction_) const;

        virtual void getOOAdj(const Warrior* attacker_, int& min_, int& max_) const;
        virtual void getPlayerInfo(const Warrior* attacker_, char* buffer_, int bufferLen_) const;
    };
    extern const PowerSlam g_powerSlam;

    struct ScorpionDeathlock : public SpecialMove {
        ScorpionDeathlock() : SpecialMove(WRESTLING, SCORPION_DEATHLOCK, "Scorpion Deathlock") {}
        virtual void use(Warrior* attacker_, const AttackRange* attackRange_, 
            Warrior* defender_, SpecialMoveAction* specialMoveAction_) const;

        virtual void getOOAdj(const Warrior* attacker_, int& min_, int& max_) const;
        virtual void getPlayerInfo(const Warrior* attacker_, char* buffer_, int bufferLen_) const;
    };
    extern const ScorpionDeathlock g_scorpionDeathlock;

    struct HipFire : public SpecialMove {
        HipFire() : SpecialMove(WEAPON_PROFICIENCY, HIP_FIRE, "Hip Fire") {}
        virtual void use(Warrior* attacker_, const AttackRange* attackRange_, 
            Warrior* defender_, const std::vector<OpenSkyNet::Utils::TaggedUnion>& params_, 
            SpecialMoveAction* specialMoveAction_) const;

        virtual void getPlayerInfo(const Warrior* attacker_, char* buffer_, int bufferLen_) const;
        virtual void getPrePerformInfo(char* buffer_, int bufferLen_) const;
        virtual void getAnimationName(char* buffer_, int bufferLen_) const { memset(buffer_,0,bufferLen_); }

        virtual bool canRotate() const { return true; }

        virtual bool doesMoveCurrCamToWarriorPOV(const Warrior* attacker_) const;
    };
    extern const HipFire g_hipFire;

    struct IronSightsFire : public SpecialMove {
        IronSightsFire() : SpecialMove(WEAPON_PROFICIENCY, IRON_SIGHTS_FIRE, "Iron Sights Fire") {}
        virtual void use(Warrior* attacker_, const AttackRange* attackRange_, 
            Warrior* defender_, const std::vector<OpenSkyNet::Utils::TaggedUnion>& params_, 
            SpecialMoveAction* specialMoveAction_) const;

        virtual void getPlayerInfo(const Warrior* attacker_, char* buffer_, int bufferLen_) const;
        virtual void getPrePerformInfo(char* buffer_, int bufferLen_) const;
        virtual void getAnimationName(char* buffer_, int bufferLen_) const { memset(buffer_,0,bufferLen_); }

        virtual bool canMoveInSameRound() const { return false; }
        virtual bool canRotate() const { return true; }

        virtual bool doesMoveCurrCamToWarriorPOV(const Warrior* attacker_) const;
    };
    extern const IronSightsFire g_ironSightsFire;

    extern std::map<SPECIAL_MOVE, const SpecialMove*> g_specialMoves;

    struct FightingStyle {
        FIGHTING_STYLE _style;
        std::string _name;
        int _offense, _defense;
        std::vector<SPECIAL_MOVE> _specialMoves;

        FightingStyle(FIGHTING_STYLE style_, std::string name_, int offense_, int defense_) : 
            _style(style_), _name(name_), _offense(offense_), _defense(defense_) {}

        virtual void getInfo(char* buffer_, int bufferLen_) const;

        static void initAll();
    };
    extern FightingStyle g_brawling;
    extern FightingStyle g_boxing;
    extern FightingStyle g_karate;
    extern FightingStyle g_wrestling;
    extern FightingStyle g_weaponProficiency;

    extern std::map<FIGHTING_STYLE, const FightingStyle*> g_fightingStyles;
}

#endif //TACTICS3DFIGHTING_STYLE_H