feely_pona/feely_pona_game.cpp

#if defined(__clang__)
#pragma once
#include "playground_unity.h"
#endif

static bool operator==(FP_GameEntityHandle const &lhs, FP_GameEntityHandle const &rhs)
{
    bool result = lhs.id == rhs.id;
    return result;
}

static bool operator!=(FP_GameEntityHandle const &lhs, FP_GameEntityHandle const &rhs)
{
    bool result = !(lhs == rhs);
    return result;
}

static Dqn_M2x3 FP_Game_CameraModelViewM2x3(FP_GameCamera camera, TELY_Platform *platform)
{
    Dqn_M2x3 result = Dqn_M2x3_Identity();
    if (platform) {
        Dqn_V2 rotate_origin = camera.world_pos - (Dqn_V2_InitV2I(platform->core.window_size) * .5f);
        result               = Dqn_M2x3_Mul(result, Dqn_M2x3_Translate(rotate_origin));
        result               = Dqn_M2x3_Mul(result, Dqn_M2x3_Rotate(camera.rotate_rads));
        result               = Dqn_M2x3_Mul(result, Dqn_M2x3_Scale(camera.scale));
        result               = Dqn_M2x3_Mul(result, Dqn_M2x3_Translate(-rotate_origin + camera.world_pos));
    }
    return result;
}

static FP_GameEntity *FP_Game_GetEntity(FP_Game *game, FP_GameEntityHandle handle)
{
    FP_GameEntity *result = nullptr;
    if (!game)
        return result;

    result                     = game->entities.data;
    uint64_t index_from_handle = handle.id & FP_GAME_ENTITY_HANDLE_INDEX_MASK;
    if (index_from_handle >= game->entities.size)
        return result;

    FP_GameEntity *candidate = game->entities.data + index_from_handle;
    if (candidate->handle == handle)
        result = candidate;
    return result;
}

static bool FP_Game_DFSPreOrderWalkEntityTree(FP_Game *game, FP_GameEntityIterator *it, FP_GameEntity *root)
{
    if (!game || !it || !root)
        return false;

    it->last_visited = it->entity;
    if (it->init) {
        it->iteration_count++;
    } else {
        it->init               = true;
        it->entity             = root;
        it->entity_parent      = it->entity->parent;
        it->entity_next        = it->entity->next;
        it->entity_first_child = it->entity->first_child;
    }

    if (it->entity_first_child) {
        it->entity             = it->entity_first_child;
        it->entity_parent      = it->entity->parent;
        it->entity_next        = it->entity->next;
        it->entity_first_child = it->entity->first_child;
    } else {
        while (it->entity->handle != root->handle) {
            if (it->entity_next) {
                it->entity             = it->entity_next;
                it->entity_parent      = it->entity->parent;
                it->entity_next        = it->entity->next;
                it->entity_first_child = it->entity->first_child;
                break;
            } else {
                if (!it->entity_parent)
                    break;
                it->entity             = it->entity_parent;
                it->entity_parent      = it->entity->parent;
                it->entity_next        = it->entity->next;
                it->entity_first_child = it->entity->first_child;
            }
        }
    }

    return it->entity->handle != root->handle;
}

static bool FP_Game_DFSPostOrderWalkEntityTree(FP_Game *game, FP_GameEntityIterator *it, FP_GameEntity *root)
{
    if (!game || !it || !root)
        return false;

    bool ascending_tree = it->entity ? (it->last_visited == it->entity->last_child) : false;
    it->last_visited    = it->entity;

    if (it->init) {
        it->iteration_count++;
    } else {
        it->init               = true;
        it->entity             = root;
        it->entity_parent      = it->entity->parent;
        it->entity_next        = it->entity->next;
        it->entity_first_child = it->entity->first_child;
    }

    // NOTE: Descend to deepest leaf node
    if (it->entity_first_child && !ascending_tree) {
        while (it->entity_first_child) {
            it->entity             = it->entity_first_child;
            it->entity_parent      = it->entity->parent;
            it->entity_next        = it->entity->next;
            it->entity_first_child = it->entity->first_child;
        }
    } else {
        // NOTE: We are at the leaf node, try going across
        if (it->entity != root && it->entity_next) {
            it->entity             = it->entity_next;
            it->entity_parent      = it->entity->parent;
            it->entity_next        = it->entity->next;
            it->entity_first_child = it->entity->first_child;
            ascending_tree         = false;
        }

        // NOTE: Try descend again
        if (it->entity_first_child && !ascending_tree) {
            while (it->entity_first_child) {
                it->entity             = it->entity_first_child;
                it->entity_parent      = it->entity->parent;
                it->entity_next        = it->entity->next;
                it->entity_first_child = it->entity->first_child;
            }
        }

        // NOTE: If we could not move further across or down then we've
        // exhausted the tree, start moving up.
        if (it->last_visited == it->entity) {
            it->entity             = it->entity_parent;
            it->entity_parent      = it->entity->parent;
            it->entity_next        = it->entity->next;
            it->entity_first_child = it->entity->first_child;
        }
    }

    return it->entity->handle != root->handle;
}


