unleashed-firmware/applications/plugins/doom/doom.c

#include <furi.h>
#include <gui/gui.h>
#include <input/input.h>
#include <stdlib.h>
#include <math.h>
#include <sys/time.h>
#include "sound.h"
#include "display.h"
#include "compiled/assets_icons.h"
#include "constants.h"
#include "entities.h"
#include "types.h"
#include "level.h"
#include <notification/notification.h>
#include <notification/notification_messages.h>

#define SOUND

// Useful macros
#define swap(a, b)          \
    do {                    \
        typeof(a) temp = a; \
        a = b;              \
        b = temp;           \
    } while(0)
#define sign(a, b) (double)(a > b ? 1 : (b > a ? -1 : 0))
#define pgm_read_byte(addr) (*(const unsigned char*)(addr))

typedef enum {
    EventTypeTick,
    EventTypeKey,
} EventType;

typedef struct {
    EventType type;
    InputEvent input;
} PluginEvent;

typedef struct {
    Player player;
    Entity entity[MAX_ENTITIES];
    StaticEntity static_entity[MAX_STATIC_ENTITIES];
    uint8_t num_entities;
    uint8_t num_static_entities;

    uint8_t scene;
    uint8_t gun_pos;
    double jogging;
    double view_height;
    bool init;

    bool up;
    bool down;
    bool left;
    bool right;
    bool fired;
    bool gun_fired;

    double rot_speed;
    double old_dir_x;
    double old_plane_x;
    NotificationApp* notify;
#ifdef SOUND
    MusicPlayer* music_instance;
    bool intro_sound;
#endif
} PluginState;

static const NotificationSequence sequence_short_sound = {
    &message_note_c5,
    &message_delay_50,
    &message_sound_off,
    NULL,
};
static const NotificationSequence sequence_long_sound = {
    &message_note_c3,
    &message_delay_100,
    &message_sound_off,
    NULL,
};

Coords translateIntoView(Coords* pos, PluginState* const plugin_state);
void updateHud(Canvas* const canvas, PluginState* const plugin_state);
// general

bool invert_screen = false;
uint8_t flash_screen = 0;

// game
// player and entities

uint8_t getBlockAt(const uint8_t level[], uint8_t x, uint8_t y) {
    if(x >= LEVEL_WIDTH || y >= LEVEL_HEIGHT) {
        return E_FLOOR;
    }

    // y is read in inverse order
    return pgm_read_byte(level + (((LEVEL_HEIGHT - 1 - y) * LEVEL_WIDTH + x) / 2)) >>
               (!(x % 2) * 4) // displace part of wanted bits
           & 0b1111; // mask wanted bits
}

// Finds the player in the map
void initializeLevel(const uint8_t level[], PluginState* const plugin_state) {
    for(uint8_t y = LEVEL_HEIGHT - 1; y > 0; y--) {
        for(uint8_t x = 0; x < LEVEL_WIDTH; x++) {
            uint8_t block = getBlockAt(level, x, y);

            if(block == E_PLAYER) {
                plugin_state->player = create_player(x, y);
                return;
            }

            // todo create other static entities
        }
    }
}

bool isSpawned(UID uid, PluginState* const plugin_state) {
    for(uint8_t i = 0; i < plugin_state->num_entities; i++) {
        if(plugin_state->entity[i].uid == uid) return true;
    }

    return false;
}

bool isStatic(UID uid, PluginState* const plugin_state) {
    for(uint8_t i = 0; i < plugin_state->num_static_entities; i++) {
        if(plugin_state->static_entity[i].uid == uid) return true;
    }

    return false;
}

void spawnEntity(uint8_t type, uint8_t x, uint8_t y, PluginState* const plugin_state) {
    // Limit the number of spawned entities
    if(plugin_state->num_entities >= MAX_ENTITIES) {
        return;
    }

    // todo: read static entity status

    switch(type) {
    case E_ENEMY:
        plugin_state->entity[plugin_state->num_entities] = create_enemy(x, y);
        plugin_state->num_entities++;
        break;

    case E_KEY:
        plugin_state->entity[plugin_state->num_entities] = create_key(x, y);
        plugin_state->num_entities++;
        break;

    case E_MEDIKIT:
        plugin_state->entity[plugin_state->num_entities] = create_medikit(x, y);
        plugin_state->num_entities++;
        break;
    }
}

void spawnFireball(double x, double y, PluginState* const plugin_state) {
    // Limit the number of spawned entities
    if(plugin_state->num_entities >= MAX_ENTITIES) {
        return;
    }

    UID uid = create_uid(E_FIREBALL, x, y);
    // Remove if already exists, don't throw anything. Not the best, but shouldn't happen too often
    if(isSpawned(uid, plugin_state)) return;

    // Calculate direction. 32 angles
    int16_t dir =
        FIREBALL_ANGLES + atan2(y - plugin_state->player.pos.y, x - plugin_state->player.pos.x) /
                              (double)PI * FIREBALL_ANGLES;
    if(dir < 0) dir += FIREBALL_ANGLES * 2;
    plugin_state->entity[plugin_state->num_entities] = create_fireball(x, y, dir);
    plugin_state->num_entities++;
}

