cakefoot/src/Character.hpp

#pragma once

#include <vector>
#include <algorithm>
#include <map>

#include "json/json.hpp"
#include "SDL_mixer.h"

#include "Configuration.hpp"
#include "Switch.hpp"
#include "Selection.hpp"
#include "Sprite.hpp"
#include "Curve.hpp"
#include "Segment.hpp"
#include "Audio.hpp"

class Character
{

private:

    /* Convert pixel size to NDC size. */
    inline static const glm::vec2 size {20.0f / 486.0f};

    /* Keep references to the global configuration and audio data */
    const Configuration& configuration;
    std::map<std::string, sb::audio::Chunk>& audio;

    /* Set at runtime based on the configuration */
    sb::Sprite _sprite;
    std::string _profile;

    /* Physics, movement, and collision */
    float speed {0.0f}, _checkpoint {0.0f};
    int next_point_index {0};
    Box _box {{0.0f, 0.0f}, 2.0f * this->size};
    bool _resting = true;

    /* Walking forward, backward, and not walking animation timer */
    sb::Animation walk;
    
    /*!
     * A JSON object containing the fields: name, speed increment, speed decrement, max speed, increment mod, decrement mod, and
     * animation frames.
     *
     * This will use the profile name set by Character::profile(const std::string&) to get the associated profile in
     * Character::configuration at `character -> profile`.
     * 
     * @return   JSON containing the currently selected profile name along with physics and texture values
     */
    const nlohmann::json& profile() const;

public:

    /* Two SDL mixer channels reserved for walk sound effects */
    inline static const int walk_channel = 0;
    inline static const int reverse_channel = 1;

    /* Create an object which can be switched on and off to move and stop the character. */
    sb::Switch<> accelerating = false;

    /* Where the character is located in NDC. */
    glm::vec3 position;

    /*!
     * @param configuration   reference to the global configuration which is expected to contain profile entries for character physics
     */
    Character(const Configuration& configuration, std::map<std::string, sb::audio::Chunk>& audio);

    /*!
     * Change the character's physics and texture by specifying a profile name. The name refers to a JSON profile stored in an array of
     * profiles in `Character::configuration` at `character -> profile`. The JSON for each profile is expected to contain the following
     * fields: name, speed increment, speed decrement, max speed, increment mod, decrement mod, and animation frames.
     *
     * The character will refer to the given profile when accessing the profile in other calls. No physics values are directly modified
     * by this function. This is done so external changes to the configuration can be registered automatically during runtime.
     *
     * However, the texture will be directly modified because re-reading the texture every frame is too slow. To automate re-reading the
     * texture, insert a hook into the game's update loop that runs this function every time a configuration modification is detected.
     *
     * @param name     String in the name field of the chosen profile in the list of profiles at `character -> profile`
     */
    void profile(const std::string& name);

    /*!
     * Set the size of the hit box as a percentage of the sprite's size.
     *
     * @param size   percentage of sprite size
     */
    void box_size(float size);

    /*!
     * Load the graphics into the GPU. This is only necessary to run if the object was constructed before the GL context was loaded.
     */
    void load();

    /*!
     * @return   reference to the box object enclosing the character in world space
     */
    const Box& box() const;

    /*!
     * @return   reference to the character's sprite object for accessing the character's graphics
     */
    const sb::Sprite& sprite() const;

    /*!
     * @param curve   the curve to reset the beginning position to
     */
    void beginning(const Curve& curve);

    /*!
     * @return   relative point on the curve where the character should spawn
     */
    float checkpoint() const;

    /*!
     * Update the spawn point.
     *
     * @param checkpoint   relative point on the curve where the character should spawn
     */
    void checkpoint(float checkpoint);

    /*!
     * Place character at checkpoint position on the curve.
     *
     * @param curve   curve to spawn on
     */
    void spawn(const Curve& curve);

    /*!
     * @param curve   curve to check against
     * @return        `true` if the character is at the end of the curve, `false` otherwise
     */
    bool at_end(const Curve& curve) const;

    /*!
     * @return   True if the character has just respawned or the level just began
     */
    bool resting() const;

    /*!
     * @return   character's relative position on the given curve
     */
    float relative(const Curve& curve) const;

    /*!
     * Check acceleration state and adjust speed. Move character toward the next point on the curve.
     *
     * @param curve           the curve to update against
     * @param timer           a timer object that is updated once per frame, so that it provides delta time for movement
     * @param muted           flag for preventing the walk sound effect output
     * @param constant_speed  override acceleration processing and set the movement to a constant speed
     */
    void update(const Curve& curve, const sb::Timer& timer, bool muted = false, std::optional<float> constant_speed = std::nullopt);

    /*!
     * Perform GL drawing operations using the character's sprite object.
     *
     * @param curve                    curve which determines how to wrap the character's position to the curve's space
     * @param transformation_uniform   transformation uniform location in the shader program
     * @param view                     view transformation matrix
     * @param projection               projection transformation matrix
     * @param texture_flag_uniform     uniform location in the shader program of the boolean that turns texture drawing on or off
     */
    void draw(const Curve& curve, GLuint transformation_uniform, const glm::mat4& view, const glm::mat4& projection,
              GLuint texture_flag_uniform);
};