HATPC/scenes/water_flow.c

#include "water_flow.h"
#include "sc/queue/sc_queue.h"
#include <stdio.h>
Entity_t* create_water_runner(EntityManager_t* ent_manager, int32_t width, int32_t height, int32_t start_tile)
{
    Entity_t* p_filler = add_entity(ent_manager, DYNMEM_ENT_TAG);
    if (p_filler == NULL) return NULL;
    CWaterRunner_t* p_crunner = add_component(p_filler, CWATERRUNNER_T);
    if (p_crunner == NULL)
    {
        remove_entity(ent_manager, p_filler->m_id);
        return NULL;
    }
    int32_t total = width * height;
    p_crunner->bfs_tilemap.tilemap = calloc(total, sizeof(BFSTile_t));
    if (p_crunner->bfs_tilemap.tilemap == NULL)
    {
        remove_entity(ent_manager, p_filler->m_id);
        return NULL;
    }
    p_crunner->bfs_tilemap.width = width;
    p_crunner->bfs_tilemap.height = height;
    p_crunner->bfs_tilemap.len = total;
    p_crunner->movement_delay = 5;

    sc_queue_init(&p_crunner->bfs_queue);
    p_crunner->visited = calloc(total, sizeof(bool));

    p_crunner->current_tile = start_tile;
    p_crunner->start_height = start_tile / width;
    p_crunner->target_tile = total;

    CTransform_t* p_ct = add_component(p_filler, CTRANSFORM_COMP_T);
    p_ct->movement_mode = KINEMATIC_MOVEMENT;
    add_component(p_filler, CTILECOORD_COMP_T);
    return p_filler;
}

void free_water_runner(Entity_t* ent, EntityManager_t* ent_manager)
{
    CWaterRunner_t* p_crunner = get_component(ent, CWATERRUNNER_T);
    free(p_crunner->bfs_tilemap.tilemap);
    free(p_crunner->visited);
    sc_queue_term(&p_crunner->bfs_queue);
    remove_entity(ent_manager, ent->m_id);
}

static void runner_BFS(const TileGrid_t* tilemap, CWaterRunner_t* p_crunner, int32_t* lowest_tile)
{
    while (!sc_queue_empty(&p_crunner->bfs_queue))
    {
        unsigned int curr_idx = sc_queue_peek_first(&p_crunner->bfs_queue);
        sc_queue_del_first(&p_crunner->bfs_queue);

        unsigned int curr_height = curr_idx / p_crunner->bfs_tilemap.width;
        unsigned int curr_low = *lowest_tile / p_crunner->bfs_tilemap.width;

        // Possible optimisation to avoid repeated BFS, dunno how possible

        bool to_go[4] = {false, false, false, false};
        Tile_t* curr_tile = tilemap->tiles + curr_idx;

        unsigned int next = curr_idx + p_crunner->bfs_tilemap.width;
        Tile_t* next_tile = tilemap->tiles + next;

        if (next < p_crunner->bfs_tilemap.len)
        {
            if (
                curr_height > curr_low
                && curr_tile->water_level < tilemap->max_water_level
            )
            {
                *lowest_tile = curr_idx;
            }

            to_go[0] = next_tile->solid != SOLID;

            if (
                next_tile->solid == SOLID
                || next_tile->water_level == tilemap->max_water_level
                || curr_tile->water_level == tilemap->max_water_level
            )
            {
                if (curr_idx % p_crunner->bfs_tilemap.width != 0)
                {
                    next = curr_idx - 1;
                    next_tile = tilemap->tiles + next;
                    to_go[1] = next_tile->solid != SOLID;
                }
                next = curr_idx + 1;
                if (next % p_crunner->bfs_tilemap.width != 0)
                {
                    next_tile = tilemap->tiles + next;
                    to_go[2] = next_tile->solid != SOLID;
                }
            }
        }

        if (curr_tile->water_level == tilemap->max_water_level)
        {
            next = curr_idx - p_crunner->bfs_tilemap.width;
            if (next >= 0 && next / p_crunner->bfs_tilemap.width >= p_crunner->start_height)
            {
                next_tile = tilemap->tiles + next;
                to_go[3] = next_tile->solid != SOLID;
            }
        }

        const int8_t offsets[4] = {p_crunner->bfs_tilemap.width, -1, 1, -p_crunner->bfs_tilemap.width};
        for (uint8_t i = 0; i < 4; ++i)
        {
            next = curr_idx + offsets[i];
            if (to_go[i] && !p_crunner->visited[next])
            {
                sc_queue_add_last(&p_crunner->bfs_queue, next);
                p_crunner->bfs_tilemap.tilemap[next].from = curr_idx;
                p_crunner->visited[next] = true;
                p_crunner->bfs_tilemap.tilemap[next].reachable = true;
            }
        }
    }
}