void removeEntity(UID uid, PluginState* const plugin_state) {
    uint8_t i = 0;
    bool found = false;

    while(i < plugin_state->num_entities) {
        if(!found && plugin_state->entity[i].uid == uid) {
            // todo: doze it
            found = true;
            plugin_state->num_entities--;
        }

        // displace entities
        if(found) {
            plugin_state->entity[i] = plugin_state->entity[i + 1];
        }

        i++;
    }
}

void removeStaticEntity(UID uid, PluginState* const plugin_state) {
    uint8_t i = 0;
    bool found = false;

    while(i < plugin_state->num_static_entities) {
        if(!found && plugin_state->static_entity[i].uid == uid) {
            found = true;
            plugin_state->num_static_entities--;
        }

        // displace entities
        if(found) {
            plugin_state->static_entity[i] = plugin_state->static_entity[i + 1];
        }

        i++;
    }
}

UID detectCollision(
    const uint8_t level[],
    Coords* pos,
    double relative_x,
    double relative_y,
    bool only_walls,
    PluginState* const plugin_state) {
    // Wall collision
    uint8_t round_x = (int)pos->x + (int)relative_x;
    uint8_t round_y = (int)pos->y + (int)relative_y;
    uint8_t block = getBlockAt(level, round_x, round_y);

    if(block == E_WALL) {
        //playSound(hit_wall_snd, HIT_WALL_SND_LEN);
        return create_uid(block, round_x, round_y);
    }

    if(only_walls) {
        return UID_null;
    }

    // Entity collision
    for(uint8_t i = 0; i < plugin_state->num_entities; i++) {
        // Don't collide with itself
        if(&(plugin_state->entity[i].pos) == pos) {
            continue;
        }

        uint8_t type = uid_get_type(plugin_state->entity[i].uid);

        // Only ALIVE enemy collision
        if(type != E_ENEMY || plugin_state->entity[i].state == S_DEAD ||
           plugin_state->entity[i].state == S_HIDDEN) {
            continue;
        }

        Coords new_coords = {
            plugin_state->entity[i].pos.x - relative_x,
            plugin_state->entity[i].pos.y - relative_y};
        uint8_t distance = coords_distance(pos, &new_coords);

        // Check distance and if it's getting closer
        if(distance < ENEMY_COLLIDER_DIST && distance < plugin_state->entity[i].distance) {
            return plugin_state->entity[i].uid;
        }
    }

    return UID_null;
}

// Shoot
void fire(PluginState* const plugin_state) {
    //playSound(shoot_snd, SHOOT_SND_LEN);

    for(uint8_t i = 0; i < plugin_state->num_entities; i++) {
        // Shoot only ALIVE enemies
        if(uid_get_type(plugin_state->entity[i].uid) != E_ENEMY ||
           plugin_state->entity[i].state == S_DEAD || plugin_state->entity[i].state == S_HIDDEN) {
            continue;
        }

        Coords transform = translateIntoView(&(plugin_state->entity[i].pos), plugin_state);
        if(fabs(transform.x) < 20 && transform.y > 0) {
            uint8_t damage = (double)fmin(
                GUN_MAX_DAMAGE,
                GUN_MAX_DAMAGE / (fabs(transform.x) * plugin_state->entity[i].distance) / 5);
            if(damage > 0) {
                plugin_state->entity[i].health = fmax(0, plugin_state->entity[i].health - damage);
                plugin_state->entity[i].state = S_HIT;
                plugin_state->entity[i].timer = 4;
            }
        }
    }
}

UID updatePosition(
    const uint8_t level[],
    Coords* pos,
    double relative_x,
    double relative_y,
    bool only_walls,
    PluginState* const plugin_state) {
    UID collide_x = detectCollision(level, pos, relative_x, 0, only_walls, plugin_state);
    UID collide_y = detectCollision(level, pos, 0, relative_y, only_walls, plugin_state);

    if(!collide_x) pos->x += relative_x;
    if(!collide_y) pos->y += relative_y;

    return collide_x || collide_y || UID_null;
}