// NOTE: Parent entity
static void FP_Game_PushParentEntity(FP_Game *game, FP_GameEntityHandle handle)
{
    DQN_ASSERTF(game->parent_entity_stack.size >= 1, "Sentinel/nil entity has not been assigned as the 0th slot yet");
    if (game)
        Dqn_FArray_Add(&game->parent_entity_stack, handle);
}

static void FP_Game_PopParentEntity(FP_Game *game)
{
    // NOTE: 0th slot is reserved for the nil entity
    if (game && game->parent_entity_stack.size > 1)
        Dqn_FArray_PopBack(&game->parent_entity_stack, 1);
}

static FP_GameEntityHandle FP_Game_ActiveParentEntity(FP_Game const *game)
{
    FP_GameEntityHandle result = {};
    if (!game || !game->parent_entity_stack.size)
        return result;
    result = game->parent_entity_stack.data[game->parent_entity_stack.size - 1];
    return result;
}

static FP_GameEntity *FP_Game_ActiveParentEntityPointer(FP_Game const *game)
{
    FP_GameEntityHandle handle = FP_Game_ActiveParentEntity(game);
    FP_GameEntity *result      = FP_Game_GetEntity(DQN_CAST(FP_Game *)game, handle);
    return result;
}

static FP_GameEntity *FP_Game_MakeEntityPointerFV(FP_Game *game, DQN_FMT_STRING_ANNOTATE char const *fmt, va_list args)
{
    FP_GameEntity *result = nullptr;
    if (!game)
        return result;

    DQN_ASSERTF(game->entities.size > 0, "Sentinel/nil entity has not been initialised yet");
    DQN_ASSERTF(game->root_entity, "Sentinel/nil entity has not been assigned yet");

    result = game->root_entity; // TODO(doyle): Root entity or ... the nil entity?
    if (game->entity_free_list) {
        result                 = game->entity_free_list;
        game->entity_free_list = game->entity_free_list->next;
        result->next           = nullptr;
    } else {
        if (game->entities.size >= (FP_GAME_ENTITY_HANDLE_INDEX_MAX + 1))
            return result;

        result = Dqn_VArray_Make(&game->entities, Dqn_ZeroMem_Yes);
        if (!result)
            return result;
        result->handle.id = (game->entities.size - 1) & FP_GAME_ENTITY_HANDLE_INDEX_MASK;
    }

    result->size_scale      = Dqn_V2_InitNx1(1);
    result->parent          = FP_Game_ActiveParentEntityPointer(game);
    result->name            = TELY_ChunkPool_AllocFmtFV(game->chunk_pool, fmt, args);
    result->waypoints       = TELY_ChunkPool_New(game->chunk_pool, FP_GameWaypoint);
    result->waypoints->next = result->waypoints;
    result->waypoints->prev = result->waypoints;

    // NOTE: Attach entity as a child to the parent
    FP_GameEntity *parent = result->parent;
    if (parent->first_child)
        parent->last_child->next = result;
    else
        parent->first_child = result;
    result->prev       = parent->last_child;
    parent->last_child = result;

    DQN_ASSERT(!result->next);
    DQN_ASSERT(result->handle.id);
    DQN_ASSERT(result->parent->handle == game->parent_entity_stack.data[game->parent_entity_stack.size - 1]);
    return result;
}

static FP_GameEntity *FP_Game_MakeEntityPointerF(FP_Game *game, DQN_FMT_STRING_ANNOTATE char const *fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    FP_GameEntity *result = FP_Game_MakeEntityPointerFV(game, fmt, args);
    va_end(args);
    return result;
}

static FP_GameEntityHandle FP_Game_MakeEntityF(FP_Game *game, DQN_FMT_STRING_ANNOTATE char const *fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    FP_GameEntity *entity = FP_Game_MakeEntityPointerF(game, fmt, args);
    va_end(args);

    FP_GameEntityHandle result = {};
    if (entity)
        result = entity->handle;
    return result;
}

