projectile.hpp

Go to the documentation of this file.

#include "server/game/object.hpp"
#include "server/game/constants.hpp"
#include "server/game/arrowtrap.hpp"
#include "server/game/spell.hpp"
#include "shared/game/sharedmodel.hpp"
 
#include <optional>
#include <deque>
#include <iostream>
#include <variant>
 
class Projectile : public Object {
public:
    struct Options {
        Options(bool isSpell, int damage, float h_mult, float v_mult,
            bool homing, float homing_strength, int homing_duration,
            std::optional<EntityID> target
        ):
            isSpell(isSpell), damage(damage), h_mult(h_mult), 
            v_mult(v_mult), homing(homing), homing_strength(homing_strength),
            homing_duration(homing_duration), target(target)
        {
            if (homing && !target.has_value()) {
                std::cerr << "FATAL: homing projectile created without target.\n"
                    << "We could potentially implement this to home on the closest Player / Enemy object,\n"
                    << "But this isn't implemented yet.\n";
                std::exit(1);
            }
        }
 
        bool isSpell;
        float h_mult;
        float v_mult;
        int damage;
        bool homing;
        float homing_strength;
        int homing_duration;
        std::optional<EntityID> target;
    };
 
    Projectile(glm::vec3 corner, glm::vec3 facing, 
        glm::vec3 dimensions, ModelType model,
        std::optional<ServerSFX> destroy_sound, Options&& options);
 
    void doCollision(Object* other, ServerGameState& state) override;
 
    bool doTick(ServerGameState& state);
 
    virtual SharedObject toShared() override;
 
 
private:
    Options opt;
    std::optional<ServerSFX> destroy_sound;
    PointLightProperties properties;
 
};
 
class HomingFireball : public Projectile {
public:
    inline static const int DAMAGE = 15;
    inline static const float H_MULT = 0.4;
    inline static const float V_MULT = 0.1;
    inline static const float HOMING_STRENGTH = 0.1f;
    inline static const int HOMING_DURATION_TICKS = 80; // 2.4s
 
    HomingFireball(glm::vec3 corner, glm::vec3 facing, std::optional<EntityID> target):
        Projectile(corner, facing, glm::vec3(0.4f, 0.4f, 0.4f), ModelType::Fireball, ServerSFX::FireballImpact,
            Options(false, DAMAGE, H_MULT, V_MULT, true, HOMING_STRENGTH, HOMING_DURATION_TICKS, target))
    {
        this->physics.feels_gravity = false;
    }
};
 
class Arrow : public Projectile {
public:
    inline static const int DAMAGE = 10;
    inline static const float H_MULT = 0.55f;
    inline static const float V_MULT = 0.0f; // not affected by gravity
 
    Arrow(glm::vec3 corner, glm::vec3 facing, Direction dir):
        Projectile(corner, facing, glm::vec3(0.0f, 0.0f, 0.0f), ModelType::Arrow, ServerSFX::ArrowImpact,
            Options(false, DAMAGE, H_MULT, V_MULT, false, 0.0f, 0, {})), dir(dir)
    {
        const float clear_model_nudge = 1.5f;
        switch (dir) {
            case Direction::LEFT:
                std::swap(this->physics.shared.dimensions.x, this->physics.shared.dimensions.z);
                this->physics.shared.facing = glm::vec3(0.0f, 0.0f, -1.0f);
                this->physics.shared.corner.x -= clear_model_nudge;
                break;
            case Direction::RIGHT:
                std::swap(this->physics.shared.dimensions.x, this->physics.shared.dimensions.z);
                this->physics.shared.facing = glm::vec3(0.0f, 0.0f, 1.0f);
                // right doesn't need nudge for some reason
                // this->physics.shared.corner.x += clear_model_nudge;
                break;
            case Direction::UP:
                this->physics.shared.facing = glm::vec3(1.0f, 0.0f, 0.0f);
                this->physics.shared.corner.z -= (2.0f * clear_model_nudge);
                break;
            case Direction::DOWN:
                this->physics.shared.facing = glm::vec3(-1.0f, 0.0f, 0.0f);
                this->physics.shared.corner.z += clear_model_nudge;
                break;
        }
    }
 
    Direction dir;
};
 
class SpellOrb : public Projectile {
public:
    inline static const int DAMAGE = 25;
    inline static const float H_MULT = 0.4;
    inline static const float V_MULT = 0.0;
    inline static const float HOMING_STRENGTH = 0.1f;
    
    SpellType sType;
 
    SpellOrb(glm::vec3 corner, glm::vec3 facing, SpellType type) :
        Projectile(corner, facing, glm::vec3(0.4f, 0.4f, 0.4f), ModelType::SpellOrb, ServerSFX::FireballImpact,
            Options(true, DAMAGE, H_MULT, V_MULT, false, 0.0f, 0, {}))
    {
        this->sType = type;
    }
};