void updateEntities(const uint8_t level[], Canvas* const canvas, PluginState* const plugin_state) {
    uint8_t i = 0;
    while(i < plugin_state->num_entities) {
        // update distance
        plugin_state->entity[i].distance =
            coords_distance(&(plugin_state->player.pos), &(plugin_state->entity[i].pos));

        // Run the timer. Works with actual frames.
        // Todo: use delta here. But needs double type and more memory
        if(plugin_state->entity[i].timer > 0) plugin_state->entity[i].timer--;

        // too far away. put it in doze mode
        if(plugin_state->entity[i].distance > MAX_ENTITY_DISTANCE) {
            removeEntity(plugin_state->entity[i].uid, plugin_state);
            // don't increase 'i', since current one has been removed
            continue;
        }

        // bypass render if hidden
        if(plugin_state->entity[i].state == S_HIDDEN) {
            i++;
            continue;
        }

        uint8_t type = uid_get_type(plugin_state->entity[i].uid);

        switch(type) {
        case E_ENEMY: {
            // Enemy "IA"
            if(plugin_state->entity[i].health == 0) {
                if(plugin_state->entity[i].state != S_DEAD) {
                    plugin_state->entity[i].state = S_DEAD;
                    plugin_state->entity[i].timer = 6;
                }
            } else if(plugin_state->entity[i].state == S_HIT) {
                if(plugin_state->entity[i].timer == 0) {
                    // Back to alert state
                    plugin_state->entity[i].state = S_ALERT;
                    plugin_state->entity[i].timer = 40; // delay next fireball thrown
                }
            } else if(plugin_state->entity[i].state == S_FIRING) {
                if(plugin_state->entity[i].timer == 0) {
                    // Back to alert state
                    plugin_state->entity[i].state = S_ALERT;
                    plugin_state->entity[i].timer = 40; // delay next fireball throwm
                }
            } else {
                // ALERT STATE
                if(plugin_state->entity[i].distance > ENEMY_MELEE_DIST &&
                   plugin_state->entity[i].distance < MAX_ENEMY_VIEW) {
                    if(plugin_state->entity[i].state != S_ALERT) {
                        plugin_state->entity[i].state = S_ALERT;
                        plugin_state->entity[i].timer = 20; // used to throw fireballs
                    } else {
                        if(plugin_state->entity[i].timer == 0) {
                            // Throw a fireball
                            spawnFireball(
                                plugin_state->entity[i].pos.x,
                                plugin_state->entity[i].pos.y,
                                plugin_state);
                            plugin_state->entity[i].state = S_FIRING;
                            plugin_state->entity[i].timer = 6;
                        } else {
                            // move towards to the player.
                            updatePosition(
                                level,
                                &(plugin_state->entity[i].pos),
                                sign(plugin_state->player.pos.x, plugin_state->entity[i].pos.x) *
                                    (double)ENEMY_SPEED * 1, // NOT SURE (delta)
                                sign(plugin_state->player.pos.y, plugin_state->entity[i].pos.y) *
                                    (double)ENEMY_SPEED * 1, // NOT SURE (delta)
                                true,
                                plugin_state);
                        }
                    }
                } else if(plugin_state->entity[i].distance <= ENEMY_MELEE_DIST) {
                    if(plugin_state->entity[i].state != S_MELEE) {
                        // Preparing the melee attack
                        plugin_state->entity[i].state = S_MELEE;
                        plugin_state->entity[i].timer = 10;
                    } else if(plugin_state->entity[i].timer == 0) {
                        // Melee attack
                        plugin_state->player.health =
                            fmax(0, plugin_state->player.health - ENEMY_MELEE_DAMAGE);
                        plugin_state->entity[i].timer = 14;
                        flash_screen = 1;
                        updateHud(canvas, plugin_state);
                    }
                } else {
                    // stand
                    plugin_state->entity[i].state = S_STAND;
                }
            }
            break;
        }

        case E_FIREBALL: {
            if(plugin_state->entity[i].distance < FIREBALL_COLLIDER_DIST) {
                // Hit the player and disappear
                plugin_state->player.health =
                    fmax(0, plugin_state->player.health - ENEMY_FIREBALL_DAMAGE);
                flash_screen = 1;
                updateHud(canvas, plugin_state);
                removeEntity(plugin_state->entity[i].uid, plugin_state);
                continue; // continue in the loop
            } else {
                // Move. Only collide with walls.
                // Note: using health to store the angle of the movement
                UID collided = updatePosition(
                    level,
                    &(plugin_state->entity[i].pos),
                    cos((double)plugin_state->entity[i].health / FIREBALL_ANGLES * (double)PI) *
                        (double)FIREBALL_SPEED,
                    sin((double)plugin_state->entity[i].health / FIREBALL_ANGLES * (double)PI) *
                        (double)FIREBALL_SPEED,
                    true,
                    plugin_state);

                if(collided) {
                    removeEntity(plugin_state->entity[i].uid, plugin_state);
                    continue; // continue in the entity check loop
                }
            }
            break;
        }

        case E_MEDIKIT: {
            if(plugin_state->entity[i].distance < ITEM_COLLIDER_DIST) {
                // pickup
                notification_message(plugin_state->notify, &sequence_long_sound);
                //playSound(medkit_snd, MEDKIT_SND_LEN);
                plugin_state->entity[i].state = S_HIDDEN;
                plugin_state->player.health = fmin(100, plugin_state->player.health + 50);
                updateHud(canvas, plugin_state);
                flash_screen = 1;
            }
            break;
        }

        case E_KEY: {
            if(plugin_state->entity[i].distance < ITEM_COLLIDER_DIST) {
                // pickup
                notification_message(plugin_state->notify, &sequence_long_sound);
                //playSound(get_key_snd, GET_KEY_SND_LEN);
                plugin_state->entity[i].state = S_HIDDEN;
                plugin_state->player.keys++;
                updateHud(canvas, plugin_state);
                flash_screen = 1;
            }
            break;
        }
        }

        i++;
    }
}