static bool FP_Game_IsNilEntity(FP_GameEntity *entity)
{
    bool result = entity ? ((entity->handle.id & FP_GAME_ENTITY_HANDLE_INDEX_MASK) == 0) : true;
    return result;
}

static void FP_Game_DetachEntityIntoFreeList(FP_Game *game, FP_GameEntityHandle handle)
{
    FP_GameEntity *entity = FP_Game_GetEntity(game, handle);
    if (FP_Game_IsNilEntity(entity))
        return;

    // NOTE: Entities in the entity tree always have a parent (except for the 
    // nil/root entity). If an entity is passed in to this function and there's
    // no parent, it's most likely you passed in an entity already in the free
    // list (in which case only the next pointer will be set). This is most
    // likely a mistake so we guard against it here.
    if (!DQN_CHECK(entity->parent))
        return;

    uint64_t const entity_index_from_handle = entity->handle.id & FP_GAME_ENTITY_HANDLE_INDEX_MASK;
    DQN_ASSERT(entity_index_from_handle < game->entities.size);

    uint64_t const entity_generation_raw    = entity->handle.id & FP_GAME_ENTITY_HANDLE_GENERATION_MASK;
    uint64_t const entity_generation        = entity_generation_raw >> FP_GAME_ENTITY_HANDLE_GENERATION_RSHIFT;
    uint64_t const new_entity_generation    = entity_generation + 1;

    // NOTE: De-attach entity from adjacent children
    if (entity->prev)
        entity->prev->next = entity->next;

    if (entity->next)
        entity->next->prev = entity->prev;

    // NOTE: De-attach from parent
    FP_GameEntity *parent = entity->parent;
    if (parent->first_child == entity)
        parent->first_child = entity->next;

    if (parent->last_child == entity)
        parent->last_child = entity->prev;

    if (entity->name.size)
        TELY_ChunkPool_Dealloc(game->chunk_pool, entity->name.data);

    if (new_entity_generation > entity_generation) {
        // NOTE: Update the incremented handle disassociating all prior handles
        // to this entity which would reference older generation values
        *entity           = {};
        entity->handle.id = entity_index_from_handle | (new_entity_generation << FP_GAME_ENTITY_HANDLE_GENERATION_RSHIFT);

        // NOTE: Attach entity to the free list
        entity->next           = game->entity_free_list;
        entity->prev           = nullptr;
        game->entity_free_list = entity;
    } else {
        // NOTE: We've cycled through all possible generations for this handle
        // We will not increment it and freeze it so it is no longer allocated
        // out. This prevents code that is still holding onto *really* old
        // handles
    }
}

static void FP_Game_DeleteEntity(FP_Game *game, FP_GameEntityHandle handle)
{
    uint64_t index_from_handle = handle.id & FP_GAME_ENTITY_HANDLE_INDEX_MASK;
    if (!game || !DQN_CHECK(index_from_handle < game->entities.size))
        return;

    FP_GameEntity *root = game->entities.data + index_from_handle;
    if (root->handle != handle)
        return;

    // NOTE: The iterator snaps a copy of all the internal n-ary tree pointers
    // so as we delete we do not accidentally invalidate any of the pointers.
    for (FP_GameEntityIterator it = {}; FP_Game_DFSPostOrderWalkEntityTree(game, &it, root); ) {
        DQN_ASSERT(it.entity != root);
        FP_GameEntity *entity = it.entity;
        FP_Game_DetachEntityIntoFreeList(game, entity->handle);
    }

    FP_Game_DetachEntityIntoFreeList(game, root->handle);
}

static Dqn_V2 FP_Game_CalcEntityWorldPos(FP_Game const *game, FP_GameEntityHandle handle)
{
    Dqn_V2 result = {};
    if (!game)
        return result;

    for (FP_GameEntity const *entity = FP_Game_GetEntity(DQN_CAST(FP_Game *) game, handle);
         entity != game->root_entity;
         entity = entity->parent) {
        result += entity->local_pos;
    }
    return result;
}

static Dqn_Rect FP_Game_CalcEntityLocalHitBox(FP_Game const *game, FP_GameEntityHandle handle)
{
    FP_GameEntity *entity  = FP_Game_GetEntity(DQN_CAST(FP_Game *)game, handle);
    Dqn_V2 half_hit_box_size = entity->local_hit_box_size * .5f;
    Dqn_Rect result          = Dqn_Rect_InitV2x2(entity->local_hit_box_offset - half_hit_box_size, entity->local_hit_box_size);
    return result;
}

