Tactics3DPC.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 TACTICS3DPC_H
#define TACTICS3DPC_H

#include "../Libs/Core_LIB/CCamera.h"
#include "../Libs/Core_LIB/ITransformChangeListener.h"
#include "../Libs/Utils_LIB/USocket.h"

#include "Tactics3DWarrior.h"

namespace Tactics3D {
    class PC : public Warrior, public OpenSkyNet::Core::TransformChangeListener {
        static OpenSkyNet::Utils::SyncEvent _gotActionsEvent;
        static OpenSkyNet::Utils::SyncEvent _infoAcknowledgedEvent;
        static OpenSkyNet::Utils::SyncEvent _currCamJustBecameWarriorPOVEvent;
    protected:
        OpenSkyNet::Core::Cinematographer* _cine;
        std::string _spreadWindowName;
        OpenSkyNet::Utils::Socket* _socket;
        bool _waitingForPerformEvent;
        float _secsSinceLastTransformNetworkUpdate;
    public:
        PC(OpenSkyNet::Utils::uint networkId_, OpenSkyNet::Core::PhysVisObject* pVO_, 
            int gp_, int lvl_, int dex_, int str_, int end_, TEAM team_, 
            OpenSkyNet::Core::Cinematographer* cine_, const std::string& spreadWindowName_, 
            OpenSkyNet::Utils::Socket* socket_);

        virtual ~PC() {}

        virtual void setPos(const OpenSkyNet::Math::Point<>& pos_);

        virtual void handleNonCollidingTransformApplied(OpenSkyNet::Core::Object* obj_);

        virtual void handleNewAttackRangeCollisions(AttackRange* collidee_, std::vector<OpenSkyNet::Core::Object*>& colliders_);
        virtual void handleDeletedAttackRangeCollisions(AttackRange* collidee_, std::vector<OpenSkyNet::Core::Object*>& colliders_);

        virtual void handleTransformChange(OpenSkyNet::Core::Object* obj_, const OpenSkyNet::Math::Point<>& prevPos_, const OpenSkyNet::Math::Matrix3x3& prevRot_, float dt_);
        virtual void handleIdle(OpenSkyNet::Core::Object* obj_, float idleSecs_);

        static volatile bool _waitingForInfoAcknowledgment;

        static inline void setGotActionsEvent(bool ignoreIfQuitting_) {
            setEvent(_gotActionsEvent,ignoreIfQuitting_);
        }
        static inline void waitForGotActionsEvent(bool ignoreIfQuitting_) {
            waitForEvent(_gotActionsEvent,ignoreIfQuitting_);
        }

        static inline void setInfoAcknowledgedEvent(bool ignoreIfQuitting_) {
            if (!_isSmokeTest)
                setEvent(_infoAcknowledgedEvent,ignoreIfQuitting_);
        }
        static inline void waitForInfoAcknowledgedEvent(bool ignoreIfQuitting_) {
            if (!_isSmokeTest)
                waitForEvent(_infoAcknowledgedEvent,ignoreIfQuitting_);
        }

        static volatile bool _isCurrCamWarriorPOV;

        static inline void setCurrCamJustBecameWarriorPOVEvent() {
            _isCurrCamWarriorPOV = true;
            setEvent(_currCamJustBecameWarriorPOVEvent, true);
        }
        static inline void waitForCurrCamJustBecameWarriorPOVEvent() {
            waitForEvent(_currCamJustBecameWarriorPOVEvent, true);
        }

        inline bool isWaitingForPerformEvent() const { return _waitingForPerformEvent; }

        virtual void onPrePerformAnyAction(const std::vector<Warrior*>& warriors_);
        virtual void onMove();
        virtual void onHipFire(OpenSkyNet::Core::Object* intendedTarget_, Action* action_);
        virtual void onIronSightsFire(OpenSkyNet::Core::Object* intendedTarget_, Action* action_);
        virtual void onEvocation();
        virtual void onAttacked(const std::vector<OpenSkyNet::Utils::TaggedUnion>& eventParams_);

        virtual void setActions();

        void sendAttributes();
        void sendActions();
        void sendMoveUpdate(int flags_);
        void sendAttack(const std::vector<OpenSkyNet::Utils::TaggedUnion>& eventParams_);
    };
}

#endif //TACTICS3DPC_H