// The map raycaster. Based on https://lodev.org/cgtutor/raycasting.html
void renderMap(
    const uint8_t level[],
    double view_height,
    Canvas* const canvas,
    PluginState* const plugin_state) {
    UID last_uid = 0; // NOT SURE ?

    for(uint8_t x = 0; x < SCREEN_WIDTH; x += RES_DIVIDER) {
        double camera_x = 2 * (double)x / SCREEN_WIDTH - 1;
        double ray_x = plugin_state->player.dir.x + plugin_state->player.plane.x * camera_x;
        double ray_y = plugin_state->player.dir.y + plugin_state->player.plane.y * camera_x;
        uint8_t map_x = (uint8_t)plugin_state->player.pos.x;
        uint8_t map_y = (uint8_t)plugin_state->player.pos.y;
        Coords map_coords = {plugin_state->player.pos.x, plugin_state->player.pos.y};
        double delta_x = fabs(1 / ray_x);
        double delta_y = fabs(1 / ray_y);

        int8_t step_x;
        int8_t step_y;
        double side_x;
        double side_y;

        if(ray_x < 0) {
            step_x = -1;
            side_x = (plugin_state->player.pos.x - map_x) * delta_x;
        } else {
            step_x = 1;
            side_x = (map_x + (double)1.0 - plugin_state->player.pos.x) * delta_x;
        }

        if(ray_y < 0) {
            step_y = -1;
            side_y = (plugin_state->player.pos.y - map_y) * delta_y;
        } else {
            step_y = 1;
            side_y = (map_y + (double)1.0 - plugin_state->player.pos.y) * delta_y;
        }

        // Wall detection
        uint8_t depth = 0;
        bool hit = 0;
        bool side;
        while(!hit && depth < MAX_RENDER_DEPTH) {
            if(side_x < side_y) {
                side_x += delta_x;
                map_x += step_x;
                side = 0;
            } else {
                side_y += delta_y;
                map_y += step_y;
                side = 1;
            }

            uint8_t block = getBlockAt(level, map_x, map_y);

            if(block == E_WALL) {
                hit = 1;
            } else {
                // Spawning entities here, as soon they are visible for the
                // player. Not the best place, but would be a very performance
                // cost scan for them in another loop
                if(block == E_ENEMY || (block & 0b00001000) /* all collectable items */) {
                    // Check that it's close to the player
                    if(coords_distance(&(plugin_state->player.pos), &map_coords) <
                       MAX_ENTITY_DISTANCE) {
                        UID uid = create_uid(block, map_x, map_y);
                        if(last_uid != uid && !isSpawned(uid, plugin_state)) {
                            spawnEntity(block, map_x, map_y, plugin_state);
                            last_uid = uid;
                        }
                    }
                }
            }

            depth++;
        }

        if(hit) {
            double distance;

            if(side == 0) {
                distance =
                    fmax(1, (map_x - plugin_state->player.pos.x + (1 - step_x) / 2) / ray_x);
            } else {
                distance =
                    fmax(1, (map_y - plugin_state->player.pos.y + (1 - step_y) / 2) / ray_y);
            }

            // store zbuffer value for the column
            zbuffer[x / Z_RES_DIVIDER] = fmin(distance * DISTANCE_MULTIPLIER, 255);

            // rendered line height
            uint8_t line_height = RENDER_HEIGHT / distance;

            drawVLine(
                x,
                view_height / distance - line_height / 2 + RENDER_HEIGHT / 2,
                view_height / distance + line_height / 2 + RENDER_HEIGHT / 2,
                GRADIENT_COUNT - (int)distance / MAX_RENDER_DEPTH * GRADIENT_COUNT - side * 2,
                canvas);
        }
    }
}

// Sort entities from far to close
uint8_t sortEntities(PluginState* const plugin_state) {
    uint8_t gap = plugin_state->num_entities;
    bool swapped = false;
    while(gap > 1 || swapped) {
        //shrink factor 1.3
        gap = (gap * 10) / 13;
        if(gap == 9 || gap == 10) gap = 11;
        if(gap < 1) gap = 1;
        swapped = false;
        for(uint8_t i = 0; i < plugin_state->num_entities - gap; i++) {
            uint8_t j = i + gap;
            if(plugin_state->entity[i].distance < plugin_state->entity[j].distance) {
                swap(plugin_state->entity[i], plugin_state->entity[j]);
                swapped = true;
            }
        }
    }
    return swapped;
}

Coords translateIntoView(Coords* pos, PluginState* const plugin_state) {
    //translate sprite position to relative to camera
    double sprite_x = pos->x - plugin_state->player.pos.x;
    double sprite_y = pos->y - plugin_state->player.pos.y;

    //required for correct matrix multiplication
    double inv_det =
        ((double)1.0 /
         ((double)plugin_state->player.plane.x * (double)plugin_state->player.dir.y -
          (double)plugin_state->player.dir.x * (double)plugin_state->player.plane.y));
    double transform_x =
        inv_det * (plugin_state->player.dir.y * sprite_x - plugin_state->player.dir.x * sprite_y);
    double transform_y = inv_det * (-plugin_state->player.plane.y * sprite_x +
                                    plugin_state->player.plane.x * sprite_y); // Z in screen
    Coords res = {transform_x, transform_y};
    return res;
}

