ICharacter.h

Go to the documentation of this file.

#pragma once

#include "common/NonCopyable.h"
#include "common/Math.h"
#include "common/Types.h"
#include <atomic>
#include <memory>

namespace ai {

namespace attributes {
const char* const NAME = "Name";
const char* const GROUP = "Group";
const char* const ID = "Id";
const char* const POSITION = "Position";
const char* const SPEED = "Speed";
const char* const ORIENTATION = "Orientation";
}

class ICharacter : public NonCopyable, public std::enable_shared_from_this<ICharacter> {
protected:
    const CharacterId _id;
    glm::vec3 _position;
    std::atomic<float> _orientation;
    // m/s
    std::atomic<float> _speed;
    CharacterAttributes _attributes;

public:
    explicit ICharacter(CharacterId id) :
            _id(id), _orientation(0.0f), _speed(0.0f) {
    }

    virtual ~ICharacter() {
    }

    bool operator ==(const ICharacter& character) const;
    bool operator !=(const ICharacter& character) const;

    CharacterId getId() const;
    virtual void setPosition(const glm::vec3& position);

    const glm::vec3& getPosition() const;
    virtual void setOrientation(float orientation);
    float getOrientation() const;
    virtual void setSpeed(float speed);
    float getSpeed() const;
    virtual void setAttribute(const std::string& key, const std::string& value);
    const CharacterAttributes& getAttributes() const;
    virtual void update(int64_t dt, bool debuggingActive) {
        (void)dt;
        (void)debuggingActive;
    }

    inline std::shared_ptr<ICharacter> ptr() {
        return shared_from_this();
    }
};

inline void ICharacter::setPosition(const glm::vec3& position) {
    ai_assert(!isInfinite(position), "invalid position");
    _position = position;
}

inline void ICharacter::setOrientation (float orientation) {
    _orientation = orientation;
}

inline float ICharacter::getOrientation () const {
    return _orientation;
}

inline void ICharacter::setAttribute(const std::string& key, const std::string& value) {
    _attributes[key] = value;
}

inline const CharacterAttributes& ICharacter::getAttributes() const {
    return _attributes;
}

inline bool ICharacter::operator ==(const ICharacter& character) const {
    return character._id == _id;
}

inline bool ICharacter::operator !=(const ICharacter& character) const {
    return character._id != _id;
}

inline CharacterId ICharacter::getId() const {
    return _id;
}

inline const glm::vec3& ICharacter::getPosition() const {
    return _position;
}

inline void ICharacter::setSpeed(float speed) {
    _speed = speed;
}

inline float ICharacter::getSpeed() const {
    return _speed;
}

typedef std::shared_ptr<ICharacter> ICharacterPtr;

template <typename CharacterType>
inline const CharacterType& character_cast(const ICharacter& character) {
    return ai_assert_cast<const CharacterType&>(character);
}

template <typename CharacterType>
inline CharacterType& character_cast(ICharacter& character) {
    return ai_assert_cast<CharacterType&>(character);
}

template <typename CharacterType>
inline CharacterType& character_cast(const ICharacterPtr& character) {
    return *ai_assert_cast<CharacterType*>(character.get());
}

}