Entity.h

Go to the documentation of this file.

/*
 * Copyright (C) 2022 The V-Gears Team
 *
 * This file is part of V-Gears
 *
 * V-Gears is free software: you can redistribute it and/or modify it under
 * terms of the GNU General Public License as published by the Free Software
 * Foundation, version 3.0 (GPLv3) of the License.
 *
 * V-Gears 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.
 */
 
#pragma once
 
#include <OgreString.h>
#include "EntityCollision.h"
#include "EntityDirection.h"
#include "ScriptManager.h"
 
enum ActionType{
 
    AT_NONE,
 
    AT_LINEAR,
 
    AT_SMOOTH
};
 
enum TurnDirection{
 
    TD_CLOCKWISE,
 
    TD_ANTICLOCKWISE,
 
    TD_CLOSEST
};
 
enum LinearMovement{
 
    LM_UP_TO_DOWN,
 
    LM_DOWN_TO_UP,
 
    LM_LEFT_TO_RIGHT,
 
    LM_RIGHT_TO_LEFT
};
 
class Entity{
 
    public:
 
        enum AnimationState{
 
            REQUESTED_ANIMATION,
 
            AUTO_ANIMATION
        };
 
        enum AnimationPlayType{
 
            PLAY_DEFAULT,
 
            PLAY_ONCE,
 
            PLAY_LOOPED
        };
 
        enum State{
 
            NONE,
 
            WALKMESH,
 
            LINEAR,
 
            JUMP,
 
            NEEDS_TO_REATTACH
        };
 
        Entity(const Ogre::String& name, Ogre::SceneNode* node);
 
        virtual ~Entity();
 
        virtual void Update();
 
        virtual void UpdateDebug();
 
        const Ogre::String& GetName() const;
 
        void SetPosition(const Ogre::Vector3& position);
 
        void ScriptSetPosition(const float x, const float y, const float z);
 
        const Ogre::Vector3 GetPosition() const;
 
        void ScriptGetPosition() const;
 
        void SetOffset(const Ogre::Vector3& position);
 
        const Ogre::Vector3 GetOffset() const;
 
        void SetRotation(const Ogre::Degree& rotation);
 
        void ScriptSetRotation(const float rotation);
 
        Ogre::Degree GetRotation() const;
 
        float ScriptGetRotation() const;
 
        virtual void setScale(const Ogre::Vector3 &scale);
 
        void SetIndex(const int index);
 
        int GetIndex();
 
        virtual void setRootOrientation(
          const Ogre::Quaternion &root_orientation
        );
 
        float GetHeight() const;
 
        void SetSolidRadius(const float radius);
 
        float GetSolidRadius() const;
 
        void SetSolid(const bool solid);
 
        bool IsSolid() const;
 
        void SetTalkRadius(const float radius);
 
        float GetTalkRadius() const;
 
        void SetTalkable(const bool talkable);
 
        bool IsTalkable() const;
 
        virtual void SetVisible(const bool visible) = 0;
 
        virtual bool IsVisible() const = 0;
 
        void SetState(const State state);
 
        State GetState() const;
 
        void SetMoveAutoSpeed(const float speed);
 
        float GetMoveAutoSpeed() const;
 
        void SetMoveWalkSpeed(const float speed);
 
        float GetMoveWalkSpeed() const;
 
        void SetMoveRunSpeed(const float speed);
 
        float GetMoveRunSpeed() const;
 
        void SetMovePosition(const Ogre::Vector3& target);
 
        const Ogre::Vector3& GetMovePosition() const;
 
        float GetMoveStopDistance() const;
 
        void SetMoveTriangleId(const int triangle);
 
        int GetMoveTriangleId() const;
 
        void SetMoveAutoRotation(const bool rotate);
 
        bool GetMoveAutoRotation() const;
 
        void SetMoveAutoAnimation(const bool animate);
 
        bool GetMoveAutoAnimation() const;
 
        const Ogre::String& GetMoveAnimationWalkName() const;
 
        const Ogre::String& GetMoveAnimationRunName() const;
 
        void ScriptMoveToPosition(const float x, const float y);
 
        void ScriptMoveToEntity(Entity* entity);
 
        int ScriptMoveSync();
 
        int ScriptJumpSync();
 
        void UnsetMove();
 
        void ScriptLinearToPosition(
          const float x, const float y, const float z, const LinearMovement movement,
          const char* animation, const float orientation, const int dest_triangle
        );
 
        int ScriptLinearSync();
 
        void SetLinear(
          const Ogre::Vector3& end, const LinearMovement movement,
          const Ogre::String& animation, const float orientation, const int dest_triangle
        );
 
        void UnsetLinear();
 
        LinearMovement GetLinearMovement() const;
 
        const Ogre::Vector3& GetLinearStart() const;
 
        const Ogre::Vector3& GetLinearEnd() const;
 
        const int GetLinearDestTriangle() const;
 
        void ScriptJumpToPosition(
          const float x, const float y, const float z, const float seconds, const int dest_triangle
        );
 
        void SetJump(const Ogre::Vector3& jump_to, const float seconds, const int dest_triangle);
 
        void UnsetJump();
 
        const Ogre::Vector3& GetJumpStart() const;
 
        const Ogre::Vector3& GetJumpEnd() const;
 
        float GetJumpSeconds() const;
 
        void SetJumpCurrentSeconds(const float seconds);
 