void renderEntities(double view_height, Canvas* const canvas, PluginState* const plugin_state) {
    sortEntities(plugin_state);

    for(uint8_t i = 0; i < plugin_state->num_entities; i++) {
        if(plugin_state->entity[i].state == S_HIDDEN) continue;

        Coords transform = translateIntoView(&(plugin_state->entity[i].pos), plugin_state);

        // don´t render if behind the player or too far away
        if(transform.y <= (double)0.1 || transform.y > MAX_SPRITE_DEPTH) {
            continue;
        }

        int16_t sprite_screen_x = HALF_WIDTH * ((double)1.0 + transform.x / transform.y);
        int8_t sprite_screen_y = RENDER_HEIGHT / 2 + view_height / transform.y;
        uint8_t type = uid_get_type(plugin_state->entity[i].uid);

        // don´t try to render if outside of screen
        // doing this pre-shortcut due int16 -> int8 conversion makes out-of-screen
        // values fit into the screen space
        if(sprite_screen_x < -HALF_WIDTH || sprite_screen_x > SCREEN_WIDTH + HALF_WIDTH) {
            continue;
        }

        switch(type) {
        case E_ENEMY: {
            uint8_t sprite;
            if(plugin_state->entity[i].state == S_ALERT) {
                // walking
                sprite = ((int)furi_get_tick() / 500) % 2;
            } else if(plugin_state->entity[i].state == S_FIRING) {
                // fireball
                sprite = 2;
            } else if(plugin_state->entity[i].state == S_HIT) {
                // hit
                sprite = 3;
            } else if(plugin_state->entity[i].state == S_MELEE) {
                // melee atack
                sprite = plugin_state->entity[i].timer > 10 ? 2 : 1;
            } else if(plugin_state->entity[i].state == S_DEAD) {
                // dying
                sprite = plugin_state->entity[i].timer > 0 ? 3 : 4;
            } else {
                // stand
                sprite = 0;
            }

            drawSprite(
                sprite_screen_x - BMP_IMP_WIDTH * (double).5 / transform.y,
                sprite_screen_y - 8 / transform.y,
                imp_inv,
                imp_mask_inv,
                BMP_IMP_WIDTH,
                BMP_IMP_HEIGHT,
                sprite,
                transform.y,
                canvas);
            break;
        }

        case E_FIREBALL: {
            drawSprite(
                sprite_screen_x - BMP_FIREBALL_WIDTH / 2 / transform.y,
                sprite_screen_y - BMP_FIREBALL_HEIGHT / 2 / transform.y,
                fireball,
                fireball_mask,
                BMP_FIREBALL_WIDTH,
                BMP_FIREBALL_HEIGHT,
                0,
                transform.y,
                canvas);
            break;
        }

        case E_MEDIKIT: {
            drawSprite(
                sprite_screen_x - BMP_ITEMS_WIDTH / 2 / transform.y,
                sprite_screen_y + 5 / transform.y,
                item,
                item_mask,
                BMP_ITEMS_WIDTH,
                BMP_ITEMS_HEIGHT,
                0,
                transform.y,
                canvas);
            break;
        }

        case E_KEY: {
            drawSprite(
                sprite_screen_x - BMP_ITEMS_WIDTH / 2 / transform.y,
                sprite_screen_y + 5 / transform.y,
                item,
                item_mask,
                BMP_ITEMS_WIDTH,
                BMP_ITEMS_HEIGHT,
                1,
                transform.y,
                canvas);
            break;
        }
        }
    }
}

void renderGun(uint8_t gun_pos, double amount_jogging, Canvas* const canvas) {
    // jogging
    char x = 48 + sin((double)furi_get_tick() * (double)JOGGING_SPEED) * 10 * amount_jogging;
    char y = RENDER_HEIGHT - gun_pos +
             fabs(cos((double)furi_get_tick() * (double)JOGGING_SPEED)) * 8 * amount_jogging;

    if(gun_pos > GUN_SHOT_POS - 2) {
        // Gun fire
        drawBitmap(x + 6, y - 11, &I_fire_inv, BMP_FIRE_WIDTH, BMP_FIRE_HEIGHT, 1, canvas);
    }

    // Don't draw over the hud!
    uint8_t clip_height = fmax(0, fmin(y + BMP_GUN_HEIGHT, RENDER_HEIGHT) - y);

    // Draw the gun (black mask + actual sprite).
    drawBitmap(x, y, &I_gun_mask_inv, BMP_GUN_WIDTH, clip_height, 0, canvas);
    drawBitmap(x, y, &I_gun_inv, BMP_GUN_WIDTH, clip_height, 1, canvas);
    //drawGun(x,y,gun_mask, BMP_GUN_WIDTH, clip_height, 0, canvas);
    //drawGun(x,y,gun, BMP_GUN_WIDTH, clip_height, 1, canvas);
}