static Dqn_Rect FP_Game_CalcEntityWorldHitBox(FP_Game const *game, FP_GameEntityHandle handle)
{
    FP_GameEntity *entity          = FP_Game_GetEntity(DQN_CAST(FP_Game *) game, handle);
    Dqn_V2           world_pos     = FP_Game_CalcEntityWorldPos(game, handle);
    Dqn_Rect         local_hit_box = FP_Game_CalcEntityLocalHitBox(game, entity->handle);
    Dqn_Rect         result        = Dqn_Rect_InitV2x2(world_pos + local_hit_box.pos, local_hit_box.size);
    return result;
}

static Dqn_Rect FP_Game_CalcEntityAttackWorldHitBox(FP_Game const *game, FP_GameEntityHandle handle)
{
    FP_GameEntity *entity    = FP_Game_GetEntity(DQN_CAST(FP_Game *) game, handle);
    Dqn_V2           world_pos = FP_Game_CalcEntityWorldPos(game, handle);
    Dqn_V2 half_hit_box_size   = entity->attack_box_size * .5f;
    Dqn_Rect result            = Dqn_Rect_InitV2x2(world_pos + entity->attack_box_offset - half_hit_box_size, entity->attack_box_size);
    return result;
}

static Dqn_Rect FP_Game_CalcEntityArrayWorldBoundingBox(FP_Game const *game, FP_GameEntityHandle const *handles, Dqn_usize count)
{
    Dqn_Rect result = {};
    if (!game || !handles)
        return result;

    DQN_FOR_UINDEX(index, count) {
        FP_GameEntityHandle  handle = handles[index];
        FP_GameEntity const *entity = FP_Game_GetEntity(DQN_CAST(FP_Game *) game, handle);
        Dqn_Rect               bbox   = FP_Game_CalcEntityLocalHitBox(game, entity->handle);
        for (FP_GameShape const &shape_ : entity->shapes) {
            FP_GameShape const *shape = &shape_;
            switch (shape->type) {
                case FP_GameShapeType_None: {
                } break;

                case FP_GameShapeType_Circle: {
                    Dqn_Rect rect =
                        Dqn_Rect_InitV2x2(shape->p1 - shape->circle_radius, Dqn_V2_InitNx1(shape->circle_radius * 2.f));
                    bbox = Dqn_Rect_Union(bbox, rect);
                } break;

                case FP_GameShapeType_Rect: /*FALLTHRU*/
                case FP_GameShapeType_Line: {
                    Dqn_V2   min   = Dqn_V2_Min(shape->p1, shape->p2);
                    Dqn_V2   max   = Dqn_V2_Max(shape->p1, shape->p2);
                    Dqn_Rect rect  = Dqn_Rect_InitV2x2(min, max - min);

                    if (shape->type == FP_GameShapeType_Rect)
                        rect.pos -= rect.size * .5f;

                    bbox = Dqn_Rect_Union(bbox, rect);
                } break;
            }
        }
        bbox.pos += FP_Game_CalcEntityWorldPos(game, entity->handle);

        if (index)
            result = Dqn_Rect_Union(result, bbox);
        else
            result = bbox;
    }
    return result;
}

static Dqn_Rect FP_Game_CalcEntityWorldBoundingBox(FP_Game *game, FP_GameEntityHandle handle)
{
    Dqn_Rect result = FP_Game_CalcEntityArrayWorldBoundingBox(game, &handle, 1);
    return result;
}

// Transition the action into the desire state and set the flag to indicate it
// has just transitioned
static void FP_Game_EntityActionSetState(FP_GameEntityAction *action, FP_GameEntityState state)
{
    if (!action)
        return;
    action->state  = state;
    action->flags |= FP_GameEntityActionFlag_StateTransition;
}

// Reset the timers and animation for the current action and set the duration
// for the new action.
static void FP_Game_EntityActionReset(FP_GameEntityAction *action, Dqn_f32 new_action_duration, TELY_AssetSpriteAnimation *anim)
{
    if (!action)
        return;
    action->anim      = anim;
    action->timer_s   = 0.f;
    action->end_at_s  = new_action_duration;
    action->flags     = 0;
}

static bool FP_Game_EntityActionHasFailed(FP_GameEntityAction const *action)
{
    bool result = action ? action->flags & FP_GameEntityActionFlag_Failed : true;
    return result;
}