        float GetJumpCurrentSeconds() const;
 
        const int GetJumpDestTriangle() const;
 
        void ScriptOffsetToPosition(
          const float x, const float y, const float z,
          const ActionType type, const float seconds
        );
 
        int ScriptOffsetSync();
 
        void UnsetOffset();
 
        const Ogre::Vector3& GetOffsetPositionStart() const;
 
        const Ogre::Vector3& GetOffsetPositionEnd() const;
 
        ActionType GetOffsetType() const;
 
        float GetOffsetSeconds() const;
 
        void SetOffsetCurrentSeconds(const float seconds);
 
        float GetOffsetCurrentSeconds() const;
 
        void ScriptTurnToDirection(
          const float direction, const TurnDirection turn_direction,
          const ActionType turn_type, const float seconds
        );
 
        void ScriptTurnToEntity(
          Entity* entity, const TurnDirection turn_direction,
          const float seconds
        );
 
        int ScriptTurnSync();
 
        void SetTurn(
          const Ogre::Degree& direction_to, Entity* entity, const TurnDirection turn_direction,
          const ActionType turn_type, const float seconds
        );
 
        void UnsetTurn();
 
        Ogre::Degree CalculateTurnAngle(const Ogre::Degree& start, const Ogre::Degree& end) const;
 
        Ogre::Degree GetTurnDirectionStart() const;
 
        Ogre::Degree GetTurnDirectionEnd() const;
 
        ActionType GetTurnType() const;
 
        float GetTurnSeconds() const;
 
        void SetTurnCurrentSeconds(const float seconds);
 
        float GetTurnCurrentSeconds() const;
 
        void ScriptSetAnimationSpeed(const float speed);
 
        const Ogre::String& GetDefaultAnimationName() const;
 
        const Ogre::String& GetCurrentAnimationName() const;
 
        AnimationState GetAnimationState() const;
 
        virtual void PlayAnimation(
          const Ogre::String& animation, AnimationState state,
          AnimationPlayType play_type, const float start, const float end
        ) = 0;
 
        virtual void PlayAnimationContinue(const Ogre::String& animation) = 0;
 
        virtual void UpdateAnimation(const float delta) = 0;
 
        void ScriptPlayAnimation(const char* name);
 
        void ScriptPlayAnimationStop(const char* name);
 
        void ScriptPlayAnimation(const char* name, const float start, const float end);
 
        void ScriptPlayAnimationStop(const char* name, const float start, const float end);
 
        void ScriptSetDefaultAnimation(const char* animation);
 
        int ScriptAnimationSync();
 
        void SetCharacter(int char_id);
 
        bool IsCharacter();
 
        int GetCharacterId();
 
        bool IsLine();
 
    protected:
 
        Ogre::String name_;
 
        Ogre::SceneNode* scene_node_;
 
        Ogre::SceneNode* model_node_;
 
        Ogre::SceneNode* model_root_node_;
 
        float height_;
 
        Ogre::SceneNode* direction_node_;
 
        EntityDirection* direction_;
 
        Ogre::SceneNode* solid_collision_node_;
 
        EntityCollision* solid_collision_;
 
        float solid_radius_;
 
        bool solid_;
 
        Ogre::SceneNode* talk_collision_node_;
 
        EntityCollision* talk_collision_;
 
        float talk_radius_;
 
        bool talkable_;
 
        State state_;
 
        std::vector<ScriptId> sync_;
 
        float move_auto_speed_;
 
        float move_walk_speed_;
 
        float move_run_speed_;
 
        Ogre::Vector3 move_position_;
 
        Entity* move_entity_;
 
        float move_stop_distance_;
 
        int move_triangle_id_;
 
        bool move_auto_rotation_;
 
        bool move_auto_animation_;
 
        Ogre::String move_animation_walk_;
 
        Ogre::String move_animation_run_;
 
        LinearMovement linear_movement_;
 
        Ogre::Vector3 linear_start_;
 
        Ogre::Vector3 linear_end_;
 
        int linear_dest_triangle_;
 
        Ogre::Vector3 jump_start_;
 
        Ogre::Vector3 jump_end_;
 
        float jump_seconds_;
 
        float jump_current_seconds_;
 
        bool jump_was_solid_;
 
        int jump_dest_triangle_;
 
        Ogre::Vector3 offset_position_start_;
 
        Ogre::Vector3 offset_position_end_;
 
        ActionType offset_type_;
 
        float offset_seconds_;
 
        float offset_current_seconds_;
 
        std::vector<ScriptId> offset_sync_;
 
        TurnDirection turn_direction_;
 
        Ogre::Degree turn_direction_start_;
 
        Ogre::Degree turn_direction_end_;
 
        Entity* turn_entity_;
 
        ActionType turn_type_;
 
        float turn_seconds_;
 
        float turn_current_seconds_;
 
        std::vector<ScriptId> turn_sync_;
 
        float animation_speed_;
 
        Ogre::String animation_current_name_;
 
        std::vector<ScriptId> animation_sync_;
 
        AnimationState animation_state_;
 
        AnimationPlayType animation_play_type_;
 
        Ogre::String animation_default_;
 
        float animation_end_time_;
 
        bool animation_auto_play_;
 
    private:
 
        Entity();
 
        Ogre::Degree GetDirectionToEntity(Entity* entity) const;
 
        bool is_character_;
 
        int character_id_;
 
        int index_;
 
        bool is_line_;
 
};