// Only needed first time
void renderHud(Canvas* const canvas, PluginState* plugin_state) {
    drawTextSpace(2, 58, "{}", 0, canvas); // Health symbol
    drawTextSpace(40, 58, "[]", 0, canvas); // Keys symbol
    updateHud(canvas, plugin_state);
}

// Render values for the HUD
void updateHud(Canvas* const canvas, PluginState* plugin_state) {
    clearRect(12, 58, 15, 6, canvas);
    clearRect(50, 58, 15, 6, canvas);
    drawText(12, 58, plugin_state->player.health, canvas);
    drawText(50, 58, plugin_state->player.keys, canvas);
}

// Debug stats
void renderStats(Canvas* const canvas, PluginState* plugin_state) {
    clearRect(58, 58, 70, 6, canvas);
    drawText(114, 58, (int)getActualFps(), canvas);
    drawText(82, 58, plugin_state->num_entities, canvas);
    // drawText(94, 58, freeMemory());
}

// Intro screen
void loopIntro(Canvas* const canvas) {
    canvas_draw_icon(
        canvas,
        (SCREEN_WIDTH - BMP_LOGO_WIDTH) / 2,
        (SCREEN_HEIGHT - BMP_LOGO_HEIGHT) / 3,
        &I_logo_inv);
    drawTextSpace(SCREEN_WIDTH / 2 - 25, SCREEN_HEIGHT * .8, "PRESS FIRE", 1, canvas);
}

static void render_callback(Canvas* const canvas, void* ctx) {
    PluginState* plugin_state = acquire_mutex((ValueMutex*)ctx, 25);
    if(plugin_state == NULL) {
        return;
    }
    if(plugin_state->init) setupDisplay(canvas);

    canvas_set_font(canvas, FontPrimary);

    switch(plugin_state->scene) {
    case INTRO: {
        loopIntro(canvas);
        break;
    }
    case GAME_PLAY: {
        updateEntities(sto_level_1, canvas, plugin_state);

        renderGun(plugin_state->gun_pos, plugin_state->jogging, canvas);
        renderMap(sto_level_1, plugin_state->view_height, canvas, plugin_state);

        renderEntities(plugin_state->view_height, canvas, plugin_state);

        renderHud(canvas, plugin_state);
        updateHud(canvas, plugin_state);
        renderStats(canvas, plugin_state);
        break;
    }
    }
    release_mutex((ValueMutex*)ctx, plugin_state);
}

static void input_callback(InputEvent* input_event, FuriMessageQueue* event_queue) {
    furi_assert(event_queue);

    PluginEvent event = {.type = EventTypeKey, .input = *input_event};
    furi_message_queue_put(event_queue, &event, 0);
}

static void doom_state_init(PluginState* const plugin_state) {
    plugin_state->notify = furi_record_open(RECORD_NOTIFICATION);
    plugin_state->num_entities = 0;
    plugin_state->num_static_entities = 0;

    plugin_state->scene = INTRO;
    plugin_state->gun_pos = 0;
    plugin_state->view_height = 0;
    plugin_state->init = true;

    plugin_state->up = false;
    plugin_state->down = false;
    plugin_state->left = false;
    plugin_state->right = false;
    plugin_state->fired = false;
    plugin_state->gun_fired = false;
#ifdef SOUND

    plugin_state->music_instance = malloc(sizeof(MusicPlayer));
    plugin_state->music_instance->model = malloc(sizeof(MusicPlayerModel));
    memset(
        plugin_state->music_instance->model->duration_history,
        0xff,
        MUSIC_PLAYER_SEMITONE_HISTORY_SIZE);
    memset(
        plugin_state->music_instance->model->semitone_history,
        0xff,
        MUSIC_PLAYER_SEMITONE_HISTORY_SIZE);
    plugin_state->music_instance->model->volume = 2;

    plugin_state->music_instance->model_mutex = furi_mutex_alloc(FuriMutexTypeNormal);
    //plugin_state->music_instance->view_port = view_port_alloc();

    plugin_state->music_instance->worker = music_player_worker_alloc();
    //music_player_worker_set_volume(plugin_state->music_instance->worker, 0.75);
    music_player_worker_set_volume(
        plugin_state->music_instance->worker,
        MUSIC_PLAYER_VOLUMES[plugin_state->music_instance->model->volume]);
    plugin_state->intro_sound = true;
    //init_sound(plugin_state->music_instance);
#endif
}

static void doom_game_update_timer_callback(FuriMessageQueue* event_queue) {
    furi_assert(event_queue);

    PluginEvent event = {.type = EventTypeTick};
    furi_message_queue_put(event_queue, &event, 0);
}