void update_water_runner_system(Scene_t* scene)
{
    // The core of the water runner is to:
    //  - Reach the lowest possible point in the tilemap
    //  - Scanline fill
    // A runner is given an amount of movement cost
    // Within the movement cost, do the following logic
    // Perform a modified BFS to find the lowest point:
    //  - Solid tiles are not reachable
    //  - If bottom tile is non-solid, that is the only reachable tile,
    //  - If bottom tile is filled with water fully, down+left+right are reachable
    //  - If bottom tile is solid, left+right are reachable
    //  - If bottom tile is OOB, terminate
    // Use a FIFO to deal with this.
    // On DFS completion, find the path to the lowest point. Keep track of this 
    // The DFS should have figured out all reachable tiles, start scanline filling at the lowest point.
    // On completion, move up update tile reachability by DFS on the current level. (repeat first step)
    //  - No need to recheck already reachable tiles
    //  - If current tile is solid, scan left and right for reachable tile and start from there
    // Repeat scanline fill
    LevelSceneData_t* data = &(CONTAINER_OF(scene, LevelScene_t, scene)->data);
    TileGrid_t tilemap = data->tilemap;

    CWaterRunner_t* p_crunner;
    unsigned int ent_idx;
    sc_map_foreach(&scene->ent_manager.component_map[CWATERRUNNER_T], ent_idx, p_crunner)
    {
        Entity_t* ent = get_entity(&scene->ent_manager, ent_idx);
        if (tilemap.tiles[p_crunner->current_tile].solid == SOLID)
        {
            CTileCoord_t* p_tilecoord = get_component(
                ent, CTILECOORD_COMP_T
            );
            for (size_t i = 0;i < p_tilecoord->n_tiles; ++i)
            {
                // Use previously store tile position
                // Clear from those positions
                unsigned int tile_idx = p_tilecoord->tiles[i];
                sc_map_del_64v(&(tilemap.tiles[tile_idx].entities_set), ent_idx);
            }
            free_water_runner(ent, &scene->ent_manager);
            continue;
        }

        switch (p_crunner->state)
        {
            case BFS_RESET:
                for (size_t i = 0; i < p_crunner->bfs_tilemap.len; ++i)
                {
                    p_crunner->bfs_tilemap.tilemap[i].from = -1;
                    p_crunner->bfs_tilemap.tilemap[i].reachable = false;
                }
                p_crunner->state = BFS_START;
                // Want the fallthough
            case BFS_START:
                memset(p_crunner->visited, 0, p_crunner->bfs_tilemap.len * sizeof(bool));
                int32_t lowest_tile = p_crunner->current_tile;
                p_crunner->visited[p_crunner->current_tile] = true;
                p_crunner->bfs_tilemap.tilemap[p_crunner->current_tile].reachable = true;
                sc_queue_add_last(&p_crunner->bfs_queue, p_crunner->current_tile);
                p_crunner->state = LOWEST_POINT_SEARCH;
                // Want the fallthough
            case LOWEST_POINT_SEARCH:
            {
                runner_BFS(&tilemap, p_crunner, &lowest_tile);
                p_crunner->target_tile = lowest_tile;

                if (p_crunner->target_tile == p_crunner->current_tile)
                {
                    p_crunner->state = SCANLINE_FILL;
                    break;
                }
                // Trace path from lowest_tile
                unsigned int prev_idx = lowest_tile;
                unsigned int curr_idx = p_crunner->bfs_tilemap.tilemap[prev_idx].from;
                while (p_crunner->bfs_tilemap.tilemap[prev_idx].from >= 0)
                {
                    p_crunner->bfs_tilemap.tilemap[curr_idx].to = prev_idx;
                    prev_idx = curr_idx;
                    curr_idx = p_crunner->bfs_tilemap.tilemap[prev_idx].from;
                }
                p_crunner->counter = p_crunner->movement_delay;
                p_crunner->state = LOWEST_POINT_MOVEMENT;
            }
            break;
            case LOWEST_POINT_MOVEMENT:
                p_crunner->counter--;
                if (p_crunner->counter == 0)
                {
                    p_crunner->current_tile = p_crunner->bfs_tilemap.tilemap[p_crunner->current_tile].to;
                    CTransform_t* p_ct = get_component(ent, CTRANSFORM_COMP_T);
                    p_ct->position.x = (p_crunner->current_tile % tilemap.width) * tilemap.tile_size; 
                    p_ct->position.y = (p_crunner->current_tile / tilemap.width) * tilemap.tile_size; 
                    if (p_crunner->current_tile == p_crunner->target_tile)
                    {
                        p_crunner->state = REACHABILITY_SEARCH;
                    }
                    p_crunner->counter = p_crunner->movement_delay;
                }
            break;
            case REACHABILITY_SEARCH:
            {
                unsigned int start_tile =
                    (p_crunner->current_tile / p_crunner->bfs_tilemap.width) * p_crunner->bfs_tilemap.width;

                for (size_t i = 0; i < p_crunner->bfs_tilemap.width; ++i)
                {
                    p_crunner->bfs_tilemap.tilemap[start_tile + i].reachable = false;
                }

                memset(p_crunner->visited, 0, p_crunner->bfs_tilemap.len * sizeof(bool));
                p_crunner->bfs_tilemap.tilemap[p_crunner->current_tile].reachable = true;
                sc_queue_add_last(&p_crunner->bfs_queue, p_crunner->current_tile);
                int32_t lowest_tile = p_crunner->current_tile;
                runner_BFS(&tilemap, p_crunner, &lowest_tile);

                p_crunner->state = SCANLINE_FILL;
            }
            break;
            default:
            break;
        }
    }
}

void init_water_runner_system(void)
{
}