static void doom_game_tick(PluginState* const plugin_state) {
    if(plugin_state->scene == GAME_PLAY) {
        //fps();
        memset(display_buf, 0, SCREEN_WIDTH * (RENDER_HEIGHT / 8));
        //player is alive
        if(plugin_state->player.health > 0) {
            if(plugin_state->up) {
                plugin_state->player.velocity +=
                    ((double)MOV_SPEED - plugin_state->player.velocity) * (double).4;
                plugin_state->jogging = fabs(plugin_state->player.velocity) * MOV_SPEED_INV;
                //plugin_state->up = false;
            } else if(plugin_state->down) {
                plugin_state->player.velocity +=
                    (-(double)MOV_SPEED - plugin_state->player.velocity) * (double).4;
                plugin_state->jogging = fabs(plugin_state->player.velocity) * MOV_SPEED_INV;
                //plugin_state->down = false;
            } else {
                plugin_state->player.velocity *= (double).5;
                plugin_state->jogging = fabs(plugin_state->player.velocity) * MOV_SPEED_INV;
            }

            if(plugin_state->right) {
                plugin_state->rot_speed = (double)ROT_SPEED * delta;
                plugin_state->old_dir_x = plugin_state->player.dir.x;
                plugin_state->player.dir.x =
                    plugin_state->player.dir.x * cos(-(plugin_state->rot_speed)) -
                    plugin_state->player.dir.y * sin(-(plugin_state->rot_speed));
                plugin_state->player.dir.y =
                    plugin_state->old_dir_x * sin(-(plugin_state->rot_speed)) +
                    plugin_state->player.dir.y * cos(-(plugin_state->rot_speed));
                plugin_state->old_plane_x = plugin_state->player.plane.x;
                plugin_state->player.plane.x =
                    plugin_state->player.plane.x * cos(-(plugin_state->rot_speed)) -
                    plugin_state->player.plane.y * sin(-(plugin_state->rot_speed));
                plugin_state->player.plane.y =
                    plugin_state->old_plane_x * sin(-(plugin_state->rot_speed)) +
                    plugin_state->player.plane.y * cos(-(plugin_state->rot_speed));

                //plugin_state->right = false;
            } else if(plugin_state->left) {
                plugin_state->rot_speed = (double)ROT_SPEED * delta;
                plugin_state->old_dir_x = plugin_state->player.dir.x;
                plugin_state->player.dir.x =
                    plugin_state->player.dir.x * cos(plugin_state->rot_speed) -
                    plugin_state->player.dir.y * sin(plugin_state->rot_speed);
                plugin_state->player.dir.y =
                    plugin_state->old_dir_x * sin(plugin_state->rot_speed) +
                    plugin_state->player.dir.y * cos(plugin_state->rot_speed);
                plugin_state->old_plane_x = plugin_state->player.plane.x;
                plugin_state->player.plane.x =
                    plugin_state->player.plane.x * cos(plugin_state->rot_speed) -
                    plugin_state->player.plane.y * sin(plugin_state->rot_speed);
                plugin_state->player.plane.y =
                    plugin_state->old_plane_x * sin(plugin_state->rot_speed) +
                    plugin_state->player.plane.y * cos(plugin_state->rot_speed);
                //plugin_state->left = false;
            }
            plugin_state->view_height =
                fabs(sin((double)furi_get_tick() * (double)JOGGING_SPEED)) * 6 *
                plugin_state->jogging;

            if(plugin_state->gun_pos > GUN_TARGET_POS) {
                // Right after fire
                plugin_state->gun_pos -= 1;
            } else if(plugin_state->gun_pos < GUN_TARGET_POS) {
                plugin_state->gun_pos += 2;
            } else if(!plugin_state->gun_fired && plugin_state->fired) {
                //furi_hal_speaker_start(20480 / 10, 0.45f);
                /*#ifdef SOUND
        music_player_worker_start(plugin_state->music_instance->worker);
#endif*/
                plugin_state->gun_pos = GUN_SHOT_POS;
                plugin_state->gun_fired = true;
                plugin_state->fired = false;
                fire(plugin_state);

            } else if(plugin_state->gun_fired && !plugin_state->fired) {
                //furi_hal_speaker_stop();
                plugin_state->gun_fired = false;

                notification_message(plugin_state->notify, &sequence_short_sound);

                /*#ifdef SOUND
        music_player_worker_stop(plugin_state->music_instance->worker);
#endif*/
            }
        } else {
            // Player is dead
            if(plugin_state->view_height > -10) plugin_state->view_height--;
            if(plugin_state->gun_pos > 1) plugin_state->gun_pos -= 2;
        }

        if(fabs(plugin_state->player.velocity) > (double)0.003) {
            updatePosition(
                sto_level_1,
                &(plugin_state->player.pos),
                plugin_state->player.dir.x * plugin_state->player.velocity * delta,
                plugin_state->player.dir.y * plugin_state->player.velocity * delta,
                false,
                plugin_state);
        } else {
            plugin_state->player.velocity = 0;
        }
    }
}

int32_t doom_app() {
    FuriMessageQueue* event_queue = furi_message_queue_alloc(8, sizeof(PluginEvent));
    PluginState* plugin_state = malloc(sizeof(PluginState));
    doom_state_init(plugin_state);
    ValueMutex state_mutex;
    if(!init_mutex(&state_mutex, plugin_state, sizeof(PluginState))) {
        FURI_LOG_E("Doom_game", "cannot create mutex\r\n");
        furi_record_close(RECORD_NOTIFICATION);
        furi_message_queue_free(event_queue);
        free(plugin_state);
        return 255;
    }
    FuriTimer* timer =
        furi_timer_alloc(doom_game_update_timer_callback, FuriTimerTypePeriodic, event_queue);
    furi_timer_start(timer, furi_kernel_get_tick_frequency() / 12);
    // Set system callbacks
    ViewPort* view_port = view_port_alloc();
    view_port_draw_callback_set(view_port, render_callback, &state_mutex);
    view_port_input_callback_set(view_port, input_callback, event_queue);

    // Open GUI and register view_port
    Gui* gui = furi_record_open("gui");
    gui_add_view_port(gui, view_port, GuiLayerFullscreen);

    //////////////////////////////////
    if(display_buf != NULL) plugin_state->init = false;

    PluginEvent event;
#ifdef SOUND
    music_player_worker_load_rtttl_from_string(plugin_state->music_instance->worker, dsintro);
    music_player_worker_start(plugin_state->music_instance->worker);
#endif
    for(bool processing = true; processing;) {
        FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100);
        PluginState* plugin_state = (PluginState*)acquire_mutex_block(&state_mutex);
#ifdef SOUND
        furi_check(
            furi_mutex_acquire(plugin_state->music_instance->model_mutex, FuriWaitForever) ==
            FuriStatusOk);
#endif
        if(event_status == FuriStatusOk) {
            // press events
            if(event.type == EventTypeKey) {
                if(event.input.key == InputKeyBack) {
                    processing = false;
#ifdef SOUND
                    if(plugin_state->intro_sound) {
                        furi_mutex_release(plugin_state->music_instance->model_mutex);
                        music_player_worker_stop(plugin_state->music_instance->worker);
                    }
#endif
                }

                if(event.input.type == InputTypePress) {
                    if(plugin_state->scene == INTRO && event.input.key == InputKeyOk) {
                        plugin_state->scene = GAME_PLAY;
                        initializeLevel(sto_level_1, plugin_state);
#ifdef SOUND
                        furi_mutex_release(plugin_state->music_instance->model_mutex);
                        music_player_worker_stop(plugin_state->music_instance->worker);
                        plugin_state->intro_sound = false;
#endif
                        goto skipintro;
                    }

                    //While playing game
                    if(plugin_state->scene == GAME_PLAY) {
                        // If the player is alive
                        if(plugin_state->player.health > 0) {
                            //Player speed
                            if(event.input.key == InputKeyUp) {
                                plugin_state->up = true;
                            } else if(event.input.key == InputKeyDown) {
                                plugin_state->down = true;
                            }
                            // Player rotation
                            if(event.input.key == InputKeyRight) {
                                plugin_state->right = true;
                            } else if(event.input.key == InputKeyLeft) {
                                plugin_state->left = true;
                            }
                            if(event.input.key == InputKeyOk) {
                                /*#ifdef SOUND
                        music_player_worker_load_rtttl_from_string(plugin_state->music_instance->worker, dspistol);
#endif*/
                                if(plugin_state->fired) {
                                    plugin_state->fired = false;
                                } else {
                                    plugin_state->fired = true;
                                }
                            }
                        } else {
                            // Player is dead
                            if(event.input.key == InputKeyOk) plugin_state->scene = INTRO;
                        }
                    }
                }
                if(event.input.type == InputTypeRelease) {
                    if(plugin_state->player.health > 0) {
                        //Player speed
                        if(event.input.key == InputKeyUp) {
                            plugin_state->up = false;
                        } else if(event.input.key == InputKeyDown) {
                            plugin_state->down = false;
                        }
                        // Player rotation
                        if(event.input.key == InputKeyRight) {
                            plugin_state->right = false;
                        } else if(event.input.key == InputKeyLeft) {
                            plugin_state->left = false;
                        }
                    }
                }
            }

        skipintro:
            if(event.type == EventTypeTick) {
                doom_game_tick(plugin_state);
            }
        }
#ifdef SOUND
        furi_mutex_release(plugin_state->music_instance->model_mutex);
#endif
        view_port_update(view_port);
        release_mutex(&state_mutex, plugin_state);
    }
#ifdef SOUND
    music_player_worker_free(plugin_state->music_instance->worker);
    furi_mutex_free(plugin_state->music_instance->model_mutex);
    free(plugin_state->music_instance->model);
    free(plugin_state->music_instance);
#endif
    furi_record_close(RECORD_NOTIFICATION);
    furi_timer_free(timer);
    view_port_enabled_set(view_port, false);
    gui_remove_view_port(gui, view_port);
    furi_record_close("gui");
    view_port_free(view_port);
    furi_message_queue_free(event_queue);
    free(plugin_state);
    return 0;
}