Added FlipperGB

applications/system/FlipperDoom/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2019 James Howard (original)
+Copyright (c) 2025 Apfxtech (Flipper Zero port)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

applications/system/FlipperDoom/README.md

@@ -0,0 +1,177 @@
+# Flipper DOOM
+
+A DOOM-style first-person shooter demake for the Flipper Zero
+(128×64 monochrome LCD). Built on the raycaster engine from
+[FlipperCatacombs](https://github.com/apfxtech/FlipperCatacombs) (a port of
+*Catacombs of the Damned* / arduboy3d by jhhoward), re-skinned with graphics
+converted **at build time from your own DOOM shareware WAD**.
+
+---
+
+## Quick Start
+
+1. Copy `dist/flipdoom.fap` to your SD card under `SD/apps/Games/`
+   (or run `ufbt launch` with the Flipper connected via USB).
+2. On the Flipper: **Apps → Games → Flipper DOOM**.
+3. Title screen → main menu → select **Play** with OK.
+4. Fight through procedurally generated levels, find the exit gate on each
+   floor, survive as deep as you can. Your score and high score are saved
+   automatically.
+
+---
+
+## Controls
+
+### Title screen
+
+| Button | Action |
+|---|---|
+| Any button | Skip the title screen |
+
+### Main menu
+
+| Button | Action |
+|---|---|
+| **Up / Down** | Move cursor (Play / Sound on-off / Score / High score) |
+| **OK** | Select item |
+| **Back (hold ~300 ms)** | Exit the app |
+
+### In game
+
+| Button | Action |
+|---|---|
+| **Up / Down** | Move forward / backward |
+| **Left / Right** | Turn left / right |
+| **OK** | Fire the shotgun (hold for continuous fire) |
+| **OK held + Left / Right** | **Strafe** (circle-strafe while firing) — essential for dodging fireballs |
+| **Back (hold ~300 ms)** | Leave the game and return to the menu |
+
+Notes:
+
+- Firing costs ammo (bottom HUD bar); ammo regenerates when not shooting.
+- Strafing only works while OK is held. Tap OK to fire while turning
+  normally; hold OK to switch the side arrows into dodge mode.
+- Walking into a backpack opens it; walking over pickups collects them.
+
+### HUD
+
+- **Bottom bar with cross icon** — health.
+- **Bar above it with bullets icon** — ammo.
+- Screen border flashes when you take damage.
+- Pickup/event messages appear at the top of the screen.
+
+---
+
+## Gameplay
+
+### Enemies
+
+| Enemy | Behavior |
+|---|---|
+| **Zombieman** | Weak, shoots from range, appears from level 1 |
+| **Sergeant** | Fast, shoots hard, keeps distance |
+| **Imp** | Throws fireballs, backs away if you get close |
+| **Demon** | Melee tank — charges you and bites |
+
+Difficulty scales with depth: early levels spawn mostly zombies; imps join
+from level 3, and demons dominate from level 6.
+
+### Exploding barrels
+
+Shooting a barrel triggers an area explosion that deals heavy damage to every
+enemy nearby (one-shots zombies and sergeants) and hurts you if you stand too
+close — though it will never kill you outright, it can leave you at 1 HP.
+Barrels sometimes leave a pickup behind.
+
+### Pickups
+
+| Item | Effect |
+|---|---|
+| Stimpack | Restores health |
+| Backpack (walk into it) | Bonus points |
+| Armor / helmet / bonus items | Points |
+
+### Scoring
+
+Points are awarded for floors cleared, kills per enemy type, and items
+collected. Escaping the base (final exit) grants a large bonus. Score and
+high score are stored on the SD card (`apps_data/flipdoom/`) and persist
+between sessions.
+
+---
+
+## Sound
+
+Tone-based sound effects through the Flipper buzzer (shotgun blast, hits,
+kills, pickups, player damage), all tuned within the buzzer's physical
+100–2500 Hz range. Sound can be toggled in the main menu; the system
+Stealth Mode is respected.
+
+---
+
+## Building from source
+
+Requires Python 3 and [ufbt](https://pypi.org/project/ufbt/):
+
+```sh
+pip install ufbt
+
+cd FlipperDoom
+
+# 1) Generate the sprite header from YOUR shareware WAD (not included here):
+python3 tools/extract_doom_assets.py /path/to/Doom1.WAD
+
+# 2) Build / install:
+ufbt          # produces dist/flipdoom.fap
+ufbt launch   # builds, installs and runs on a connected Flipper
+```
+
+### About the assets
+
+No id Software assets are stored in this repository. The generated header
+`game/Generated/DoomSprites.inc.h` is produced locally by
+`tools/extract_doom_assets.py`, which decodes sprites from the user's own
+shareware WAD (freely distributable as a whole), rescales them and quantizes
+to 1-bit (black / 50% checker / white) in the engine's sprite formats.
+Do not redistribute the generated header — always regenerate it from a WAD
+you own. The "DOOM" title lettering and the HUD icons are original pixel art
+made for this project. Preview images of the converted assets are written to
+`tools/preview/`.
+
+Entity mapping (game mechanics are inherited from the Catacombs engine):
+
+| Engine entity | DOOM sprite | Role |
+|---|---|---|
+| Skeleton | Demon (SARG) | melee tank |
+| Mage | Imp (TROO) | fireball thrower |
+| Bat | Sergeant (SPOS) | fast shooter |
+| Spider | Zombieman (POSS) | weak shooter |
+| Weapon | Shotgun (SHTG + SHTF flash) | first person, centered |
+| Urn | Barrel (BAR1) | explodes when shot |
+| Potion | Stimpack (STIM) | health |
+| Chest / opened | Backpack (BPAK) / Clip (CLIP) | treasure |
+| Crown / scroll / coins | Armor / helmet / potion bottle (ARM1, BON2, BON1) | points |
+| Sign | Skull pile (POL5) | decoration |
+| Projectiles | Fireball (BAL1) | player & enemies |
+
+## Why not a real doomgeneric port?
+
+The hardware makes it impossible — not a software choice:
+
+| | Flipper Zero | Real DOOM (doomgeneric) |
+|---|---|---|
+| Total RAM | 256 KB | — |
+| Free heap for apps | ~140 KB | ~7 MB (zone memory + framebuffer) |
+| Engine binary | FAPs load fully into RAM | ~524 KB compiled for Cortex-M4 |
+
+The Flipper cannot execute code from the SD card (no XIP), so it can't even
+load the DOOM engine binary. DOOM ports to 256 KB microcontrollers (GBA,
+nRF52840) rely on memory-mapped flash, which the Flipper does not have. This
+demake keeps the aesthetic with an engine that actually fits: ~30 KB loaded,
+30 FPS on the 64 MHz Cortex-M4.
+
+## License
+
+Same license as the base project (see `LICENSE`). WAD contents are property
+of id Software; the extraction tool only transforms them locally for
+personal use.

applications/system/FlipperDoom/application.fam

@@ -0,0 +1,15 @@
+App(
+    appid="flipdoom",
+    name="Flipper DOOM",
+    apptype=FlipperAppType.EXTERNAL,
+    entry_point="flipdoom_app",
+    cdefines=["APP_FLIPDOOM"],
+    requires=["gui"],
+    stack_size=8 * 1024,
+    fap_category="Games",
+    fap_icon="flipdoom_icon.png",
+    order=36,
+    fap_author="user",
+    fap_version="1.0",
+    fap_description="Doom-style raycaster demake for Flipper Zero. Graphics converted at build time from your own Doom shareware WAD.",
+)

applications/system/FlipperDoom/game/Defines.h

@@ -0,0 +1,87 @@
+#pragma once
+#include <cstdint>
+#include <cstring>
+
+static inline const void* pgm_read_ptr_safe(const void* p) {
+    const void* out;
+    std::memcpy(&out, p, sizeof(out));
+    return out;
+}
+
+// Platform detection
+#if defined(_WIN32)
+#include <stdint.h>
+#include <string.h>
+#define PROGMEM
+#define PSTR(s) (s)
+#define pgm_read_byte(x) (*((uint8_t*)(x)))
+#define pgm_read_word(x) (*((uint16_t*)(x)))
+#define pgm_read_ptr(x) (*((uintptr_t*)(x)))
+#define strlen_P(x) strlen(x)
+#define strcpy_P(dst, src) strcpy(dst, src)
+#define memcpy_P(dst, src, n) memcpy(dst, src, n)
+#elif defined(__AVR__)
+// Arduino/Arduboy platform
+#include <avr/pgmspace.h>
+#else
+// Flipper Zero and other ARM platforms
+#include <stdint.h>
+#include <string.h>
+#define PROGMEM
+#define PSTR(s) (s)
+#define pgm_read_byte(x) (*((const uint8_t*)(x)))
+#define pgm_read_word(x) (*((const uint16_t*)(x)))
+#define pgm_read_dword(x) (*((const uint32_t*)(x)))
+#define strlen_P(x) strlen(x)
+#define strcpy_P(dst, src) strcpy(dst, src)
+#define strcmp_P(s1, s2) strcmp(s1, s2)
+#define strncmp_P(s1, s2, n) strncmp(s1, s2, n)
+#define memcpy_P(dst, src, n) memcpy(dst, src, n)
+#define sprintf_P sprintf
+#define snprintf_P snprintf
+#endif
+
+// Display configuration
+#define DISPLAY_WIDTH 128
+#define DISPLAY_HEIGHT 64
+
+// Game settings
+#define DEV_MODE 0
+
+// Input definitions
+#define INPUT_LEFT 1
+#define INPUT_RIGHT 2
+#define INPUT_UP 4
+#define INPUT_DOWN 8
+#define INPUT_A 16
+#define INPUT_B 32
+
+#ifndef COLOUR_WHITE
+#define COLOUR_WHITE 1
+#endif
+
+#ifndef COLOUR_BLACK
+#define COLOUR_BLACK 0
+#endif
+
+// Angle system (256 = 360 degrees)
+#define FIXED_ANGLE_MAX 256
+
+// 3D rendering settings
+#define CAMERA_SCALE 1
+#define CLIP_PLANE 32
+#define CLIP_ANGLE 32
+#define NEAR_PLANE_MULTIPLIER 130
+#define NEAR_PLANE (DISPLAY_WIDTH * NEAR_PLANE_MULTIPLIER / 256)
+#define HORIZON (DISPLAY_HEIGHT / 2)
+
+// World settings
+#define CELL_SIZE 256
+#define PARTICLES_PER_SYSTEM 8
+#define BASE_SPRITE_SIZE 16
+#define MAX_SPRITE_SIZE (DISPLAY_HEIGHT / 2)
+#define MIN_TEXTURE_DISTANCE 4
+#define MAX_QUEUED_DRAWABLES 12
+
+// Player settings
+#define TURN_SPEED 3

applications/system/FlipperDoom/game/Draw.h

@@ -0,0 +1,146 @@
+#pragma once
+#include "game/Defines.h"
+
+#define WITH_IMAGE_TEXTURES  0
+#define WITH_VECTOR_TEXTURES 1
+#define WITH_TEXTURES        (WITH_IMAGE_TEXTURES || WITH_VECTOR_TEXTURES)
+#define WITH_SPRITE_OUTLINES 1
+
+struct Camera {
+    int16_t x, y;
+    uint8_t angle;
+    int16_t rotCos, rotSin;
+    int16_t clipCos, clipSin;
+    uint8_t cellX, cellY;
+    int8_t tilt;
+    int8_t bob;
+    uint8_t shakeTime;
+};
+
+enum class DrawableType : uint8_t {
+    Sprite = 0,
+    ParticleSystem = 1
+};
+
+enum class AnchorType : uint8_t {
+    Floor,
+    Center,
+    BelowCenter,
+    Ceiling
+};
+
+struct QueuedDrawable {
+    union {
+        const uint16_t* spriteData;
+        struct ParticleSystem* particleSystem;
+    };
+
+    DrawableType type : 1;
+    bool invert       : 1;
+    int8_t x;
+    int8_t y;
+    uint8_t halfSize;
+    uint8_t inverseCameraDistance;
+};
+
+class Renderer {
+public:
+    static Camera camera;
+    static uint8_t wBuffer[DISPLAY_WIDTH];
+    static uint8_t globalRenderFrame;
+
+    static void Render();
+
+    static void DrawObject(
+        const uint16_t* spriteData,
+        int16_t x,
+        int16_t y,
+        uint8_t scale = 128,
+        AnchorType anchor = AnchorType::Floor,
+        bool invert = false);
+    static QueuedDrawable* CreateQueuedDrawable(uint8_t inverseCameraDistance);
+    static int8_t GetHorizon(int16_t x);
+
+    static bool
+        TransformAndCull(int16_t worldX, int16_t worldY, int16_t& outScreenX, int16_t& outScreenW);
+
+    static void DrawScaled(
+        const uint16_t* data,
+        int8_t x,
+        int8_t y,
+        uint8_t halfSize,
+        uint8_t inverseCameraDistance,
+        bool invert = false,
+        uint8_t color = COLOUR_BLACK);
+
+    static int8_t horizonBuffer[DISPLAY_WIDTH];
+    static uint8_t numBufferSlicesFilled;
+    static void DrawWallLine(
+        int16_t x1,
+        int16_t y1,
+        int16_t x2,
+        int16_t y2,
+        uint8_t clipLeft,
+        uint8_t clipRight,
+        uint8_t col);
+    static void DrawWallSegment(
+        const uint8_t* texture,
+        int16_t x1,
+        int16_t w1,
+        int16_t x2,
+        int16_t w2,
+        uint8_t u1clip,
+        uint8_t u2clip,
+        bool edgeLeft,
+        bool edgeRight,
+        bool shadeEdge);
+    static void DrawWall(
+        const uint8_t* texture,
+        int16_t x1,
+        int16_t y1,
+        int16_t x2,
+        int16_t y2,
+        bool edgeLeft,
+        bool edgeRight,
+        bool shadeEdge);
+    static void DrawBackground();
+    static uint8_t numQueuedDrawables;
+    static bool isFrustrumClipped(int16_t x, int16_t y);
+
+private:
+    static QueuedDrawable queuedDrawables[MAX_QUEUED_DRAWABLES];
+
+    // #if WITH_IMAGE_TEXTURES
+    // 	static void DrawWallSegment(const uint16_t* texture, int16_t x1, int16_t w1, int16_t x2, int16_t w2, uint8_t u1clip, uint8_t u2clip, bool edgeLeft, bool edgeRight, bool shadeEdge);
+    // 	static void DrawWall(const uint16_t* texture, int16_t x1, int16_t y1, int16_t x2, int16_t y2, bool edgeLeft, bool edgeRight, bool shadeEdge);
+    // #elif WITH_VECTOR_TEXTURES
+    // 	static void DrawWallLine(int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t clipLeft, uint8_t clipRight, uint8_t col);
+    // 	static void DrawWallSegment(const uint8_t* texture, int16_t x1, int16_t w1, int16_t x2, int16_t w2, uint8_t u1clip, uint8_t u2clip, bool edgeLeft, bool edgeRight, bool shadeEdge);
+    // 	static void DrawWall(const uint8_t* texture, int16_t x1, int16_t y1, int16_t x2, int16_t y2, bool edgeLeft, bool edgeRight, bool shadeEdge);
+    // #else
+    // 	static void DrawWallSegment(int16_t x1, int16_t w1, int16_t x2, int16_t w2, bool edgeLeft, bool edgeRight, bool shadeEdge);
+    // 	static void DrawWall(int16_t x1, int16_t y1, int16_t x2, int16_t y2, bool edgeLeft, bool edgeRight, bool shadeEdge);
+    // #endif
+    static void DrawFloorLine(int16_t x1, int16_t y1, int16_t x2, int16_t y2);
+    static void DrawFloorLineInner(int16_t x1, int16_t y1, int16_t x2, int16_t y2);
+    static void DrawFloorLines();
+
+    static void TransformToViewSpace(int16_t x, int16_t y, int16_t& outX, int16_t& outY);
+    static void TransformToScreenSpace(int16_t viewX, int16_t viewZ, int16_t& outX, int16_t& outW);
+
+    static void DrawCell(uint8_t x, uint8_t y);
+    static void DrawCells();
+    static void DrawWeapon();
+    static void DrawHUD();
+    static void DrawBar(uint8_t* screenPtr, const uint8_t* iconData, uint8_t amount, uint8_t max);
+    static void DrawDamageIndicator();
+
+    static void QueueSprite(
+        const uint16_t* data,
+        int8_t x,
+        int8_t y,
+        uint8_t halfSize,
+        uint8_t inverseCameraDistance,
+        bool invert = false);
+    static void RenderQueuedDrawables();
+};

applications/system/FlipperDoom/game/Enemy.cpp

@@ -0,0 +1,484 @@
+#include "game/Enemy.h"
+#include "game/Defines.h"
+#include "game/Draw.h"
+#include "game/Map.h"
+#include "game/FixedMath.h"
+#include "game/Game.h"
+#include "game/Projectile.h"
+#include "game/Generated/SpriteTypes.h"
+#include "game/Sounds.h"
+#include "game/Platform.h"
+#include "game/Particle.h"
+
+Enemy EnemyManager::enemies[maxEnemies];
+
+const EnemyArchetype Enemy::archetypes[(int)EnemyType::NumEnemyTypes] PROGMEM =
+{
+	{
+		// Skeleton
+		skeletonSpriteData,
+		50,					// hp
+		4,					// speed
+		20,					// attackStrength
+		3,					// attackDuration
+		2,					// stunDuration
+		false,				// isRanged
+		96,					// sprite scale
+		AnchorType::Floor	// sprite anchor
+	},
+	{
+		// Mage
+		mageSpriteData,
+		30,					// hp
+		5,					// speed
+		20,					// attackStrength
+		3,					// attackDuration
+		2,					// stunDuration
+		true,				// isRanged
+		96,					// sprite scale
+		AnchorType::Floor	// sprite anchor
+	},
+	{
+		// Bat -> shotgun sergeant (ranged, hits hard)
+		batSpriteData,
+		20,					// hp
+		6,					// speed
+		10,					// attackStrength
+		2,					// attackDuration
+		0,					// stunDuration
+		true,				// isRanged
+		90,					// sprite scale
+		AnchorType::Floor	// sprite anchor
+	},
+	{
+		// Spider -> zombieman (ranged, weak)
+		spiderSpriteData,
+		10,					// hp
+		5,					// speed
+		4,					// attackStrength
+		1,					// attackDuration
+		0,					// stunDuration
+		true,				// isRanged
+		80,					// sprite scale
+		AnchorType::Floor	// sprite anchor
+	}
+};
+
+void Enemy::Init(EnemyType initType, int16_t initX, int16_t initY)
+{
+	state = EnemyState::Idle;
+	type = initType;
+	x = initX;
+	y = initY;
+	frameDelay = 0;
+	targetCellX = x / CELL_SIZE;
+	targetCellY = y / CELL_SIZE;
+	hp = GetArchetype()->GetHP();
+}
+
+void Enemy::Damage(uint8_t amount)
+{
+	if (amount >= hp)
+	{
+		Game::stats.enemyKills[(int)type]++;
+		type = EnemyType::None;
+		Platform::PlaySound(Sounds::Kill);
+		ParticleSystemManager::CreateExplosion(x, y, true);
+	}
+	else
+	{
+		hp -= amount;
+		Platform::PlaySound(Sounds::Hit);
+		state = EnemyState::Stunned;
+		frameDelay = GetArchetype()->GetStunDuration();
+	}
+}
+
+const EnemyArchetype* Enemy::GetArchetype() const
+{
+	if (type == EnemyType::None)
+		return nullptr;
+	return &archetypes[(int)type];
+}
+
+int16_t Clamp(int16_t x, int16_t min, int16_t max)
+{
+	if(x < min)
+		return min;
+	if(x > max)
+		return max;
+	return x;
+}
+
+bool Enemy::TryPickCell(int8_t newX, int8_t newY)
+{
+	if(Map::IsBlocked(newX, newY))// && !engine.map.isDoor(newX, newZ))
+		return false;
+	if(Map::IsBlocked(targetCellX, newY)) // && !engine.map.isDoor(targetCellX, newZ))
+		return false;
+	if(Map::IsBlocked(newX, targetCellY)) // && !engine.map.isDoor(newX, targetCellZ))
+		return false;
+
+	for (Enemy& other : EnemyManager::enemies)
+	{
+		if(this != &other && other.IsValid())
+		{
+			if(other.targetCellX == newX && other.targetCellY == newY)
+				return false;
+		}
+	}
+
+	targetCellX = newX;
+	targetCellY = newY;
+
+	return true;
+}
+
+bool Enemy::TryPickCells(int8_t deltaX, int8_t deltaY)
+{
+	return TryPickCell(targetCellX + deltaX, targetCellY + deltaY)
+		|| TryPickCell(targetCellX + deltaX, targetCellY) 
+		|| TryPickCell(targetCellX, targetCellY + deltaY) 
+		|| TryPickCell(targetCellX - deltaX, targetCellY + deltaY)
+		|| TryPickCell(targetCellX + deltaX, targetCellY - deltaY);
+}
+
+uint8_t Enemy::GetPlayerCellDistance() const
+{
+	uint8_t dx = ABS(Game::player.x - x) / CELL_SIZE;
+	uint8_t dy = ABS(Game::player.y - y) / CELL_SIZE;
+	return dx > dy ? dx : dy;
+}
+
+void Enemy::PickNewTargetCell()
+{
+	int8_t deltaX = (int8_t) Clamp((Game::player.x / CELL_SIZE) - targetCellX, -1, 1);
+	int8_t deltaY = (int8_t) Clamp((Game::player.y / CELL_SIZE) - targetCellY, -1, 1);
+	uint8_t dodgeChance = (uint8_t) Random();
+
+	if (GetArchetype()->GetIsRanged() && GetPlayerCellDistance() < 3)
+	{
+		deltaX = -deltaX;
+		deltaY = -deltaY;
+	}
+
+	if(deltaX == 0)
+	{
+		if(dodgeChance < 64)
+		{
+			deltaX = -1;
+		}
+		else if(dodgeChance < 128)
+		{
+			deltaX = 1;
+		}
+	}
+	else if(deltaY == 0)
+	{
+		if(dodgeChance < 64)
+		{
+			deltaY = -1;
+		}
+		else if(dodgeChance < 128)
+		{
+			deltaY = 1;
+		}
+	}
+
+	TryPickCells(deltaX, deltaY);
+}
+
+void Enemy::StunMove()
+{
+	//int16_t targetX = Game::player.x;
+	//int16_t targetY = Game::player.y;
+	//
+	//int16_t maxDelta = 3;
+	//
+	//int16_t deltaX = Clamp(targetX - x, -maxDelta, maxDelta);
+	//int16_t deltaY = Clamp(targetY - y, -maxDelta, maxDelta);
+	//
+	//x -= deltaX;
+	//y -= deltaY;
+	
+//	int16_t deltaX = (Random() % 16) - 8;
+//	int16_t deltaY = (Random() % 16) - 8;
+//	x += deltaX;
+//	y += deltaY;
+}
+
+bool Enemy::TryMove()
+{
+	if(Map::IsSolid(targetCellX, targetCellY))
+	{
+		//engine.map.openDoorsAt(targetCellX, targetCellZ, Direction_None);
+		return false;
+	}
+
+	int16_t targetX = (targetCellX * CELL_SIZE) + CELL_SIZE / 2;
+	int16_t targetY = (targetCellY * CELL_SIZE) + CELL_SIZE / 2;
+
+	int16_t maxDelta = GetArchetype()->GetMovementSpeed();
+
+	int16_t deltaX = Clamp(targetX - x, -maxDelta, maxDelta);
+	int16_t deltaY = Clamp(targetY - y, -maxDelta, maxDelta);
+
+	x += deltaX;
+	y += deltaY;
+
+	if(IsOverlappingEntity(Game::player))
+	{
+		if (!GetArchetype()->GetIsRanged())
+		{
+			Game::player.Damage(GetArchetype()->GetAttackStrength());
+			if (Game::player.hp == 0)
+			{
+				Game::stats.killedBy = type;
+			}
+
+			state = EnemyState::Attacking;
+			frameDelay = GetArchetype()->GetAttackDuration();
+		}
+
+		x -= deltaX;
+		y -= deltaY;
+		return false;
+	}
+
+	if(x == targetX && y == targetY)
+	{
+		PickNewTargetCell();
+	}
+	return true;	
+}
+
+bool Enemy::FireProjectile(uint8_t angle)
+{
+	return ProjectileManager::FireProjectile(this, x, y, angle) != nullptr;
+}
+
+bool Enemy::TryFireProjectile()
+{
+	int8_t deltaX = (Game::player.x - x) / CELL_SIZE;
+	int8_t deltaY = (Game::player.y - y) / CELL_SIZE;
+
+	if (deltaX == 0)
+	{
+		if (deltaY < 0)
+		{
+			return FireProjectile(FIXED_ANGLE_270);
+		}
+		else if (deltaY > 0)
+		{
+			return FireProjectile(FIXED_ANGLE_90);
+		}
+	}
+	else if (deltaY == 0)
+	{
+		if (deltaX < 0)
+		{
+			return FireProjectile(FIXED_ANGLE_180);
+		}
+		else if (deltaX > 0)
+		{
+			return FireProjectile(0);
+		}
+	}
+	else if (deltaX == deltaY)
+	{
+		if (deltaX > 0)
+		{
+			return FireProjectile(FIXED_ANGLE_45);
+		}
+		else
+		{
+			return FireProjectile(FIXED_ANGLE_180 + FIXED_ANGLE_45);
+		}
+	}
+	else if (deltaX == -deltaY)
+	{
+		if (deltaX > 0)
+		{
+			return FireProjectile(FIXED_ANGLE_270 + FIXED_ANGLE_45);
+		}
+		else
+		{
+			return FireProjectile(FIXED_ANGLE_90 + FIXED_ANGLE_45);
+		}
+	}
+
+	return false;
+}
+
+bool Enemy::ShouldFireProjectile() const
+{
+	uint8_t distance = GetPlayerCellDistance();
+	uint8_t chance = 16 / (distance > 0 ? distance : 1);
+
+	return GetArchetype()->GetIsRanged() && (Random() & 0xff) < chance && Map::IsClearLine(x, y, Game::player.x, Game::player.y);
+}
+
+void Enemy::Tick()
+{
+	if (state == EnemyState::Stunned)
+	{
+		StunMove();
+	}
+
+	if (frameDelay > 0)
+	{
+		if ((Game::globalTickFrame & 0xf) == 0)
+		{
+			frameDelay--;
+		}
+		return;
+	}
+
+	switch (state)
+	{
+	case EnemyState::Idle:
+		if (Map::IsClearLine(x, y, Game::player.x, Game::player.y))
+		{
+			Platform::PlaySound(Sounds::SpotPlayer);
+			state = EnemyState::Moving;
+		}
+		break;
+	case EnemyState::Moving:
+		TryMove();
+
+		if (ShouldFireProjectile())
+		{
+			if (TryFireProjectile())
+			{
+				Platform::PlaySound(Sounds::Shoot);
+				state = EnemyState::Attacking;
+				frameDelay = GetArchetype()->GetAttackDuration();
+			}
+		}
+		break;
+	case EnemyState::Attacking:
+		state = EnemyState::Moving;
+		break;
+	case EnemyState::Stunned:
+		state = EnemyState::Moving;
+		break;
+	default:
+    break;
+	}
+}
+
+void EnemyManager::Init()
+{
+	for (Enemy& enemy : enemies)
+	{
+		enemy.Clear();
+	}
+}
+
+void EnemyManager::Update()
+{
+	for (Enemy& enemy : enemies)
+	{
+		if(enemy.IsValid())
+		{
+			enemy.Tick();
+		}
+	}
+}
+
+void EnemyManager::Draw()
+{
+	for(Enemy& enemy : enemies)
+	{
+		if(enemy.IsValid())
+		{
+			bool invert = enemy.GetState() == EnemyState::Stunned && (Renderer::globalRenderFrame & 1);
+			int frameOffset = (enemy.GetType() == EnemyType::Bat || enemy.GetState() == EnemyState::Moving) && (Game::globalTickFrame & 8) == 0 ? 32 : 0;
+
+			const EnemyArchetype* archetype = enemy.GetArchetype();
+			Renderer::DrawObject(archetype->GetSpriteData() + frameOffset, enemy.x, enemy.y, archetype->GetSpriteScale(), archetype->GetSpriteAnchor(), invert);
+		}
+	}
+}
+
+void EnemyManager::Spawn(EnemyType enemyType, int16_t x, int16_t y)
+{
+	for (Enemy& enemy : enemies)
+	{
+		if(!enemy.IsValid())
+		{
+			enemy.Init(enemyType, x, y);
+			return;
+		}
+	}		
+}
+
+// Doom-like difficulty curve: early levels are mostly zombiemen,
+// deeper levels bring sergeants, imps and finally demons
+static EnemyType PickEnemyType()
+{
+	uint8_t roll = (uint8_t)(Random() % 100);
+	uint8_t f = Game::floor;
+
+	if (f < 3)
+	{
+		if (roll < 55) return EnemyType::Spider;   // zombieman
+		if (roll < 85) return EnemyType::Bat;      // sergeant
+		return EnemyType::Mage;                    // imp
+	}
+	if (f < 6)
+	{
+		if (roll < 30) return EnemyType::Spider;
+		if (roll < 55) return EnemyType::Bat;
+		if (roll < 85) return EnemyType::Mage;
+		return EnemyType::Skeleton;                // demon
+	}
+	if (roll < 15) return EnemyType::Spider;
+	if (roll < 40) return EnemyType::Bat;
+	if (roll < 70) return EnemyType::Mage;
+	return EnemyType::Skeleton;
+}
+
+void EnemyManager::SpawnEnemies()
+{
+	for (uint8_t y = 0; y < Map::height; y++)
+	{
+		for (uint8_t x = 0; x < Map::width; x++)
+		{
+			if (Map::GetCellSafe(x, y) == CellType::Monster)
+			{
+				EnemyManager::Spawn(PickEnemyType(), x * CELL_SIZE + CELL_SIZE / 2, y * CELL_SIZE + CELL_SIZE / 2);
+				Map::SetCell(x, y, CellType::Empty);
+				break;
+			}
+		}
+	}
+	
+}
+
+Enemy* EnemyManager::GetOverlappingEnemy(Entity& entity)
+{
+	for (Enemy& enemy : enemies)
+	{
+		if (enemy.IsValid() && enemy.IsOverlappingEntity(entity))
+		{
+			return &enemy;
+		}
+	}
+
+	return nullptr;
+}
+
+Enemy* EnemyManager::GetOverlappingEnemy(int16_t x, int16_t y)
+{
+	for (Enemy& enemy : enemies)
+	{
+		if (enemy.IsValid() && enemy.IsOverlappingPoint(x, y))
+		{
+			return &enemy;
+		}
+	}
+
+	return nullptr;
+}
+

applications/system/FlipperDoom/game/Enemy.h

@@ -0,0 +1,100 @@
+#pragma once
+
+#include <stdint.h>
+#include "game/Entity.h"
+#include "game/Defines.h"
+#include "game/Draw.h"
+
+enum class EnemyType : uint8_t
+{
+	Skeleton,
+	Mage,
+	Bat,
+	Spider,
+	NumEnemyTypes,
+	None = NumEnemyTypes,
+	Exit,
+};
+
+enum class EnemyState : uint8_t
+{
+	Idle,
+	Moving,
+	Attacking,
+	Stunned,
+	Dying,
+	Dead
+};
+
+struct EnemyArchetype
+{
+	const uint16_t* spriteData;
+
+	uint8_t hp;
+	uint8_t movementSpeed;
+	uint8_t attackStrength;
+	uint8_t attackDuration;
+	uint8_t stunDuration;
+	uint8_t isRanged;
+	uint8_t spriteScale;
+	AnchorType spriteAnchor;
+
+	const uint16_t* GetSpriteData() const {return static_cast<const uint16_t*>(pgm_read_ptr_safe(&spriteData));}
+	uint8_t GetHP() const				{ return pgm_read_byte(&hp); }
+	uint8_t GetMovementSpeed() const	{ return pgm_read_byte(&movementSpeed); }
+	uint8_t GetAttackStrength() const	{ return pgm_read_byte(&attackStrength); }
+	uint8_t GetAttackDuration() const	{ return pgm_read_byte(&attackDuration); }
+	uint8_t GetStunDuration() const		{ return pgm_read_byte(&stunDuration); }
+	bool GetIsRanged() const			{ return pgm_read_byte(&isRanged) != 0; }
+	uint8_t GetSpriteScale() const		{ return pgm_read_byte(&spriteScale); }
+	AnchorType GetSpriteAnchor() const	{ return (AnchorType) pgm_read_byte(&spriteAnchor); }
+};
+
+class Enemy : public Entity
+{
+public:
+	void Init(EnemyType type, int16_t x, int16_t y);
+	void Tick();
+	bool IsValid() const { return type != EnemyType::None; }
+	void Damage(uint8_t amount);
+	void Clear() { type = EnemyType::None; }
+	const EnemyArchetype* GetArchetype() const;
+	EnemyState GetState() const { return state; }
+	EnemyType GetType() const { return type; }
+
+private:
+	static const EnemyArchetype archetypes[(int)EnemyType::NumEnemyTypes];
+
+	bool ShouldFireProjectile() const;
+	bool FireProjectile(uint8_t angle);
+	bool TryMove();
+	void StunMove();
+	bool TryFireProjectile();
+	void PickNewTargetCell();
+	bool TryPickCells(int8_t deltaX, int8_t deltaY);
+	bool TryPickCell(int8_t newX, int8_t newY);
+	uint8_t GetPlayerCellDistance() const;
+
+	EnemyType type : 3;
+	EnemyState state : 3;
+	uint8_t frameDelay : 2;
+	uint8_t hp;
+	uint8_t targetCellX, targetCellY;
+};
+
+class EnemyManager
+{
+public:
+	static constexpr int maxEnemies = 24; //24;
+	static Enemy enemies[maxEnemies];
+	
+	static void Spawn(EnemyType enemyType, int16_t x, int16_t y);
+	static void SpawnEnemies();
+
+	static Enemy* GetOverlappingEnemy(Entity& entity);
+	static Enemy* GetOverlappingEnemy(int16_t x, int16_t y);
+	
+	static void Init();
+	static void Draw();
+	static void Update();
+};

applications/system/FlipperDoom/game/Entity.cpp

@@ -0,0 +1,17 @@
+#include "game/Entity.h"
+#include "game/Game.h"
+#include "game/Map.h"
+
+#define ENTITY_SIZE 192
+
+bool Entity::IsOverlappingEntity(const Entity& other) const
+{
+	return (x >= other.x - ENTITY_SIZE && x <= other.x + ENTITY_SIZE
+		&& y >= other.y - ENTITY_SIZE && y <= other.y + ENTITY_SIZE);
+}
+
+bool Entity::IsOverlappingPoint(int16_t pointX, int16_t pointY) const
+{
+	return (pointX >= x - ENTITY_SIZE / 2 && pointX <= x + ENTITY_SIZE / 2
+		&& pointY >= y - ENTITY_SIZE / 2 && pointY <= y + ENTITY_SIZE / 2);
+}

applications/system/FlipperDoom/game/Entity.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <stdint.h>
+
+class Entity
+{
+public:
+	bool IsOverlappingPoint(int16_t pointX, int16_t pointY) const;
+	bool IsOverlappingEntity(const Entity& other) const;
+
+	int16_t x, y;
+};

applications/system/FlipperDoom/game/FixedMath.cpp

@@ -0,0 +1,19 @@
+// #include "FixedMath.h"
+
+// static uint16_t xs = 1;
+
+// uint16_t Random() {
+//     xs ^= xs << 7;
+//     xs ^= xs >> 9;
+//     xs ^= xs << 8;
+//     return xs;
+// }
+
+// void SeedRandom() {
+//     uint32_t r = furi_hal_random_get();
+//     xs = (uint16_t)(r ^ (r >> 16));
+// }
+
+// void SeedRandom(uint16_t seed) {
+//     xs = seed | 1;
+// }

applications/system/FlipperDoom/game/FixedMath.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <stdint.h>
+#include <furi.h>
+#include <furi_hal.h>
+#if defined(_WIN32)
+#include <math.h>
+#endif
+#include "game/Defines.h"
+
+#define FIXED_SHIFT       8
+#define FIXED_ONE         (1 << FIXED_SHIFT)
+#define INT_TO_FIXED(x)   ((x) * FIXED_ONE)
+#define FIXED_TO_INT(x)   ((x) >> 8)
+#define FLOAT_TO_FIXED(x) ((int16_t)((x) * FIXED_ONE))
+
+#ifndef ABS
+#define ABS(x) (((x) < 0) ? -(x) : (x))
+#endif
+
+#define FIXED_ANGLE_MAX           256
+#define FIXED_ANGLE_WRAP(x)       ((x) & 255)
+#define FIXED_ANGLE_45            (FIXED_ANGLE_90 / 2)
+#define FIXED_ANGLE_90            (FIXED_ANGLE_MAX / 4)
+#define FIXED_ANGLE_180           (FIXED_ANGLE_90 * 2)
+#define FIXED_ANGLE_270           (FIXED_ANGLE_90 * 3)
+#define FIXED_ANGLE_TO_RADIANS(x) ((x) * (2.0f * 3.141592654f / FIXED_ANGLE_MAX))
+
+extern const int16_t sinTable[FIXED_ANGLE_MAX] PROGMEM;
+
+inline int16_t FixedSin(uint8_t angle) {
+    return pgm_read_word(&sinTable[angle]);
+}
+
+inline int16_t FixedCos(uint8_t angle) {
+    return pgm_read_word(&sinTable[FIXED_ANGLE_WRAP(FIXED_ANGLE_90 - angle)]);
+}
+
+// uint16_t Random();
+// void SeedRandom();
+// void SeedRandom(uint16_t seed);
+
+inline uint16_t Random() {
+    uint32_t r = furi_hal_random_get();
+    return (uint16_t)(r ^ (r >> 16));
+}

applications/system/FlipperDoom/game/Font.cpp

@@ -0,0 +1,115 @@
+#include <stdint.h>
+#include "game/Defines.h"
+#include "game/Font.h"
+#include "game/Platform.h"
+#include "game/Generated/SpriteTypes.h"
+
+static inline uint8_t v3(uint8_t m)
+{
+    return m | (m << 1) | (m >> 1);
+}
+
+static inline void apply4(uint8_t* dst, uint8_t a, uint8_t b, uint8_t c, uint8_t d, uint8_t xorMask)
+{
+    if (xorMask)
+    {
+        dst[0] |= a;
+        dst[1] |= b;
+        dst[2] |= c;
+        dst[3] |= d;
+    }
+    else
+    {
+        dst[0] &= ~a;
+        dst[1] &= ~b;
+        dst[2] &= ~c;
+        dst[3] &= ~d;
+    }
+}
+
+static inline void apply1(uint8_t* dst, uint8_t m, uint8_t xorMask)
+{
+    if (xorMask) *dst |= m;
+    else *dst &= ~m;
+}
+
+void Font::PrintString(const char* str, uint8_t line, uint8_t x, uint8_t colour)
+{
+    uint8_t* p = Platform::GetScreenBuffer() + DISPLAY_WIDTH * line + x;
+    uint8_t xorMask = (colour == COLOUR_BLACK) ? 0 : 0xff;
+
+    for (;;)
+    {
+        char c = *str++;
+        if (!c) break;
+        DrawChar(p, c, xorMask);
+        p += glyphWidth;
+    }
+}
+
+void Font::PrintInt(uint16_t val, uint8_t line, uint8_t x, uint8_t colour)
+{
+    uint8_t* p = Platform::GetScreenBuffer() + DISPLAY_WIDTH * line + x;
+    uint8_t xorMask = (colour == COLOUR_BLACK) ? 0 : 0xff;
+
+    if (val == 0)
+    {
+        DrawChar(p, '0', xorMask);
+        return;
+    }
+
+    char buf[5];
+    int n = 0;
+
+    while (val && n < 5)
+    {
+        buf[n++] = (char)('0' + (val % 10));
+        val /= 10;
+    }
+
+    while (n--)
+    {
+        DrawChar(p, buf[n], xorMask);
+        p += glyphWidth;
+    }
+}
+
+void Font::DrawChar(uint8_t* p, char c, uint8_t xorMask)
+{
+    uint8_t uc = (uint8_t)c;
+    if (uc < firstGlyphIndex) return;
+
+    const uint8_t* f = fontPageData + glyphWidth * (uc - firstGlyphIndex);
+
+    uint8_t i0 = ~f[0];
+    uint8_t i1 = ~f[1];
+    uint8_t i2 = ~f[2];
+    uint8_t i3 = ~f[3];
+
+    uint8_t t0 = v3(i0 | i1);
+    uint8_t t1 = v3(i0 | i1 | i2);
+    uint8_t t2 = v3(i1 | i2 | i3);
+    uint8_t t3 = v3(i2 | i3);
+
+    uint8_t r0 = t0 & ~i0;
+    uint8_t r1 = t1 & ~i1;
+    uint8_t r2 = t2 & ~i2;
+    uint8_t r3 = t3 & ~i3;
+
+    uint8_t outlineMask = xorMask ^ 0xff;
+
+    // The outline spills one byte to each side of the glyph. Clamp it to the
+    // screen buffer: with x == 0 on the first line `p - 1` lands on the heap
+    // block header of FlipperState (back_buffer is its first member) and the
+    // `|=`/`&=` write corrupts the allocator metadata -- the game keeps
+    // running fine but the firmware crashes/hangs later, when the app frees
+    // its state on exit.
+    uint8_t* bufStart = Platform::GetScreenBuffer();
+    uint8_t* bufEnd = bufStart + (DISPLAY_WIDTH * DISPLAY_HEIGHT / 8);
+
+    if (p - 1 >= bufStart) apply1(p - 1, v3(i0), outlineMask);
+    apply4(p, r0, r1, r2, r3, outlineMask);
+    if (p + 4 < bufEnd) apply1(p + 4, v3(i3), outlineMask);
+
+    apply4(p, i0, i1, i2, i3, xorMask);
+}

applications/system/FlipperDoom/game/Font.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <stdint.h>
+#include "game/Defines.h"
+
+#define FONT_WIDTH 4
+#define FONT_HEIGHT 6
+
+class Font
+{
+public:
+	static constexpr int glyphWidth = 4;
+	static constexpr int glyphHeight = 8;
+	static constexpr int firstGlyphIndex = 32;
+
+	static void PrintString(const char* str, uint8_t line, uint8_t x, uint8_t colour = COLOUR_BLACK);
+	static void PrintInt(uint16_t value, uint8_t line, uint8_t x, uint8_t xorMask = COLOUR_BLACK);
+
+private:
+	static void DrawChar(uint8_t* screenPtr, char c, uint8_t xorMask);
+};

applications/system/FlipperDoom/game/Game.cpp

@@ -0,0 +1,166 @@
+#include "game/Defines.h"
+#include "game/Game.h"
+#include "game/FixedMath.h"
+#include "game/Draw.h"
+#include "game/Map.h"
+#include "game/Projectile.h"
+#include "game/Particle.h"
+#include "game/MapGenerator.h"
+#include "game/Platform.h"
+#include "game/Entity.h"
+#include "game/Enemy.h"
+#include "game/Menu.h"
+
+Player Game::player;
+const char* Game::displayMessage = nullptr;
+uint8_t Game::displayMessageTime = 0;
+Game::State Game::state = Game::State::Menu;
+uint8_t Game::floor = 1;
+uint8_t Game::globalTickFrame = 0;
+Stats Game::stats;
+Menu Game::menu;
+
+void Game::Init() {
+    menu.Init();
+    ParticleSystemManager::Init();
+    ProjectileManager::Init();
+    EnemyManager::Init();
+}
+
+bool Game::InMenu() {
+    return (state != State::InGame);
+}
+
+void Game::GoToMenu() {
+    Game::stats.killedBy = EnemyType::Exit;
+    SwitchState(State::FadeOut);
+}
+
+void Game::StartGame() {
+    floor = 1;
+    stats.Reset();
+    player.Init();
+    SwitchState(State::EnteringLevel);
+}
+
+void Game::SwitchState(State newState) {
+    if(state != newState) {
+        state = newState;
+        menu.ResetTimer();
+    }
+}
+
+void Game::ShowMessage(const char* message) {
+    constexpr uint8_t messageDisplayTime = 90;
+
+    displayMessage = message;
+    displayMessageTime = messageDisplayTime;
+}
+
+void Game::NextLevel() {
+    if(floor == 10) {
+        GameOver();
+    } else {
+        floor++;
+        SwitchState(State::EnteringLevel);
+    }
+}
+
+void Game::StartLevel() {
+    ParticleSystemManager::Init();
+    ProjectileManager::Init();
+    EnemyManager::Init();
+    MapGenerator::Generate();
+    EnemyManager::SpawnEnemies();
+
+    player.NextLevel();
+    SwitchState(State::InGame);
+}
+
+void Game::Draw() {
+    switch(state) {
+    case State::Menu:
+        menu.Draw();
+        break;
+    case State::EnteringLevel:
+        menu.DrawEnteringLevel();
+        break;
+    // case State::TransitionToLevel:
+    //     menu.TransitionToLevel();
+    //     break;
+    case State::InGame: {
+        Renderer::camera.x = player.x;
+        Renderer::camera.y = player.y;
+        Renderer::camera.angle = player.angle;
+        Renderer::Render();
+    } break;
+    case State::GameOver:
+        menu.DrawGameOver();
+        break;
+    case State::FadeOut:
+        menu.FadeOut();
+        break;
+    default:
+        break;
+    }
+}
+
+void Game::TickInGame() {
+    if(displayMessageTime > 0) {
+        displayMessageTime--;
+        if(displayMessageTime == 0) displayMessage = nullptr;
+    }
+
+    player.Tick();
+
+    ProjectileManager::Update();
+    ParticleSystemManager::Update();
+    EnemyManager::Update();
+
+    if(Map::GetCellSafe(player.x / CELL_SIZE, player.y / CELL_SIZE) == CellType::Exit) {
+        NextLevel();
+    }
+
+    if(player.hp == 0) {
+        GameOver();
+    }
+}
+
+void Game::Tick() {
+    globalTickFrame++;
+
+    switch(state) {
+    case State::InGame:
+        TickInGame();
+        return;
+    case State::EnteringLevel:
+        menu.TickEnteringLevel();
+        return;
+    case State::Menu:
+        menu.Tick();
+        return;
+    case State::GameOver:
+        menu.TickGameOver();
+        return;
+    // case State::TransitionToLevel:
+    //     return;
+    default:
+        return;
+    }
+}
+
+void Game::GameOver() {
+    SwitchState(State::FadeOut);
+}
+
+void Stats::Reset() {
+    killedBy = EnemyType::None;
+    chestsOpened = 0;
+    coinsCollected = 0;
+    crownsCollected = 0;
+    scrollsCollected = 0;
+
+    for(uint8_t& killCounter : enemyKills) {
+        killCounter = 0;
+    }
+}

applications/system/FlipperDoom/game/Game.h

@@ -0,0 +1,63 @@
+#pragma once
+
+#include <stdint.h>
+#include "game/Defines.h"
+#include "game/Player.h"
+#include "game/Enemy.h"
+#include "game/Menu.h"
+
+class Entity;
+
+struct Stats {
+    EnemyType killedBy;
+    uint8_t enemyKills[(int)EnemyType::NumEnemyTypes];
+    uint8_t chestsOpened;
+    uint8_t crownsCollected;
+    uint8_t scrollsCollected;
+    uint8_t coinsCollected;
+
+    void Reset();
+};
+
+class Game {
+public:
+    static Menu menu;
+    static uint8_t globalTickFrame;
+
+    enum class State : uint8_t {
+        Menu,
+        EnteringLevel,
+        InGame,
+        GameOver,
+        FadeOut,
+        // TransitionToLevel
+    };
+
+    static void Init();
+    static void Tick();
+    static void Draw();
+
+    static bool InMenu();
+    static void GoToMenu();
+
+    static void StartGame();
+    static void StartLevel();
+    static void NextLevel();
+    static void GameOver();
+
+    static void SwitchState(State newState);
+
+    static void ShowMessage(const char* message);
+
+    static Player player;
+
+    static const char* displayMessage;
+    static uint8_t displayMessageTime;
+    static uint8_t floor;
+
+    static Stats stats;
+
+private:
+    static void TickInGame();
+    static State state;
+};

applications/system/FlipperDoom/game/Generated/DoomSprites.inc.h

@@ -0,0 +1,204 @@
+// Auto-generated by tools/extract_doom_assets.py
+// Derived at build time from the user's local Doom shareware WAD.
+// Do not commit WAD-derived data to public repositories.
+
+constexpr uint8_t skeletonSpriteData_numFrames = 2;
+extern const uint16_t skeletonSpriteData[] PROGMEM =
+{
+	0x0,0x0,0x0,0x0,0x1fc,0x144,0xffc,0xfac,0x7ffe,0x416,0x3ffe,0x2e,0x7ff,0x455,0x7fe,0x3e,
+	0x4ffe,0x4476,0xfffe,0x2022,0xfe3e,0x7016,0xc9fe,0x802,0x1e0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+	0x0,0x0,0x0,0x0,0x3f0,0x150,0x3fc,0x200,0x103e,0x1016,0x7ffe,0x82e,0x3ffe,0x1476,0x17ff,0x23a,
+	0x7ff,0x41f,0x4ffe,0x23e,0xfffe,0x7056,0xfe1e,0x2802,0x3fe,0x114,0x3f0,0x2a0,0x0,0x0,0x0,0x0
+};
+constexpr uint8_t mageSpriteData_numFrames = 2;
+extern const uint16_t mageSpriteData[] PROGMEM =
+{
+	0x0,0x0,0x0,0x0,0x0,0x0,0x3e0,0x0,0x78,0x8,0x38,0x8,0xbffe,0x414,0xffff,0x800a,
+	0x83ff,0x15,0x7ffe,0xa,0x7ff8,0x1010,0x238,0x8,0x3f0,0x10,0x1c0,0x80,0x0,0x0,0x0,0x0,
+	0x0,0x0,0x0,0x0,0x1e0,0x0,0x1f8,0x8,0x38,0x8,0x1ffc,0x8c,0x7fff,0x1107,0x17ff,0x8f,
+	0xffff,0x517,0xfff8,0xa618,0x1b8,0x8,0xf8,0xa8,0x60,0x40,0x0,0x0,0x0,0x0,0x0,0x0
+};
+constexpr uint8_t batSpriteData_numFrames = 2;
+extern const uint16_t batSpriteData[] PROGMEM =
+{
+	0x0,0x0,0x0,0x0,0x0,0x0,0xf8,0x20,0x1f8,0x70,0xffc,0x88,0x1fff,0x47,0xffff,0x8023,
+	0xfffe,0x4406,0x3f8,0x0,0x38,0x10,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+	0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x20,0x1f8,0x50,0xff8,0x8,0x5fff,0x47,0x7fff,0x23,
+	0x7fff,0x7,0xfff8,0x0,0x378,0x10,0x78,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0
+};
+constexpr uint8_t spiderSpriteData_numFrames = 2;
+extern const uint16_t spiderSpriteData[] PROGMEM =
+{
+	0x0,0x0,0x0,0x0,0x78,0x50,0xf8,0x78,0x7fc,0x4c,0xfff,0xa,0xffff,0x17,0xffff,0x2a2a,
+	0x3ffc,0x1004,0x38,0x8,0x30,0x10,0x30,0x20,0x8,0x0,0x8,0x0,0x0,0x0,0x0,0x0,
+	0x0,0x0,0x0,0x0,0x60,0x40,0x1f8,0x78,0x7f8,0x58,0x1fff,0x20a,0x7fff,0x17,0x3fff,0x2a,
+	0xfff8,0x10,0x778,0x8,0x78,0x10,0x38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0
+};
+constexpr uint8_t projectileSpriteData_numFrames = 1;
+extern const uint16_t projectileSpriteData[] PROGMEM =
+{
+	0x7e0,0x100,0x1ff8,0x2a0,0x3ffc,0x550,0x7ffe,0xaa8,0x7ffe,0x554,0xffff,0x2bea,0xffff,0x57f4,0xffff,0x2ffa,
+	0xffff,0x57f4,0xffff,0x2bea,0xffff,0x57d4,0x7ffe,0x2baa,0x7ffe,0x1554,0x3ffc,0xaa0,0x1ff8,0x540,0x7e0,0x280
+};
+constexpr uint8_t enemyProjectileSpriteData_numFrames = 1;
+extern const uint16_t enemyProjectileSpriteData[] PROGMEM =
+{
+	0x7e0,0x0,0x1ff8,0x220,0x3ffc,0x554,0x7ffe,0xaaa,0x7ffe,0x1554,0xffff,0x2fea,0xffff,0x17f4,0xffff,0x2fea,
+	0xffff,0x57f5,0xffff,0x2bea,0xffff,0x57f4,0x7ffe,0x2fea,0x7ffe,0x15d4,0x3ffc,0x2aa8,0x1ff8,0x550,0x7e0,0x280
+};
+constexpr uint8_t torchSpriteData1_numFrames = 1;
+extern const uint16_t torchSpriteData1[] PROGMEM =
+{
+	0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x0,0xc0f0,0xc020,
+	0xc0f8,0x4070,0x8000,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0
+};
+constexpr uint8_t torchSpriteData2_numFrames = 1;
+extern const uint16_t torchSpriteData2[] PROGMEM =
+{
+	0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x8000,0xc070,0xc050,0xfff8,0xea38,
+	0xc070,0xc050,0x8000,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0
+};
+constexpr uint8_t urnSpriteData_numFrames = 1;
+extern const uint16_t urnSpriteData[] PROGMEM =
+{
+	0x0,0x0,0x0,0x0,0x7ffe,0x7ffe,0xffff,0xffee,0xffff,0x5dfd,0xffff,0xaaaa,0xffff,0x5557,0xffff,0x8aa,
+	0xffff,0x5547,0xffff,0xb,0xffff,0x1101,0xffff,0x3,0xffff,0x1,0xffff,0x0,0x0,0x0,0x0,0x0
+};
+constexpr uint8_t potionSpriteData_numFrames = 1;
+extern const uint16_t potionSpriteData[] PROGMEM =
+{
+	0xfffc,0x5554,0xfffe,0xafbe,0xffff,0x575f,0xffff,0xaebf,0xffff,0x555f,0xffff,0xa2bf,0xffff,0x57f,0xffff,0x82ff,
+	0xffff,0x55f,0xffff,0xa2bf,0xffff,0x555f,0xffff,0xaabf,0xffff,0x575f,0xfffe,0xaebe,0xfffc,0x1554,0x0,0x0
+};
+constexpr uint8_t chestSpriteData_numFrames = 1;
+extern const uint16_t chestSpriteData[] PROGMEM =
+{
+	0x0,0x0,0x0,0x0,0xfffc,0x1554,0xffff,0xaebe,0xffff,0x477f,0xfffe,0xaaae,0xfffc,0x4574,0xfffc,0xa0bc,
+	0xfffc,0x457c,0xfffc,0xaaac,0xfffe,0x5776,0xffff,0xaabe,0xffff,0x457e,0xfffc,0x22a0,0x0,0x0,0x0,0x0
+};
+constexpr uint8_t chestOpenSpriteData_numFrames = 1;
+extern const uint16_t chestOpenSpriteData[] PROGMEM =
+{
+	0x0,0x0,0xfffe,0xaaaa,0xffff,0x5557,0xffff,0x2aab,0xffff,0x5,0xffff,0x28ab,0xffff,0x1557,0xffff,0x2b,
+	0xffff,0x1555,0xffff,0x28ab,0xffff,0x5,0xffff,0x2aab,0xffff,0x5557,0xfffe,0xaaaa,0x0,0x0,0x0,0x0
+};
+constexpr uint8_t scrollSpriteData_numFrames = 1;
+extern const uint16_t scrollSpriteData[] PROGMEM =
+{
+	0x3fc0,0x1540,0x7ff0,0x2aa0,0xfff8,0x5550,0xfffc,0xe2a8,0x3ffc,0x1d4,0x3ffe,0x3fa,0xfffe,0x45fc,0xfffe,0xabfe,
+	0xfffe,0x55fc,0xfffe,0x2bfe,0x3ffe,0x35c,0x3ffc,0x2a8,0xfffc,0xf154,0xfff8,0xaaa8,0x7ff0,0x5550,0x3fc0,0x2a80
+};
+constexpr uint8_t coinsSpriteData_numFrames = 1;
+extern const uint16_t coinsSpriteData[] PROGMEM =
+{
+	0x0,0x0,0x0,0x0,0x1e00,0x1000,0x3f80,0x2000,0x7fc0,0x4500,0xffc0,0x8000,0xfffe,0x4000,0xffff,0x2,
+	0xffff,0x15,0xfffe,0x82,0xffc0,0x540,0x7fc0,0xa80,0x3f80,0x1500,0x1e00,0x800,0x0,0x0,0x0,0x0
+};
+constexpr uint8_t crownSpriteData_numFrames = 1;
+extern const uint16_t crownSpriteData[] PROGMEM =
+{
+	0x300,0x100,0x380,0x380,0x780,0x180,0x1f80,0x380,0x7f80,0x4780,0xff80,0xae80,0xff80,0x5600,0xff00,0xaa00,
+	0xff00,0x5400,0xff80,0xaa00,0xff80,0x4700,0x7f80,0x380,0x1f80,0x580,0x780,0x380,0x380,0x180,0x300,0x200
+};
+constexpr uint8_t signSpriteData_numFrames = 1;
+extern const uint16_t signSpriteData[] PROGMEM =
+{
+	0x0,0x0,0xc000,0x0,0xc000,0x4000,0xc000,0x8000,0xc000,0xc000,0xc000,0x8000,0xc000,0x4000,0xc000,0x8000,
+	0xc000,0x4000,0xe000,0xe000,0xe000,0x4000,0xc000,0x8000,0xc000,0x4000,0xc000,0xc000,0x0,0x0,0x0,0x0
+};
+extern const uint8_t handSpriteData1[] PROGMEM =
+{
+	0x2e,0x1c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+	0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x0,0xe0,0x8,0xf8,0x4,0xfc,
+	0x0,0xfc,0x0,0xff,0x8,0xfc,0x4,0xfc,0x8,0xf8,0x0,0xe0,0x80,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+	0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+	0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x80,0x80,0x40,0xc0,0x80,0xc0,0x40,0xc0,0xa0,0xe0,0x40,0xe0,
+	0xa0,0xe0,0x10,0xf0,0x0,0xf0,0x0,0xf0,0x0,0xf8,0x10,0xfe,0x0,0xff,0x0,0xff,0x0,0xff,0x10,0xff,0x0,0xff,0x0,0xff,
+	0x0,0xff,0x10,0xff,0x0,0xff,0x0,0xff,0x0,0xff,0x10,0xfe,0x0,0xf8,0x10,0xf0,0x0,0xe0,0x0,0xe0,0x80,0xc0,0x0,0x80,
+	0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+	0x0,0x0,0x0,0xe0,0x80,0xfe,0x40,0xff,0xaa,0xff,0x55,0xff,0xaa,0xff,0x57,0xff,0x2f,0xff,0x5,0xff,0x0,0xff,0x0,0xff,
+	0x20,0xff,0x60,0xff,0x62,0xff,0x60,0xff,0x60,0xff,0x60,0xff,0x20,0xff,0x20,0xff,0x20,0xff,0x0,0xff,0x20,0xff,0x20,0xff,
+	0x20,0xff,0x60,0xff,0x60,0xff,0x60,0xff,0x22,0xff,0x60,0xff,0x20,0xff,0x50,0xff,0x0,0xff,0x1,0xff,0x0,0xfe,0x40,0xe0,
+	0x80,0xc0,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xa,0xe,0x5,0xf,
+	0xa,0xf,0x5,0xf,0x2,0xf,0x1,0xf,0x0,0xf,0x0,0xf,0x0,0xf,0x0,0xf,0x0,0xf,0x0,0xf,0x0,0xf,0x0,0xf,
+	0x0,0xf,0x0,0xf,0x0,0xf,0x0,0xf,0x0,0xf,0x0,0xf,0x0,0xf,0x0,0xf,0x0,0xf,0x0,0xf,0x0,0xf,0x0,0xf,
+	0x0,0xf,0x0,0xf,0x0,0xf,0x0,0xf,0x0,0xf,0x0,0xf,0x0,0xf,0x0,0xf,0x0,0xf,0x0,0xf,0x0,0xf,0x0,0xf,
+	0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0
+};
+extern const uint8_t handSpriteData2[] PROGMEM =
+{
+	0x2e,0x26,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x6,0x45,0xe7,
+	0xa8,0xff,0x4,0xff,0xa,0xff,0x5,0xff,0xa,0xff,0x45,0xff,0xae,0xff,0x3f,0x3f,0xf,0xf,0x3,0x3,0x0,0x0,0x0,0x0,
+	0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x3,0xf,0xf,0x3f,0x3f,0xae,0xff,0x45,0xff,0xa,0xff,0x4,0xff,
+	0xa,0xff,0x4,0xff,0xaa,0xff,0x15,0x37,0x2,0x6,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+	0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,
+	0x0,0x1,0x0,0x1,0x0,0x1,0x0,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x80,0xa0,0xe0,0x50,0xf0,0xa0,0xf0,0x44,0xfc,
+	0xa0,0xf0,0x50,0xf0,0xa0,0xe0,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x0,0x3,0x0,0x3,0x2,0x3,0x1,0x1,
+	0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+	0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x80,0x80,0x80,0x80,0x80,0x40,0xc0,
+	0x80,0xc0,0x40,0xc0,0xa0,0xe0,0x50,0xf8,0xaa,0xfe,0x55,0xff,0xaa,0xff,0x55,0xff,0xaa,0xff,0x55,0xff,0xaa,0xff,0x55,0xff,
+	0xaa,0xff,0x55,0xff,0xaa,0xfe,0x50,0xf8,0xa0,0xe0,0x40,0xc0,0x80,0x80,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+	0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,
+	0xa8,0xf8,0x54,0xfe,0xaa,0xfe,0x55,0xff,0xff,0xff,0xfd,0xff,0xff,0xff,0x1d,0xff,0x8a,0xff,0x55,0xff,0xaa,0xff,0xd5,0xff,
+	0x88,0xff,0x88,0xff,0x88,0xff,0x80,0xff,0x80,0xff,0x80,0xff,0x80,0xff,0x0,0xff,0x80,0xff,0x80,0xff,0x80,0xff,0x80,0xff,
+	0x88,0xff,0x88,0xff,0x88,0xff,0xd5,0xff,0xaa,0xff,0x51,0xff,0x82,0xff,0x14,0xfe,0xa8,0xf8,0x0,0x80,0x0,0x0,0x0,0x0,
+	0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x28,0x38,0x15,0x3f,0x2a,0x3f,0x1d,0x3f,
+	0x2a,0x3f,0x17,0x3f,0xb,0x3f,0x1,0x3f,0x8,0x3f,0x5,0x3f,0x0,0x3f,0x1,0x3f,0x0,0x3f,0x1,0x3f,0x1,0x3f,0x1,0x3f,
+	0x3,0x3f,0x1,0x3f,0x0,0x3f,0x1,0x3f,0x0,0x3f,0x1,0x3f,0x0,0x3f,0x1,0x3f,0x0,0x3f,0x1,0x3f,0x3,0x3f,0x1,0x3f,
+	0x1,0x3f,0x1,0x3f,0x1,0x3f,0x1,0x3f,0x0,0x3f,0x5,0x3f,0x0,0x3f,0x5,0x3f,0xa,0x3f,0x14,0x3e,0x0,0x0,0x0,0x0,
+	0x0,0x0,0x0,0x0,0x0,0x0
+};
+extern const uint8_t titleBitmapData[] PROGMEM =
+{
+	0x80,0x40,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x0,0x0,0x0,0x0,
+	0x0,0x0,0x0,0x0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0xff,0xff,
+	0xff,0xff,0xff,0xff,0xf,0xf,0xf,0xf,0x0,0x0,0x0,0x0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,
+	0x0,0x0,0x0,0x0,0xf,0xf,0xf,0xf,0xff,0xff,0xff,0xff,0xf,0xf,0xf,0xf,0x0,0x0,0x0,0x0,0xf0,0xf0,0xf0,0xf0,
+	0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0x0,0x0,0x0,0x0,0xf,0xf,0xf,0xf,0xff,0xff,0xff,0xff,0x0,0x0,0x0,0x0,
+	0x0,0x0,0x0,0x0,0xf,0xf,0xf,0xf,0xff,0xff,0xff,0xff,0xf,0xf,0xf,0xf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+	0xff,0xff,0xff,0xff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xf0,0xf0,0xf0,0xf0,
+	0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0xff,0xff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0xff,0xff,
+	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0xff,0xff,0x0,0x0,0x0,0x0,
+	0x0,0x0,0x0,0x0,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+	0xff,0xff,0xff,0xff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf0,0xf0,0xf0,0xf0,0x0,0x0,0x0,0x0,0xf0,0xf0,0xf0,0xf0,
+	0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0xff,0xff,0xa0,0x50,0xa0,0x50,0xa0,0x50,0xa0,0x50,0xff,0xff,0xff,0xff,
+	0xff,0xff,0xff,0xff,0xaf,0x5f,0xaf,0x5f,0xa0,0x50,0xa0,0x50,0xa0,0x50,0xa0,0x50,0xff,0xff,0xff,0xff,0xa0,0x50,0xa0,0x50,
+	0xa0,0x50,0xa0,0x50,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xa0,0x50,0xa0,0x50,0xa0,0x50,0xa0,0x50,
+	0xff,0xff,0xff,0xff,0xa0,0x50,0xa0,0x50,0xa0,0x50,0xa0,0x50,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+	0xa0,0x50,0xa0,0x50,0xa0,0x50,0xa0,0x50,0xff,0xff,0xff,0xff,0xa0,0x50,0xa0,0x50,0xa0,0x50,0xa0,0x50,0xff,0xff,0xff,0xff,
+	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xa0,0x50,0xa0,0x50,0xa0,0x50,0xa0,0x50,0xff,0xff,0xff,0xff,0xaa,0x55,0xaa,0x55,
+	0xaa,0x55,0xaa,0x55,0xaf,0x5f,0xaf,0x5f,0xaf,0x5f,0xaf,0x5f,0xaa,0x55,0xaa,0x55,0xaa,0x55,0xaa,0x55,0xff,0xff,0xff,0xff,
+	0xff,0xff,0xff,0xff,0xfa,0xf5,0xfa,0xf5,0xaa,0x55,0xaa,0x55,0xaf,0x5f,0xaf,0x5f,0xaf,0x5f,0xaf,0x5f,0xaf,0x5f,0xaf,0x5f,
+	0xaa,0x55,0xaa,0x55,0xfa,0xf5,0xfa,0xf5,0xff,0xff,0xff,0xff,0xfa,0xf5,0xfa,0xf5,0xaa,0x55,0xaa,0x55,0xaf,0x5f,0xaf,0x5f,
+	0xaf,0x5f,0xaf,0x5f,0xaf,0x5f,0xaf,0x5f,0xaa,0x55,0xaa,0x55,0xfa,0xf5,0xfa,0xf5,0xff,0xff,0xff,0xff,0xaa,0x55,0xaa,0x55,
+	0xaa,0x55,0xaa,0x55,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xaa,0x55,0xaa,0x55,0xaa,0x55,0xaa,0x55,
+	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
+};
+extern const uint8_t heartSpriteData[] PROGMEM =
+{
+0x1c,0x14,0x77,0x41,0x77,0x14,0x1c,0x0
+};
+extern const uint8_t manaSpriteData[] PROGMEM =
+{
+0x7e,0x7f,0x7e,0x0,0x7f,0x7e,0x7e,0x0
+};

applications/system/FlipperDoom/game/Generated/SpriteData.inc.h

@@ -0,0 +1,24 @@
+// Engine assets kept from FlipperCatacombs (non-Doom): gates, wall texture, font
+// Generated from Images/entrance.png
+constexpr uint8_t entranceSpriteData_numFrames = 1;
+extern const uint16_t entranceSpriteData[] PROGMEM =
+{
+	0x4,0x0,0xe,0x0,0xe,0x0,0x1f,0x0,0x3ff,0x3fc,0x9f,0x90,0x9f,0x90,0x9f,0x90,0x9f,0x90,0x9f,0x90,0x9f,0x90,0x3ff,0x3fc,0x1f,0x0,0xe,0x0,0xe,0x0,0x4,0x0
+};
+// Generated from Images/exit.png
+constexpr uint8_t exitSpriteData_numFrames = 1;
+extern const uint16_t exitSpriteData[] PROGMEM =
+{
+	0x2000,0x0,0x7000,0x0,0x7000,0x0,0xf800,0x0,0xffc0,0x3fc0,0xf900,0x900,0xf900,0x900,0xf900,0x900,0xf900,0x900,0xf900,0x900,0xf900,0x900,0xffc0,0x3fc0,0xf800,0x0,0x7000,0x0,0x7000,0x0,0x2000,0x0
+};
+// Generated from Images/textures.png
+constexpr uint8_t wallTextureData_numTextures = 1;
+extern const uint16_t wallTextureData[] PROGMEM =
+{
+	0xf3cf,0xf3cf,0xf3cf,0xf3c0,0xf3c0,0xf3cf,0x3cf,0x3cf,0xf3cf,0xf3cf,0xf00f,0xf00f,0xf3cf,0xf3cf,0xf3cf,0xf3cf
+};
+// Generated from Images/font.png
+extern const uint8_t fontPageData[] PROGMEM =
+{
+0xff,0xff,0xff,0xff,0xff,0xd1,0xff,0xff,0xf9,0xff,0xf9,0xff,0xc1,0xeb,0xc1,0xff,0xd3,0xc1,0xe5,0xff,0xcd,0xf7,0xd9,0xff,0xcb,0xd5,0xeb,0xff,0xff,0xf9,0xff,0xff,0xff,0xe3,0xdd,0xff,0xff,0xdd,0xe3,0xff,0xeb,0xf7,0xeb,0xff,0xf7,0xe3,0xf7,0xff,0xdf,0xef,0xff,0xff,0xf7,0xf7,0xf7,0xff,0xff,0xdf,0xff,0xff,0xcf,0xf7,0xf9,0xff,0xc3,0xdd,0xe1,0xff,0xdb,0xc1,0xdf,0xff,0xcd,0xd5,0xd3,0xff,0xdd,0xd5,0xeb,0xff,0xe1,0xef,0xc7,0xff,0xd1,0xd5,0xe5,0xff,0xc3,0xd5,0xe5,0xff,0xcd,0xf5,0xf9,0xff,0xc3,0xd5,0xe1,0xff,0xd3,0xd5,0xe1,0xff,0xff,0xeb,0xff,0xff,0xdf,0xeb,0xff,0xff,0xf7,0xeb,0xdd,0xff,0xeb,0xeb,0xeb,0xff,0xdd,0xeb,0xf7,0xff,0xfd,0xd5,0xf9,0xff,0xe3,0xdd,0xd3,0xff,0xc3,0xf5,0xc1,0xff,0xc3,0xd5,0xe9,0xff,0xe3,0xdd,0xdd,0xff,0xc1,0xdd,0xe3,0xff,0xc3,0xd5,0xd5,0xff,0xc3,0xf5,0xf5,0xff,0xe3,0xdd,0xc5,0xff,0xc1,0xf7,0xc1,0xff,0xdd,0xc1,0xdd,0xff,0xef,0xdd,0xe1,0xff,0xc1,0xf7,0xc9,0xff,0xc1,0xdf,0xdf,0xff,0xc1,0xfb,0xc1,0xff,0xc1,0xfd,0xc3,0xff,0xe3,0xdd,0xe3,0xff,0xc1,0xf5,0xf3,0xff,0xe3,0xcd,0xc1,0xff,0xc3,0xf5,0xc9,0xff,0xdb,0xd5,0xed,0xff,0xfd,0xc1,0xfd,0xff,0xe1,0xdf,0xc1,0xff,0xe1,0xdf,0xe1,0xff,0xc1,0xef,0xc1,0xff,0xc9,0xf7,0xc9,0xff,0xf9,0xc7,0xf9,0xff,0xcd,0xd5,0xd9,0xff,0xff,0xc1,0xdd,0xff,0xf9,0xf7,0xcf,0xff,0xff,0xdd,0xc1,0xff,0xfb,0xfd,0xfb,0xff,0xdf,0xdf,0xdf,0xff,0xff,0xfd,0xfb,0xff,0xe7,0xdb,0xc3,0xff,0xc1,0xdb,0xe7,0xff,0xe7,0xdb,0xdb,0xff,0xe7,0xdb,0xc1,0xff,0xe7,0xcb,0xd3,0xff,0xc3,0xed,0xfb,0xff,0xb7,0xab,0xc7,0xff,0xc1,0xf7,0xcf,0xff,0xff,0xe5,0xdf,0xff,0xbf,0xcb,0xff,0xff,0xc1,0xf7,0xcb,0xff,0xff,0xe1,0xdf,0xff,0xc3,0xf7,0xc3,0xff,0xc3,0xfb,0xc7,0xff,0xe7,0xdb,0xe7,0xff,0x83,0xdb,0xe7,0xff,0xe7,0xdb,0x83,0xff,0xc3,0xf7,0xfb,0xff,0xd7,0xd3,0xeb,0xff,0xe1,0xdb,0xdf,0xff,0xe3,0xdf,0xc3,0xff,0xc3,0xdf,0xe3,0xff,0xc3,0xef,0xc3,0xff,0xcb,0xf7,0xcb,0xff,0xf3,0xaf,0xc3,0xff,0xdb,0xcb,0xd3,0xff,0xf7,0xc1,0xdd,0xff,0xff,0xc1,0xff,0xff,0xdd,0xc1,0xf7,0xff,0xfb,0xfd,0xfb,0xff,0xe3,0xed,0xe3,0xff
+};

applications/system/FlipperDoom/game/Generated/SpriteTypes.h

@@ -0,0 +1,48 @@
+// Declarations for assets generated by tools/extract_doom_assets.py
+// (converted at build time from the user's local Doom shareware WAD)
+constexpr uint8_t skeletonSpriteData_numFrames = 2;
+extern const uint16_t skeletonSpriteData[]; // demon
+constexpr uint8_t mageSpriteData_numFrames = 2;
+extern const uint16_t mageSpriteData[]; // imp
+constexpr uint8_t torchSpriteData1_numFrames = 1;
+extern const uint16_t torchSpriteData1[];
+constexpr uint8_t torchSpriteData2_numFrames = 1;
+extern const uint16_t torchSpriteData2[];
+constexpr uint8_t projectileSpriteData_numFrames = 1;
+extern const uint16_t projectileSpriteData[];
+constexpr uint8_t enemyProjectileSpriteData_numFrames = 1;
+extern const uint16_t enemyProjectileSpriteData[];
+constexpr uint8_t entranceSpriteData_numFrames = 1;
+extern const uint16_t entranceSpriteData[];
+constexpr uint8_t exitSpriteData_numFrames = 1;
+extern const uint16_t exitSpriteData[];
+constexpr uint8_t urnSpriteData_numFrames = 1;
+extern const uint16_t urnSpriteData[]; // barrel
+constexpr uint8_t signSpriteData_numFrames = 1;
+extern const uint16_t signSpriteData[]; // skull pile
+constexpr uint8_t crownSpriteData_numFrames = 1;
+extern const uint16_t crownSpriteData[]; // armor
+constexpr uint8_t coinsSpriteData_numFrames = 1;
+extern const uint16_t coinsSpriteData[]; // health bonus
+constexpr uint8_t scrollSpriteData_numFrames = 1;
+extern const uint16_t scrollSpriteData[]; // armor bonus
+constexpr uint8_t chestSpriteData_numFrames = 1;
+extern const uint16_t chestSpriteData[]; // backpack
+constexpr uint8_t chestOpenSpriteData_numFrames = 1;
+extern const uint16_t chestOpenSpriteData[]; // clip
+constexpr uint8_t potionSpriteData_numFrames = 1;
+extern const uint16_t potionSpriteData[]; // stimpack
+constexpr uint8_t batSpriteData_numFrames = 2;
+extern const uint16_t batSpriteData[]; // sergeant
+constexpr uint8_t spiderSpriteData_numFrames = 2;
+extern const uint16_t spiderSpriteData[]; // zombieman
+// First-person weapon (shotgun idle / firing)
+extern const uint8_t handSpriteData1[];
+extern const uint8_t handSpriteData2[];
+// Title screen (128x64, Platform::DrawSolidBitmap format)
+extern const uint8_t titleBitmapData[];
+constexpr uint8_t wallTextureData_numTextures = 1;
+extern const uint16_t wallTextureData[];
+extern const uint8_t fontPageData[];
+extern const uint8_t heartSpriteData[];
+extern const uint8_t manaSpriteData[];

applications/system/FlipperDoom/game/LUT.h

@@ -0,0 +1,8 @@
+const uint8_t scaleLUT[] PROGMEM = {
+	15,0,8,15,0,4,8,12,15,0,2,5,8,10,13,15,0,2,4,6,8,10,12,14,15,0,1,3,4,6,8,9,11,12,14,15,0,1,2,4,5,6,8,9,10,12,13,14,15,0,1,2,3,4,5,6,8,9,10,11,12,13,14,15,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,15,0,0,1,2,3,4,5,6,7,8,8,9,10,11,12,13,14,15,15,0,0,1,2,3,4,4,5,6,7,8,8,9,10,11,12,12,13,14,15,15,0,0,1,2,2,3,4,5,5,6,7,8,8,9,10,10,11,12,13,13,14,15,15,0,0,1,2,2,3,4,4,5,6,6,7,8,8,9,10,10,11,12,12,13,14,14,15,15,0,0,1,1,2,3,3,4,4,5,6,6,7,8,8,9,9,10,11,11,12,12,13,14,14,15,15,0,0,1,1,2,2,3,4,4,5,5,6,6,7,8,8,9,9,10,10,11,12,12,13,13,14,14,15,15,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,8,8,9,9,10,10,11,11,12,12,13,13,14,14,15,15,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13,14,14,15,15,15
+};
+
+const int16_t sinTable[] PROGMEM = {
+	0,6,12,18,25,31,37,43,49,56,62,68,74,80,86,92,97,103,109,115,120,126,131,136,142,147,152,157,162,167,171,176,181,185,189,193,197,201,205,209,212,216,219,222,225,228,231,234,236,238,241,243,244,246,248,249,251,252,253,254,254,255,255,255,255,255,255,255,254,254,253,252,251,249,248,246,244,243,241,238,236,234,231,228,225,222,219,216,212,209,205,201,197,193,189,185,181,176,171,167,162,157,152,147,142,136,131,126,120,115,109,103,97,92,86,80,74,68,62,56,49,43,37,31,25,18,12,6,0,-6,-12,-18,-25,-31,-37,-43,-49,-56,-62,-68,-74,-80,-86,-92,-97,-103,-109,-115,-120,-126,-131,-136,-142,-147,-152,-157,-162,-167,-171,-176,-181,-185,-189,-193,-197,-201,-205,-209,-212,-216,-219,-222,-225,-228,-231,-234,-236,-238,-241,-243,-244,-246,-248,-249,-251,-252,-253,-254,-254,-255,-255,-255,-255,-255,-255,-255,-254,-254,-253,-252,-251,-249,-248,-246,-244,-243,-241,-238,-236,-234,-231,-228,-225,-222,-219,-216,-212,-209,-205,-201,-197,-193,-189,-185,-181,-176,-171,-167,-162,-157,-152,-147,-142,-136,-131,-126,-120,-115,-109,-103,-97,-92,-86,-80,-74,-68,-62,-56,-49,-43,-37,-31,-25,-18,-12,-6
+};
+

applications/system/FlipperDoom/game/Map.cpp

@@ -0,0 +1,254 @@
+#include "game/Defines.h"
+#include "game/Map.h"
+#include "game/Game.h"
+#include "game/FixedMath.h"
+#include "game/Draw.h"
+#include "game/Platform.h"
+#include "game/Enemy.h"
+
+uint8_t Map::level[Map::width * Map::height / 2];
+
+bool Map::IsBlocked(uint8_t x, uint8_t y)
+{
+	return GetCellSafe(x, y) >= CellType::FirstCollidableCell;
+}
+
+bool Map::IsSolid(uint8_t x, uint8_t y)
+{
+	return GetCellSafe(x, y) >= CellType::FirstSolidCell;
+}
+
+CellType Map::GetCell(uint8_t x, uint8_t y) 
+{
+	int index = y * Map::width + x;
+	uint8_t cellData = level[index / 2];
+	
+	if(index & 1)
+	{
+		return (CellType)(cellData >> 4);
+	}
+	else
+	{
+		return (CellType)(cellData & 0xf);
+	}
+}
+
+CellType Map::GetCellSafe(uint8_t x, uint8_t y) 
+{
+	if(x >= Map::width || y >= Map::height)
+		return CellType::BrickWall;
+	
+	int index = y * Map::width + x;
+	uint8_t cellData = level[index / 2];
+	
+	if(index & 1)
+	{
+		return (CellType)(cellData >> 4);
+	}
+	else
+	{
+		return (CellType)(cellData & 0xf);
+	}
+}
+
+void Map::SetCell(uint8_t x, uint8_t y, CellType type)
+{
+	if (x >= Map::width || y >= Map::height)
+	{
+		return;
+	}
+
+	int index = (y * Map::width + x) / 2;
+	uint8_t cellType = (uint8_t)type;
+	
+	if(x & 1)
+	{
+		level[index] = (level[index] & 0xf) | (cellType << 4);
+	}
+	else
+	{
+		level[index] = (level[index] & 0xf0) | (cellType & 0xf);
+	}
+}
+
+void Map::DebugDraw()
+{
+	for(int y = 0; y < Map::height; y++)
+	{
+		for(int x = 0; x < Map::width; x++)
+		{
+			Platform::PutPixel(x, y, GetCell(x, y) == CellType::BrickWall ? 1 : 0);
+
+			if (x == Renderer::camera.cellX && y == Renderer::camera.cellY && (Game::globalTickFrame & 8) != 0)
+			{
+				Platform::PutPixel(x, y, 1);
+			}
+		}
+	}
+
+	if ((Game::globalTickFrame & 2) != 0)
+	{
+		for (uint8_t n = 0; n < EnemyManager::maxEnemies; n++)
+		{
+			Enemy& enemy = EnemyManager::enemies[n];
+
+			if (enemy.IsValid())
+			{
+				Platform::PutPixel(enemy.x / CELL_SIZE, enemy.y / CELL_SIZE, 1);
+			}
+		}
+	}
+}
+
+bool Map::IsClearLine(int16_t x1, int16_t y1, int16_t x2, int16_t y2)
+{
+	int cellX1 = x1 / CELL_SIZE;
+	int cellX2 = x2 / CELL_SIZE;
+	int cellY1 = y1 / CELL_SIZE;
+	int cellY2 = y2 / CELL_SIZE;
+
+    int xdist = ABS(cellX2 - cellX1);
+
+	int partial, delta;
+	int deltafrac;
+	int xfrac, yfrac;
+	int xstep, ystep;
+	int32_t ltemp;
+	int x, y;
+
+    if (xdist > 0)
+    {
+        if (cellX2 > cellX1)
+        {
+            partial = (CELL_SIZE * (cellX1 + 1) - x1);
+            xstep = 1;
+        }
+        else
+        {
+            partial = (x1 - CELL_SIZE * (cellX1));
+            xstep = -1;
+        }
+
+        deltafrac = ABS(x2 - x1);
+        delta = y2 - y1;
+        ltemp = ((int32_t)delta * CELL_SIZE) / deltafrac;
+        if (ltemp > 0x7fffl)
+            ystep = 0x7fff;
+        else if (ltemp < -0x7fffl)
+            ystep = -0x7fff;
+        else
+            ystep = ltemp;
+        yfrac = y1 + (((int32_t)ystep*partial) / CELL_SIZE);
+
+        x = cellX1 + xstep;
+        cellX2 += xstep;
+        do
+        {
+            y = (yfrac) / CELL_SIZE;
+            yfrac += ystep;
+
+			if (IsSolid(x, y))
+				return false;
+
+            x += xstep;
+
+            //
+            // see if the door is open enough
+            //
+            /*value &= ~0x80;
+            intercept = yfrac-ystep/2;
+
+            if (intercept>doorposition[value])
+                return false;*/
+
+        } while (x != cellX2);
+    }
+
+    int ydist = ABS(cellY2 - cellY1);
+
+    if (ydist > 0)
+    {
+        if (cellY2 > cellY1)
+        {
+            partial = (CELL_SIZE * (cellY1 + 1) - y1);
+            ystep = 1;
+        }
+        else
+        {
+            partial = (y1 - CELL_SIZE * (cellY1));
+            ystep = -1;
+        }
+
+        deltafrac = ABS(y2 - y1);
+        delta = x2 - x1;
+        ltemp = ((int32_t)delta * CELL_SIZE)/deltafrac;
+        if (ltemp > 0x7fffl)
+            xstep = 0x7fff;
+        else if (ltemp < -0x7fffl)
+            xstep = -0x7fff;
+        else
+            xstep = ltemp;
+        xfrac = x1 + (((int32_t)xstep*partial) / CELL_SIZE);
+
+        y = cellY1 + ystep;
+        cellY2 += ystep;
+        do
+        {
+            x = (xfrac) / CELL_SIZE;
+            xfrac += xstep;
+
+			if (IsSolid(x, y))
+				return false;
+            y += ystep;
+
+            //
+            // see if the door is open enough
+            //
+            /*value &= ~0x80;
+            intercept = xfrac-xstep/2;
+
+            if (intercept>doorposition[value])
+                return false;*/
+        } while (y != cellY2);
+    }
+
+    return true;
+}
+
+void Map::DrawMinimap()
+{
+	constexpr uint8_t minimapWidth = 24;
+	constexpr uint8_t minimapHeight = 18;
+	constexpr uint8_t minimapX = 0; //DISPLAY_WIDTH / 2 - minimapWidth / 2;
+	constexpr uint8_t minimapY = 0; //DISPLAY_HEIGHT - minimapHeight;
+	uint8_t playerCellX = Game::player.x / CELL_SIZE;
+	uint8_t playerCellY = Game::player.y / CELL_SIZE;
+	uint8_t startCellX = playerCellX - minimapWidth / 2;
+	uint8_t startCellY = playerCellY - minimapHeight / 2;
+
+	uint8_t outX = minimapX;
+	uint8_t cellX = startCellX;
+
+	for (uint8_t x = 0; x < minimapWidth; x++)
+	{
+		uint8_t outY = minimapY;
+		uint8_t cellY = startCellY;
+
+		for (uint8_t y = 0; y < minimapHeight; y++)
+		{
+			if (cellX == playerCellX && cellY == playerCellY)
+			{
+				Platform::PutPixel(outX, outY, (Game::globalTickFrame & 3) ? COLOUR_BLACK : COLOUR_WHITE);
+			}
+			else
+			{
+				Platform::PutPixel(outX, outY, cellX < width && cellY < height && IsSolid(cellX, cellY) ? COLOUR_BLACK : COLOUR_WHITE);
+			}
+			outY++;
+			cellY++;
+		}
+
+		outX++;
+		cellX++;
+	}
+}

applications/system/FlipperDoom/game/Map.h

@@ -0,0 +1,60 @@
+#pragma once
+
+#include <stdint.h>
+
+enum class CellType : uint8_t 
+{
+	Empty = 0,
+
+	// Monster types
+	Monster,
+
+	// Non collidable decorations
+	Torch,
+	Entrance,
+	Exit,
+
+	// Items
+	Potion,
+	Coins,
+	Crown,
+	Scroll,
+
+	// Collidable decorations
+	Urn,
+	Chest,
+	ChestOpened,
+	Sign,
+
+	// Solid cells
+	BrickWall,
+	
+	FirstCollidableCell = Urn,
+	FirstSolidCell = BrickWall
+};
+
+class Map
+{
+public:
+	static constexpr int width = 32;
+	static constexpr int height = 24;
+
+	static bool IsSolid(uint8_t x, uint8_t y);
+	static bool IsBlocked(uint8_t x, uint8_t y);
+	static inline bool IsBlockedAtWorldPosition(int16_t x, int16_t y)
+	{
+		return IsBlocked((uint8_t)(x >> 8), (uint8_t)(y >> 8));
+	}
+
+	static CellType GetCell(uint8_t x, uint8_t y);
+	static CellType GetCellSafe(uint8_t x, uint8_t y);
+	static void SetCell(uint8_t x, uint8_t y, CellType cellType);
+	static void DebugDraw();
+	static void DrawMinimap();
+
+	static bool IsClearLine(int16_t x1, int16_t y1, int16_t x2, int16_t y2);
+
+private:	
+	static uint8_t level[width * height / 2];
+	
+};

applications/system/FlipperDoom/game/MapGenerator.cpp

@@ -0,0 +1,610 @@
+#include "game/MapGenerator.h"
+#include "game/Map.h"
+#include "game/FixedMath.h"
+#include "game/Enemy.h"
+#include "game/Game.h"
+
+uint8_t MapGenerator::GetDistanceToCellType(uint8_t x, uint8_t y, CellType cellType)
+{
+	uint8_t ringWidth = 3;
+
+	for (uint8_t offset = 1; offset < Map::width; offset++)
+	{
+		for (uint8_t i = 0; i < ringWidth; i++)
+		{
+			if (Map::GetCellSafe(x - offset + i, y - offset) == cellType)
+			{
+				return offset;
+			}
+			if (Map::GetCellSafe(x - offset + i, y + offset) == cellType)
+			{
+				return offset;
+			}
+			if (Map::GetCellSafe(x - offset, y - offset + i) == cellType)
+			{
+				return offset;
+			}
+			if (Map::GetCellSafe(x + offset, y - offset + i) == cellType)
+			{
+				return offset;
+			}
+		}
+
+		ringWidth += 2;
+	}
+
+	return 0xff;
+}
+
+uint8_t MapGenerator::CountNeighbours(uint8_t x, uint8_t y)
+{
+	uint8_t result = 0;
+
+	if (Map::GetCellSafe(x + 1, y) == CellType::Empty)
+		result++;
+	if (Map::GetCellSafe(x, y + 1) == CellType::Empty)
+		result++;
+	if (Map::GetCellSafe(x - 1, y) == CellType::Empty)
+		result++;
+	if (Map::GetCellSafe(x, y - 1) == CellType::Empty)
+		result++;
+	if (Map::GetCellSafe(x + 1, y + 1) == CellType::Empty)
+		result++;
+	if (Map::GetCellSafe(x - 1, y + 1) == CellType::Empty)
+		result++;
+	if (Map::GetCellSafe(x - 1, y - 1) == CellType::Empty)
+		result++;
+	if (Map::GetCellSafe(x + 1, y - 1) == CellType::Empty)
+		result++;
+
+	return result;
+}
+
+MapGenerator::NeighbourInfo MapGenerator::GetCellNeighbourInfo(uint8_t x, uint8_t y)
+{
+	NeighbourInfo result;
+
+	result.count = 0;
+	result.mask = 0;
+
+	if (Map::IsSolid(x, y - 1))
+	{
+		result.hasNorth = true;
+		result.count++;
+	}
+	if (Map::IsSolid(x + 1, y))
+	{
+		result.hasEast = true;
+		result.count++;
+	}
+	if (Map::IsSolid(x, y + 1))
+	{
+		result.hasSouth = true;
+		result.count++;
+	}
+	if (Map::IsSolid(x - 1, y))
+	{
+		result.hasWest = true;
+		result.count++;
+	}
+
+	return result;
+}
+
+uint8_t MapGenerator::CountImmediateNeighbours(uint8_t x, uint8_t y)
+{
+	uint8_t result = 0;
+
+	if (Map::GetCellSafe(x + 1, y) == CellType::Empty)
+		result++;
+	if (Map::GetCellSafe(x, y + 1) == CellType::Empty)
+		result++;
+	if (Map::GetCellSafe(x - 1, y) == CellType::Empty)
+		result++;
+	if (Map::GetCellSafe(x, y - 1) == CellType::Empty)
+		result++;
+
+	return result;
+}
+
+MapGenerator::NeighbourInfo MapGenerator::GetRoomNeighbourMask(uint8_t x, uint8_t y, uint8_t w, uint8_t h)
+{
+	NeighbourInfo result;
+	result.mask = 0;
+	result.count = 0;
+
+	result.canDemolishNorth = y > 1;
+	result.canDemolishWest = x > 1;
+	result.canDemolishEast = x + w + 1 < Map::width - 1;
+	result.canDemolishSouth = y + h + 1 < Map::height - 1;
+
+	// Don't demolish walls if the neighbouring room has the same wall length
+	if (Map::GetCell(x - 1, y - 2) != CellType::Empty && Map::GetCell(x + w, y - 2) != CellType::Empty)
+	{
+		result.canDemolishNorth = false;
+	}
+	if (Map::GetCell(x - 2, y - 1) != CellType::Empty && Map::GetCell(x - 2, y + h) != CellType::Empty)
+	{
+		result.canDemolishWest = false;
+	}
+	if (Map::GetCell(x + w + 1, y - 1) != CellType::Empty && Map::GetCell(x + w, y + h + 1) != CellType::Empty)
+	{
+		result.canDemolishEast = false;
+	}
+	if (Map::GetCell(x - 1, y + h + 1) != CellType::Empty && Map::GetCell(x + w, y + h + 1) != CellType::Empty)
+	{
+		result.canDemolishSouth = false;
+	}
+
+	// Don't demolish wall if this will leave an unattached wall
+	if (Map::GetCell(x - 1, y - 2) == CellType::Empty && Map::GetCell(x - 2, y - 1) == CellType::Empty)
+	{
+		result.canDemolishNorth = false;
+		result.canDemolishWest = false;
+	}
+	if (Map::GetCell(x + w, y - 2) == CellType::Empty && Map::GetCell(x + w + 1, y - 1) == CellType::Empty)
+	{
+		result.canDemolishNorth = false;
+		result.canDemolishEast = false;
+	}
+	if (Map::GetCell(x + w, y + h + 1) == CellType::Empty && Map::GetCell(x + w + 1, y + h) == CellType::Empty)
+	{
+		result.canDemolishSouth = false;
+		result.canDemolishEast = false;
+	}
+	if (Map::GetCell(x - 1, y + h + 1) == CellType::Empty && Map::GetCell(x - 2, y + h) == CellType::Empty)
+	{
+		result.canDemolishSouth = false;
+		result.canDemolishWest = false;
+	}
+
+	bool hasNorthWall = Map::GetCell(x, y - 1) != CellType::Empty && Map::GetCell(x + w - 1, y - 1) != CellType::Empty;
+	bool hasEastWall = Map::GetCell(x + w, y) != CellType::Empty && Map::GetCell(x + w, y + h - 1) != CellType::Empty;
+	bool hasSouthWall = Map::GetCell(x, y + h) != CellType::Empty && Map::GetCell(x + w - 1, y + h) != CellType::Empty;
+	bool hasWestWall = Map::GetCell(x - 1, y) != CellType::Empty && Map::GetCell(x - 1, y + h - 1) != CellType::Empty;
+
+	if (!hasNorthWall)
+	{
+		result.canDemolishNorth = false;
+		result.canDemolishEast = false;
+		result.canDemolishWest = false;
+	}
+	if (!hasEastWall)
+	{
+		result.canDemolishNorth = false;
+		result.canDemolishEast = false;
+		result.canDemolishSouth = false;
+	}
+	if (!hasSouthWall)
+	{
+		result.canDemolishEast = false;
+		result.canDemolishSouth = false;
+		result.canDemolishWest = false;
+	}
+	if (!hasWestWall)
+	{
+		result.canDemolishNorth = false;
+		result.canDemolishSouth = false;
+		result.canDemolishWest = false;
+	}
+
+	for (int i = x; i < x + w; i++)
+	{
+		if (Map::GetCell(i, y - 1) == CellType::Empty)
+		{
+			result.hasNorth = true;
+			result.count++;
+		}
+		if (Map::GetCell(i, y + h) == CellType::Empty)
+		{
+			result.hasSouth = true;
+			result.count++;
+		}
+
+		// Don't demolish wall if there is an intersecting wall attached
+		if (y > 1 && Map::GetCell(i, y - 2) != CellType::Empty)
+		{
+			result.canDemolishNorth = false;
+		}
+		if (y + h + 1 < Map::height - 1 && Map::GetCell(i, y + h + 1) != CellType::Empty)
+		{
+			result.canDemolishSouth = false;
+		}
+	}
+	for (int j = y; j < y + h; j++)
+	{
+		if (Map::GetCell(x - 1, j) == CellType::Empty)
+		{
+			result.hasWest = true;
+			result.count++;
+		}
+		if (Map::GetCell(x + w, j) == CellType::Empty)
+		{
+			result.hasEast = true;
+			result.count++;
+		}
+
+		// Don't demolish wall if there is an intersecting wall attached
+		if (x > 1 && Map::GetCell(x - 2, j) != CellType::Empty)
+		{
+			result.canDemolishWest = false;
+		}
+		if (x + w + 1 < Map::width - 1 && Map::GetCell(x + w + 1, j) != CellType::Empty)
+		{
+			result.canDemolishEast = false;
+		}
+	}
+
+	return result;
+}
+
+void MapGenerator::SplitMap(uint8_t x, uint8_t y, uint8_t w, uint8_t h, uint8_t doorX, uint8_t doorY)
+{
+	constexpr int minRoomSize = 3;
+	constexpr int maxRoomSize = 8;
+	//constexpr int maxFloorSpace = 80;
+	constexpr int demolishWallChance = 20;
+
+	if (doorX != 0 && doorY != 0)
+	{
+		Map::SetCell(doorX, doorY, CellType::Empty);
+	}
+
+	bool splitVertical = false;
+	bool splitHorizontal = false;
+
+	if (w > maxRoomSize || h > maxRoomSize)//w * h > maxFloorSpace)
+	{
+		if (w < h)
+		{
+			splitVertical = true;
+		}
+		else
+		{
+			splitHorizontal = true;
+		}
+	}
+
+	if (splitVertical)
+	{
+		uint8_t splitSize;
+		uint8_t splitAttempts = 255;
+		do
+		{
+			splitSize = (Random() % (h - 2 * minRoomSize)) + minRoomSize;
+			splitAttempts--;
+		} while (splitAttempts > 0 && (Map::GetCell(x - 1, y + splitSize) == CellType::Empty || Map::GetCell(x + w, y + splitSize) == CellType::Empty
+			|| Map::GetCell(x - 1, y + splitSize - 1) == CellType::Empty || Map::GetCell(x + w, y + splitSize - 1) == CellType::Empty
+			|| Map::GetCell(x - 1, y + splitSize + 1) == CellType::Empty || Map::GetCell(x + w, y + splitSize + 1) == CellType::Empty));
+
+		if (splitAttempts > 0)
+		{
+			uint8_t splitDoorX = x + (Random() % (w - 2)) + 1;
+			uint8_t splitDoorY = y + splitSize;
+
+			for (uint8_t i = x; i < x + w; i++)
+			{
+				Map::SetCell(i, y + splitSize, CellType::BrickWall);
+			}
+
+			SplitMap(x, y + splitSize + 1, w, h - splitSize - 1, splitDoorX, splitDoorY);
+			SplitMap(x, y, w, splitSize, splitDoorX, splitDoorY);
+			return;
+		}
+	}
+	else if (splitHorizontal)
+	{
+		uint8_t splitSize;
+		uint8_t splitAttempts = 255;
+		do
+		{
+			splitSize = (Random() % (w - 2 * minRoomSize)) + minRoomSize;
+			splitAttempts--;
+		} while (splitAttempts > 0 && (Map::GetCell(x + splitSize, y - 1) == CellType::Empty || Map::GetCell(x + splitSize, y + h) == CellType::Empty
+			|| Map::GetCell(x + splitSize - 1, y - 1) == CellType::Empty || Map::GetCell(x + splitSize - 1, y + h) == CellType::Empty
+			|| Map::GetCell(x + splitSize + 1, y - 1) == CellType::Empty || Map::GetCell(x + splitSize + 1, y + h) == CellType::Empty));
+
+		if (splitAttempts > 0)
+		{
+			uint8_t splitDoorX = x + splitSize;
+			uint8_t splitDoorY = y + (Random() % (h - 2)) + 1;
+
+			for (uint8_t j = y; j < y + h; j++)
+			{
+				Map::SetCell(x + splitSize, j, CellType::BrickWall);
+			}
+
+			SplitMap(x + splitSize + 1, y, w - splitSize - 1, h, splitDoorX, splitDoorY);
+			SplitMap(x, y, splitSize, h, splitDoorX, splitDoorY);
+			return;
+		}
+	}
+
+	{
+		NeighbourInfo neighbours = GetRoomNeighbourMask(x, y, w, h);
+
+		if (neighbours.canDemolishNorth && (Random() % 100) < demolishWallChance)
+		{
+			for (int i = 0; i < w; i++)
+			{
+				Map::SetCell(x + i, y - 1, CellType::Empty);
+			}
+		}
+		else if (neighbours.canDemolishWest && (Random() % 100) < demolishWallChance)
+		{
+			for (int j = 0; j < h; j++)
+			{
+				Map::SetCell(x - 1, y + j, CellType::Empty);
+			}
+		}
+		else if (neighbours.canDemolishSouth && (Random() % 100) < demolishWallChance)
+		{
+			for (int i = 0; i < w; i++)
+			{
+				Map::SetCell(x + i, y + h, CellType::Empty);
+			}
+		}
+		else if (neighbours.canDemolishEast && (Random() % 100) < demolishWallChance)
+		{
+			for (int j = 0; j < h; j++)
+			{
+				Map::SetCell(x + w, y + j, CellType::Empty);
+			}
+		}
+
+		// Add decorations
+		{
+			// Add four cornering columns
+			if (w == h && w >= 7 && h >= 7)
+			{
+				Map::SetCell(x + 1, y + 1, CellType::BrickWall);
+				Map::SetCell(x + w - 2, y + 1, CellType::BrickWall);
+				Map::SetCell(x + w - 2, y + h - 2, CellType::BrickWall);
+				Map::SetCell(x + 1, y + h - 2, CellType::BrickWall);
+			}
+		}
+	}
+}
+
+void MapGenerator::Generate()
+{
+	uint8_t playerStartX = 1;
+	uint8_t playerStartY = 1;
+
+	for (int y = 0; y < Map::height; y++)
+	{
+		for (int x = 0; x < Map::width; x++)
+		{
+			bool isEdge = x == 0 || y == 0 || x == Map::width - 1 || y == Map::height - 1;
+			Map::SetCell(x, y, isEdge ? CellType::BrickWall : CellType::Empty);
+		}
+	}
+
+	SplitMap(1, 1, Map::width - 2, Map::height - 2, 0, 0);
+
+	// Find any big open spaces
+	{
+		bool hasOpenSpaces = true;
+
+		while (hasOpenSpaces)
+		{
+			hasOpenSpaces = false;
+
+			uint8_t x = 0, y = 0, space = 0;
+
+			for (uint8_t i = 1; i < Map::width - 1; i++)
+			{
+				for (uint8_t j = 0; j < Map::height - 1; j++)
+				{
+					bool foundWall = false;
+
+					for (uint8_t k = 0; k < Map::height && !foundWall; k++)
+					{
+						for (uint8_t u = 0; u < k && !foundWall; u++)
+						{
+							for (uint8_t v = 0; v < k && !foundWall; v++)
+							{
+								if (Map::GetCellSafe(i + u, j + v) != CellType::Empty)
+								{
+									foundWall = true;
+								}
+							}
+						}
+
+						if (!foundWall && k > space)
+						{
+							space = k;
+							x = i;
+							y = j;
+						}
+					}
+				}
+			}
+
+			if (space > 6)
+			{
+				hasOpenSpaces = true;
+
+				// Stick a donut in the middle
+				for (uint8_t n = 2; n < space - 2; n++)
+				{
+					Map::SetCell(x + n, y + 2, CellType::BrickWall);
+					Map::SetCell(x + 2, y + n, CellType::BrickWall);
+					Map::SetCell(x + n, y + space - 3, CellType::BrickWall);
+					Map::SetCell(x + space - 3, y + n, CellType::BrickWall);
+				}
+			}
+		}
+	}
+
+	// Add torches
+	{
+		uint8_t attempts = 255;
+		uint8_t toSpawn = 64;
+		uint8_t minSpacing = 3;
+
+		while (attempts > 0 && toSpawn > 0)
+		{
+			uint8_t x = Random() % Map::width;
+			uint8_t y = Random() % Map::height;
+
+			if (Map::GetCellSafe(x, y) == CellType::Empty)
+			{
+				NeighbourInfo info = GetCellNeighbourInfo(x, y);
+
+				if(info.count == 1 && GetDistanceToCellType(x, y, CellType::Torch) > minSpacing)
+				{
+					Map::SetCell(x, y, CellType::Torch);
+					toSpawn--;
+					attempts = 255;
+				}
+			}
+
+			attempts--;
+		}
+	}
+
+	// Add monsters
+	{
+		uint8_t attempts = 255;
+		uint8_t monstersToSpawn = EnemyManager::maxEnemies;
+		CellType monsterType = CellType::Monster;
+		uint8_t minSpacing = 3;
+
+		while (attempts > 0 && monstersToSpawn > 0)
+		{
+			uint8_t x = Random() % Map::width;
+			uint8_t y = Random() % Map::height;
+
+			if (Map::GetCellSafe(x, y) == CellType::Empty && Map::IsClearLine(x * CELL_SIZE + CELL_SIZE / 2, y * CELL_SIZE + CELL_SIZE / 2, playerStartX * CELL_SIZE + CELL_SIZE / 2, playerStartY * CELL_SIZE + CELL_SIZE / 2) == false)
+			{
+				NeighbourInfo info = GetCellNeighbourInfo(x, y);
+				if (info.count == 0 && GetDistanceToCellType(x, y, monsterType) > minSpacing)
+				{
+					Map::SetCell(x, y, monsterType);
+					monstersToSpawn--;
+					attempts = 255;
+				}
+			}
+
+			attempts--;
+		}
+	}
+
+	// Add blocking decorations
+	{
+		uint8_t attempts = 255;
+		uint8_t toSpawn = 255;
+		CellType cellType = CellType::Urn;
+		uint8_t minSpacing = 3;
+
+		while (attempts > 0 && toSpawn > 0)
+		{
+			uint8_t x = Random() % Map::width;
+			uint8_t y = Random() % Map::height;
+
+			if (Map::GetCellSafe(x, y) == CellType::Empty)
+			{
+				NeighbourInfo info = GetCellNeighbourInfo(x, y);
+
+				if(info.IsCorner() && GetDistanceToCellType(x, y, cellType) > minSpacing)
+				{
+					Map::SetCell(x, y, cellType);
+					toSpawn--;
+					attempts = 255;
+				}
+			}
+
+			attempts--;
+		}
+	}
+
+	// Add entrance and exit
+	Map::SetCell(1, 1, CellType::Entrance);
+	Map::SetCell(Map::width - 3, Map::height - 3, CellType::Exit);
+
+	// Add sign
+	if(false)
+	{
+		uint16_t attempts = 65535;
+		constexpr uint8_t closeness = 5;
+
+		while (attempts > 0)
+		{
+			uint8_t x = Random() % closeness;
+			uint8_t y = Random() % closeness;
+
+			if (Map::GetCellSafe(x, y) == CellType::Empty
+				&&	Map::GetCellSafe(x - 1, y) == CellType::Empty
+				&&	Map::GetCellSafe(x, y - 1) == CellType::Empty
+				&&	Map::GetCellSafe(x + 1, y) == CellType::Empty
+				&&	Map::GetCellSafe(x, y + 1) == CellType::Empty
+				&&	Map::GetCellSafe(x - 1, y - 1) == CellType::Empty
+				&&	Map::GetCellSafe(x + 1, y - 1) == CellType::Empty
+				&&	Map::GetCellSafe(x - 1, y + 1) == CellType::Empty
+				&&	Map::GetCellSafe(x + 1, y + 1) == CellType::Empty
+				&& Map::IsClearLine(x * CELL_SIZE + CELL_SIZE / 2, y * CELL_SIZE + CELL_SIZE / 2, playerStartX * CELL_SIZE + CELL_SIZE / 2, playerStartY * CELL_SIZE + CELL_SIZE / 2))
+			{
+				Map::SetCell(x, y, CellType::Sign);
+				break;
+			}
+
+			attempts--;
+		}
+	}
+	else if(Game::floor == 1)
+	{
+		Map::SetCell(2, 2, CellType::Sign);
+	}
+	
+	// Add treasure / items
+	{
+		uint16_t attempts = 65535;
+		uint8_t toSpawn = 8;
+		CellType cellType = CellType::Chest;
+		uint8_t minSpacing = 3;
+		uint8_t minExitSpacing = 6;
+
+		while (attempts > 0 && toSpawn > 0)
+		{
+			uint8_t x = Random() % Map::width;
+			uint8_t y = Random() % Map::height;
+
+			switch (Random() % 5)
+			{
+			case 0:
+				cellType = CellType::Potion;
+				break;
+			case 1:
+				cellType = CellType::Coins;
+				break;
+			case 2:
+				cellType = CellType::Chest;
+				break;
+			case 3:
+				cellType = CellType::Crown;
+				break;
+			case 4:
+				cellType = CellType::Scroll;
+				break;
+			}
+
+			if (Map::GetCellSafe(x, y) == CellType::Empty)
+			{
+				NeighbourInfo info = GetCellNeighbourInfo(x, y);
+
+				if(info.count == 1 
+				&& GetDistanceToCellType(x, y, cellType) > minSpacing
+				&& GetDistanceToCellType(x, y, CellType::Entrance) > minExitSpacing
+				&& GetDistanceToCellType(x, y, CellType::Exit) > minExitSpacing)
+				{
+					Map::SetCell(x, y, cellType);
+					toSpawn--;
+					attempts = 255;
+				}
+			}
+
+			attempts--;
+		}
+	}
+}

applications/system/FlipperDoom/game/MapGenerator.h

@@ -0,0 +1,60 @@
+#pragma once
+
+#include <stdint.h>
+#include "game/Map.h"
+
+class MapGenerator
+{
+public:
+	static void Generate();
+
+private:
+
+	struct NeighbourInfo
+	{
+		union
+		{
+			uint8_t mask;
+
+			struct
+			{
+				bool hasNorth : 1;
+				bool hasEast : 1;
+				bool hasSouth : 1;
+				bool hasWest : 1;
+
+				bool canDemolishNorth : 1;
+				bool canDemolishEast : 1;
+				bool canDemolishSouth : 1;
+				bool canDemolishWest : 1;
+			};
+		};
+
+		uint8_t count;
+
+		bool IsCorner() const 
+		{
+			if (count != 2)
+				return false;
+
+			if (hasNorth && hasEast)
+				return true;
+			if (hasEast && hasSouth)
+				return true;
+			if (hasSouth && hasWest)
+				return true;
+			if (hasWest && hasNorth)
+				return true;
+
+			return false;
+		}
+	};
+
+	static uint8_t CountNeighbours(uint8_t x, uint8_t y);
+	static uint8_t CountImmediateNeighbours(uint8_t x, uint8_t y);
+	static NeighbourInfo GetRoomNeighbourMask(uint8_t x, uint8_t y, uint8_t w, uint8_t h);
+	static void SplitMap(uint8_t x, uint8_t y, uint8_t w, uint8_t h, uint8_t doorX, uint8_t doorY);
+
+	static NeighbourInfo GetCellNeighbourInfo(uint8_t x, uint8_t y);
+	static uint8_t GetDistanceToCellType(uint8_t x, uint8_t y, CellType cellType);
+};

applications/system/FlipperDoom/game/Menu.cpp

@@ -0,0 +1,705 @@
+#include "game/Defines.h"
+#include "game/Platform.h"
+#include "game/Menu.h"
+#include "game/Font.h"
+#include "game/Game.h"
+#include "game/Draw.h"
+#include "game/Textures.h"
+#include "game/Generated/SpriteTypes.h"
+#include "game/Map.h"
+#include "game/FixedMath.h"
+#include "lib/EEPROM.h"
+
+#include <stdio.h>
+#include <string.h>
+
+constexpr uint8_t EEPROM_BASE_ADDR = 0;
+
+struct ObjDesc {
+    const uint16_t* sprite;
+    bool animated;
+    bool invert;
+    uint8_t varsIndex;
+};
+
+static const ObjDesc kObjects[] = {
+    { chestSpriteData,    false, false, 0 },
+    { crownSpriteData,    false, false, 1 },
+    { scrollSpriteData,   false, false, 2 },
+    { coinsSpriteData,    false, false, 3 },
+    { skeletonSpriteData, true,  false, 4 },
+    { mageSpriteData,     true,  false, 5 },
+    { batSpriteData,      true,  false, 6 },
+    { spiderSpriteData,   true,  false, 7 },
+    { exitSpriteData,     false, false, 8 }
+};
+
+static constexpr uint8_t kObjectsCount = (uint8_t)(sizeof(kObjects) / sizeof(kObjects[0]));
+static constexpr uint8_t SHIFT_MASK = 63;
+
+namespace {
+constexpr uint8_t MENU_ITEMS_COUNT = 4;
+constexpr uint8_t VISIBLE_ROWS = 2;
+
+constexpr uint8_t MENU_FIRST_ROW = 4;
+constexpr uint8_t TEXT_X = 18;
+constexpr uint8_t CURSOR_X = 10;
+
+constexpr uint8_t SPLASH_TIME_TICKS = 90;
+static uint8_t splashTimer = 0;
+static bool splashActive = true;
+
+static uint8_t Wrap(int v, int n) {
+    v %= n;
+    if(v < 0) v += n;
+    return (uint8_t)v;
+}
+
+static uint8_t MaxTop() {
+    return (MENU_ITEMS_COUNT > VISIBLE_ROWS) ? (uint8_t)(MENU_ITEMS_COUNT - VISIBLE_ROWS) : 0;
+}
+
+void DrawMenuRoom() {
+    const int16_t leftWall = 1 * CELL_SIZE;
+    const int16_t rightWall = 4 * CELL_SIZE;
+    const int16_t topWall = 1 * CELL_SIZE;
+    const int16_t bottomWall = 4 * CELL_SIZE;
+
+    Renderer::camera.x = (int16_t)((leftWall + rightWall) / 2);
+    Renderer::camera.y = (int16_t)((topWall + bottomWall) / 2);
+
+    static uint16_t angleFP = 0;
+    constexpr uint16_t SPEED_FP = 64;
+    angleFP = (uint16_t)(angleFP + SPEED_FP);
+    Renderer::camera.angle = (uint8_t)(angleFP >> 8);
+
+    Renderer::camera.tilt = 0;
+    Renderer::camera.bob = 0;
+
+    Renderer::globalRenderFrame++;
+    Renderer::DrawBackground();
+
+    Renderer::numBufferSlicesFilled = 0;
+    Renderer::numQueuedDrawables = 0;
+
+    for(uint8_t n = 0; n < DISPLAY_WIDTH; n++) {
+        Renderer::wBuffer[n] = 0;
+        Renderer::horizonBuffer[n] = HORIZON +
+                                     (((DISPLAY_WIDTH / 2 - n) * Renderer::camera.tilt) >> 8) +
+                                     Renderer::camera.bob;
+    }
+
+    Renderer::camera.cellX = Renderer::camera.x / CELL_SIZE;
+    Renderer::camera.cellY = Renderer::camera.y / CELL_SIZE;
+
+    {
+        uint16_t rotPhase = (uint16_t)(0 - angleFP);
+        uint8_t a0 = (uint8_t)(rotPhase >> 8);
+        uint8_t f = (uint8_t)(rotPhase & 0xff);
+        uint8_t a1 = (uint8_t)(a0 + 1);
+
+        int16_t c0 = FixedCos(a0);
+        int16_t c1 = FixedCos(a1);
+        int16_t s0 = FixedSin(a0);
+        int16_t s1 = FixedSin(a1);
+
+        Renderer::camera.rotCos = (int16_t)(c0 + (((int32_t)(c1 - c0) * f) >> 8));
+        Renderer::camera.rotSin = (int16_t)(s0 + (((int32_t)(s1 - s0) * f) >> 8));
+    }
+
+    {
+        uint16_t clipPhase = (uint16_t)(((uint16_t)CLIP_ANGLE << 8) - angleFP);
+        uint8_t a0 = (uint8_t)(clipPhase >> 8);
+        uint8_t f = (uint8_t)(clipPhase & 0xff);
+        uint8_t a1 = (uint8_t)(a0 + 1);
+
+        int16_t c0 = FixedCos(a0);
+        int16_t c1 = FixedCos(a1);
+        int16_t s0 = FixedSin(a0);
+        int16_t s1 = FixedSin(a1);
+
+        Renderer::camera.clipCos = (int16_t)(c0 + (((int32_t)(c1 - c0) * f) >> 8));
+        Renderer::camera.clipSin = (int16_t)(s0 + (((int32_t)(s1 - s0) * f) >> 8));
+    }
+
+#if WITH_IMAGE_TEXTURES
+    const uint16_t* texture = wallTextureData;
+#elif WITH_VECTOR_TEXTURES
+    const uint8_t* texture = vectorTexture0;
+#endif
+
+    constexpr int8_t MIN_CELL = 0;
+    constexpr int8_t MAX_CELL = 4;
+
+#define MENU_SOLID(cx, cy) (((cx) == 0) || ((cx) == MAX_CELL) || ((cy) == 0) || ((cy) == MAX_CELL))
+#define MENU_SOLID_SAFE(cx, cy)                                                   \
+    (((cx) < MIN_CELL || (cx) > MAX_CELL || (cy) < MIN_CELL || (cy) > MAX_CELL) ? \
+         true :                                                                   \
+         MENU_SOLID((cx), (cy)))
+
+    int8_t xd, yd;
+    int8_t x1, y1, x2, y2;
+
+    if(Renderer::camera.rotCos > 0) {
+        x1 = MIN_CELL;
+        x2 = MAX_CELL + 1;
+        xd = 1;
+    } else {
+        x2 = MIN_CELL - 1;
+        x1 = MAX_CELL;
+        xd = -1;
+    }
+
+    if(Renderer::camera.rotSin < 0) {
+        y1 = MIN_CELL;
+        y2 = MAX_CELL + 1;
+        yd = 1;
+    } else {
+        y2 = MIN_CELL - 1;
+        y1 = MAX_CELL;
+        yd = -1;
+    }
+
+    auto drawMenuCell = [&](int8_t x, int8_t y) {
+        if(!MENU_SOLID(x, y)) return;
+        if(Renderer::isFrustrumClipped(x, y)) return;
+        if(Renderer::numBufferSlicesFilled >= DISPLAY_WIDTH) return;
+
+        const bool blockedLeft = MENU_SOLID_SAFE(x - 1, y);
+        const bool blockedRight = MENU_SOLID_SAFE(x + 1, y);
+        const bool blockedUp = MENU_SOLID_SAFE(x, y - 1);
+        const bool blockedDown = MENU_SOLID_SAFE(x, y + 1);
+
+        int16_t wx1 = (int16_t)(x * CELL_SIZE);
+        int16_t wy1 = (int16_t)(y * CELL_SIZE);
+        int16_t wx2 = (int16_t)(wx1 + CELL_SIZE);
+        int16_t wy2 = (int16_t)(wy1 + CELL_SIZE);
+
+        if(!blockedLeft && Renderer::camera.x < wx1) {
+#if WITH_TEXTURES
+            Renderer::DrawWall(
+                texture,
+                wx1,
+                wy1,
+                wx1,
+                wy2,
+                !blockedUp && Renderer::camera.y > wy1,
+                !blockedDown && Renderer::camera.y < wy2,
+                false);
+#else
+            Renderer::DrawWall(
+                wx1,
+                wy1,
+                wx1,
+                wy2,
+                !blockedUp && Renderer::camera.y > wy1,
+                !blockedDown && Renderer::camera.y < wy2,
+                false);
+#endif
+        }
+
+        if(!blockedDown && Renderer::camera.y > wy2) {
+#if WITH_TEXTURES
+            Renderer::DrawWall(
+                texture,
+                wx1,
+                wy2,
+                wx2,
+                wy2,
+                !blockedLeft && Renderer::camera.x > wx1,
+                !blockedRight && Renderer::camera.x < wx2,
+                false);
+#else
+            Renderer::DrawWall(
+                wx1,
+                wy2,
+                wx2,
+                wy2,
+                !blockedLeft && Renderer::camera.x > wx1,
+                !blockedRight && Renderer::camera.x < wx2,
+                false);
+#endif
+        }
+
+        if(!blockedRight && Renderer::camera.x > wx2) {
+#if WITH_TEXTURES
+            Renderer::DrawWall(
+                texture,
+                wx2,
+                wy2,
+                wx2,
+                wy1,
+                !blockedDown && Renderer::camera.y < wy2,
+                !blockedUp && Renderer::camera.y > wy1,
+                false);
+#else
+            Renderer::DrawWall(
+                wx2,
+                wy2,
+                wx2,
+                wy1,
+                !blockedDown && Renderer::camera.y < wy2,
+                !blockedUp && Renderer::camera.y > wy1,
+                false);
+#endif
+        }
+
+        if(!blockedUp && Renderer::camera.y < wy1) {
+#if WITH_TEXTURES
+            Renderer::DrawWall(
+                texture,
+                wx2,
+                wy1,
+                wx1,
+                wy1,
+                !blockedRight && Renderer::camera.x < wx2,
+                !blockedLeft && Renderer::camera.x > wx1,
+                false);
+#else
+            Renderer::DrawWall(
+                wx2,
+                wy1,
+                wx1,
+                wy1,
+                !blockedRight && Renderer::camera.x < wx2,
+                !blockedLeft && Renderer::camera.x > wx1,
+                false);
+#endif
+        }
+    };
+
+    if(ABS(Renderer::camera.rotCos) < ABS(Renderer::camera.rotSin)) {
+        for(int8_t y = y1; y != y2; y += yd) {
+            for(int8_t x = x1; x != x2; x += xd) {
+                drawMenuCell(x, y);
+            }
+        }
+    } else {
+        for(int8_t x = x1; x != x2; x += xd) {
+            for(int8_t y = y1; y != y2; y += yd) {
+                drawMenuCell(x, y);
+            }
+        }
+    }
+
+#undef MENU_SOLID_SAFE
+#undef MENU_SOLID
+}
+}
+
+void Menu::Draw() {
+    if (splashActive) {
+        // Title screen converted from the user's own shareware WAD
+        Platform::DrawSolidBitmap(0, 0, titleBitmapData);
+        return;
+    }
+
+    DrawMenuRoom();
+
+    Font::PrintString(PSTR("FLIPPER DOOM"), 2, 40, COLOUR_WHITE);
+
+    for (uint8_t row = 0; row < VISIBLE_ROWS; ++row) {
+        uint8_t idx = (uint8_t)(m_topIndex + row);
+        if (idx >= MENU_ITEMS_COUNT) break;
+        PrintItem(idx, (uint8_t)(MENU_FIRST_ROW + row));
+    }
+
+    static uint8_t bubble = 0;
+    static uint16_t lastFrameSeen = 0xFFFF;
+
+    const uint16_t frame = (uint16_t)Game::globalTickFrame;
+
+    if (frame != lastFrameSeen) {
+        if ((frame & SHIFT_MASK) == 0) {
+            bubble = (uint8_t)(bubble + 2);
+            if (bubble >= kObjectsCount) bubble = (uint8_t)(bubble - kObjectsCount);
+            if (bubble >= kObjectsCount) bubble = (uint8_t)(bubble - kObjectsCount);
+        }
+        lastFrameSeen = frame;
+    }
+
+    const uint8_t num1 = bubble;
+    uint8_t num2 = (uint8_t)(bubble + 1);
+    if (num2 >= kObjectsCount) num2 = 0;
+
+    const ObjDesc& sprite1 = kObjects[num1];
+    const ObjDesc& sprite2 = kObjects[num2];
+
+    const int animOffset = ((Game::globalTickFrame & 8) == 0) ? 32 : 0;
+    const int off1 = sprite1.animated ? animOffset : 0;
+    const int off2 = sprite2.animated ? animOffset : 0;
+
+    const uint16_t* torchSprite =
+        (Game::globalTickFrame & 4) ? torchSpriteData1 : torchSpriteData2;
+
+    if (sprite1.invert) {
+        Renderer::DrawScaled(sprite1.sprite + off1, 66, 29, 9, 255, true, COLOUR_BLACK);
+    } else {
+        Renderer::DrawScaled(sprite1.sprite + off1, 66, 29, 9, 255);
+    }
+
+    if (sprite2.invert) {
+        Renderer::DrawScaled(sprite2.sprite + off2, 96, 30, 9, 255, true, COLOUR_BLACK);
+    } else {
+        Renderer::DrawScaled(sprite2.sprite + off2, 96, 30, 9, 255);
+    }
+
+    Renderer::DrawScaled(torchSprite, 0, 10, 9, 255);
+    Renderer::DrawScaled(torchSprite, DISPLAY_WIDTH - 18, 10, 9, 255);
+
+    Font::PrintInt(m_save[sprite1.varsIndex], MENU_FIRST_ROW + 1, 86, COLOUR_WHITE);
+    Font::PrintInt(m_save[sprite2.varsIndex], MENU_FIRST_ROW + 1, 116, COLOUR_WHITE);
+
+    Font::PrintString(PSTR(">"), (uint8_t)(MENU_FIRST_ROW + m_cursorPos), CURSOR_X, COLOUR_WHITE);
+}
+
+void Menu::PrintItem(uint8_t idx, uint8_t row) {
+    switch(idx) {
+    case 0:
+        Font::PrintString(PSTR("Play"), row, TEXT_X, COLOUR_WHITE);
+        break;
+    case 1:
+        Font::PrintString(PSTR("Sound:"), row, TEXT_X, COLOUR_WHITE);
+        Font::PrintString(
+            Platform::IsAudioEnabled() ? PSTR("on") : PSTR("off"), row, TEXT_X + 28, COLOUR_WHITE);
+        break;
+    case 2:
+        Font::PrintString(PSTR("Score:"), row, TEXT_X, COLOUR_WHITE);
+        Font::PrintInt(m_score, row, TEXT_X + 28, COLOUR_WHITE);
+        break;
+    case 3:
+        Font::PrintString(PSTR("High:"), row, TEXT_X, COLOUR_WHITE);
+        Font::PrintInt(m_high, row, TEXT_X + 28, COLOUR_WHITE);
+        break;
+    }
+}
+
+void Menu::Init() {
+    m_selection = 0;
+    m_topIndex = 0;
+    m_cursorPos = 0;
+
+    splashTimer = 0;
+    splashActive = true;
+}
+
+void Menu::DrawEnteringLevel() {
+    DrawMenuRoom();
+    Font::PrintString(PSTR("Entering E1M"), 3, 34, COLOUR_BLACK);
+    Font::PrintInt(Game::floor, 3, 82, COLOUR_BLACK);
+}
+
+static int CountCharsInt(int v) {
+    int n = 1;
+    if(v < 0) {
+        n++;
+        v = -v;
+    } // минус тоже символ
+    while(v >= 10) {
+        v /= 10;
+        n++;
+    }
+    return n;
+}
+
+void PrintScoreCentered(int finalScore) {
+    const int screenW = 128;
+
+    int n = CountCharsInt(finalScore);
+    int textW = 4 * n - 1;
+
+    int x = (screenW - textW) / 2;
+
+    Font::PrintInt(finalScore, 2, x, COLOUR_BLACK);
+}
+
+void Menu::DrawGameOver() {
+    uint16_t finalScore = 0;
+    constexpr int finishBonus = 500;
+    constexpr int levelBonus = 20;
+    constexpr int chestBonus = 15;
+    constexpr int crownBonus = 10;
+    constexpr int scrollBonus = 8;
+    constexpr int coinsBonus = 4;
+    constexpr int skeletonKillBonus = 10;
+    constexpr int mageKillBonus = 10;
+    constexpr int batKillBonus = 5;
+    constexpr int spiderKillBonus = 4;
+
+    finalScore += (Game::floor - 1) * levelBonus;
+    if(Game::stats.killedBy == EnemyType::None) finalScore += finishBonus;
+    finalScore += Game::stats.chestsOpened * chestBonus;
+    finalScore += Game::stats.crownsCollected * crownBonus;
+    finalScore += Game::stats.scrollsCollected * scrollBonus;
+    finalScore += Game::stats.coinsCollected * coinsBonus;
+    finalScore += Game::stats.enemyKills[(int)EnemyType::Skeleton] * skeletonKillBonus;
+    finalScore += Game::stats.enemyKills[(int)EnemyType::Mage] * mageKillBonus;
+    finalScore += Game::stats.enemyKills[(int)EnemyType::Bat] * batKillBonus;
+    finalScore += Game::stats.enemyKills[(int)EnemyType::Spider] * spiderKillBonus;
+
+    DrawMenuRoom();
+    PrintScoreCentered(finalScore);
+
+    switch(Game::stats.killedBy) {
+    case EnemyType::Exit:
+        Font::PrintString(PSTR("You have left the game."), 1, 18, COLOUR_BLACK);
+        break;
+    case EnemyType::None:
+        Font::PrintString(PSTR("You escaped the base!"), 1, 22, COLOUR_BLACK);
+        break;
+    case EnemyType::Mage:
+        Font::PrintString(PSTR("Killed by an imp on level"), 1, 8, COLOUR_BLACK);
+        Font::PrintInt(Game::floor, 1, 112, COLOUR_BLACK);
+        break;
+    case EnemyType::Skeleton:
+        Font::PrintString(PSTR("Killed by a demon on level"), 1, 6, COLOUR_BLACK);
+        Font::PrintInt(Game::floor, 1, 114, COLOUR_BLACK);
+        break;
+    case EnemyType::Bat:
+        Font::PrintString(PSTR("Killed by a sergeant on level"), 1, 2, COLOUR_BLACK);
+        Font::PrintInt(Game::floor, 1, 120, COLOUR_BLACK);
+        break;
+    case EnemyType::Spider:
+        Font::PrintString(PSTR("Killed by a zombie on level"), 1, 4, COLOUR_BLACK);
+        Font::PrintInt(Game::floor, 1, 116, COLOUR_BLACK);
+        break;
+    }
+
+    constexpr uint8_t firstRow = 21;
+    constexpr uint8_t secondRow = 38;
+
+    int offset = (Game::globalTickFrame & 8) == 0 ? 32 : 0;
+
+    Renderer::DrawScaled(chestSpriteData, 6, firstRow, 9, 255, false, COLOUR_WHITE);
+    Font::PrintInt(Game::stats.chestsOpened, 4, 24, COLOUR_BLACK);
+
+    Renderer::DrawScaled(crownSpriteData, 6, secondRow, 9, 255, false, COLOUR_WHITE);
+    Font::PrintInt(Game::stats.crownsCollected, 6, 24, COLOUR_BLACK);
+
+    Renderer::DrawScaled(scrollSpriteData, 36, firstRow, 9, 255, false, COLOUR_WHITE);
+    Font::PrintInt(Game::stats.scrollsCollected, 4, 54, COLOUR_BLACK);
+
+    Renderer::DrawScaled(coinsSpriteData, 36, secondRow, 9, 255, false, COLOUR_WHITE);
+    Font::PrintInt(Game::stats.coinsCollected, 6, 54, COLOUR_BLACK);
+
+    Renderer::DrawScaled(skeletonSpriteData + offset, 72, firstRow, 9, 255, false, COLOUR_WHITE);
+    Font::PrintInt(Game::stats.enemyKills[(int)EnemyType::Skeleton], 4, 90, COLOUR_BLACK);
+
+    Renderer::DrawScaled(mageSpriteData + offset, 72, secondRow, 9, 255, false, COLOUR_WHITE);
+    Font::PrintInt(Game::stats.enemyKills[(int)EnemyType::Mage], 6, 90, COLOUR_BLACK);
+
+    Renderer::DrawScaled(batSpriteData + offset, 102, firstRow, 9, 255, false, COLOUR_WHITE);
+    Font::PrintInt(Game::stats.enemyKills[(int)EnemyType::Bat], 4, 120, COLOUR_BLACK);
+
+    Renderer::DrawScaled(spiderSpriteData + offset, 102, secondRow, 9, 255, false, COLOUR_WHITE);
+    Font::PrintInt(Game::stats.enemyKills[(int)EnemyType::Spider], 6, 120, COLOUR_BLACK);
+
+    m_save[0] = Game::stats.chestsOpened;
+    m_save[1] = Game::stats.crownsCollected;
+    m_save[2] = Game::stats.scrollsCollected;
+    m_save[3] = Game::stats.coinsCollected;
+    m_save[4] = Game::stats.enemyKills[(int)EnemyType::Skeleton];
+    m_save[5] = Game::stats.enemyKills[(int)EnemyType::Mage];
+    m_save[6] = Game::stats.enemyKills[(int)EnemyType::Bat];
+    m_save[7] = Game::stats.enemyKills[(int)EnemyType::Spider];
+    m_save[8] = 0;
+
+    if(Game::floor > 0) {
+        m_save[8] = Game::floor - 1;
+    } 
+
+    SetScore(finalScore);
+}
+
+void Menu::Tick() {
+    static uint8_t lastInput = 0;
+    uint8_t input = Platform::GetInput();
+
+    if(splashActive) {
+        if(splashTimer < SPLASH_TIME_TICKS) splashTimer++;
+        if(splashTimer >= SPLASH_TIME_TICKS) splashActive = false;
+        // any key skips the title screen
+        if(input && !lastInput && splashTimer > 8) splashActive = false;
+        lastInput = input;
+        return;
+    }
+
+    auto syncWindow = [&]() {
+        uint8_t maxTop = MaxTop();
+
+        if(m_selection < m_topIndex) m_topIndex = m_selection;
+
+        uint8_t end = (uint8_t)(m_topIndex + (VISIBLE_ROWS - 1));
+        if(m_selection > end) {
+            int t = (int)m_selection - (VISIBLE_ROWS - 1);
+            if(t < 0) t = 0;
+            if(t > maxTop) t = maxTop;
+            m_topIndex = (uint8_t)t;
+        }
+
+        m_cursorPos = (uint8_t)(m_selection - m_topIndex);
+        if(m_cursorPos >= VISIBLE_ROWS) m_cursorPos = (VISIBLE_ROWS - 1);
+    };
+
+    if((input & INPUT_DOWN) && !(lastInput & INPUT_DOWN)) {
+        uint8_t next = Wrap((int)m_selection + 1, MENU_ITEMS_COUNT);
+
+        if(m_cursorPos < (VISIBLE_ROWS - 1)) {
+            m_selection = next;
+            m_cursorPos++;
+        } else {
+            m_selection = next;
+
+            if(m_topIndex < MaxTop()) {
+                m_topIndex++;
+            } else {
+                m_topIndex = 0;
+                m_cursorPos = 0;
+            }
+        }
+
+        syncWindow();
+    }
+
+    if((input & INPUT_UP) && !(lastInput & INPUT_UP)) {
+        uint8_t prev = Wrap((int)m_selection - 1, MENU_ITEMS_COUNT);
+
+        if(m_cursorPos > 0) {
+            m_selection = prev;
+            m_cursorPos--;
+        } else {
+            m_selection = prev;
+
+            if(m_topIndex > 0) {
+                m_topIndex--;
+            } else {
+                m_topIndex = MaxTop();
+                m_cursorPos = (VISIBLE_ROWS - 1);
+            }
+        }
+
+        syncWindow();
+    }
+
+    if((input & (INPUT_A | INPUT_B)) && !(lastInput & (INPUT_A | INPUT_B))) {
+        switch(m_selection) {
+        case 0:
+            Game::StartGame();
+            break;
+        case 1:
+            Platform::SetAudioEnabled(!Platform::IsAudioEnabled());
+            break;
+        default:
+            break;
+        }
+    }
+
+    lastInput = input;
+}
+
+void Menu::TickEnteringLevel() {
+    constexpr uint8_t showTime = 45;
+    if(timer < showTime) timer++;
+    if(timer == showTime && Platform::GetInput() == 0) {
+        Game::StartLevel();
+    }
+}
+
+void Menu::TickGameOver() {
+    constexpr uint8_t minShowTime = 30;
+
+    if(timer < minShowTime) timer++;
+
+    if(timer == minShowTime && (Platform::GetInput() & (INPUT_A | INPUT_B))) {
+        timer++;
+    } else if(timer == minShowTime + 1 && Platform::GetInput() == 0) {
+        Game::SwitchState(Game::State::Menu);
+    }
+}
+
+static inline void DrawEraseTile8x8(int16_t x, int16_t y, const uint8_t* frame8bytes) {
+    for(uint8_t row = 0; row < 8; row++) {
+        uint8_t rowMask = pgm_read_byte(frame8bytes + row);
+        while(rowMask) {
+            uint8_t b = (uint8_t)__builtin_ctz((unsigned)rowMask);
+            uint8_t col = 7 - b;
+            Platform::PutPixel(x + col, y + row, COLOUR_WHITE);
+            rowMask &= (uint8_t)(rowMask - 1);
+        }
+    }
+}
+
+void Menu::DrawTransitionFrame(uint8_t frameIndex) {
+    const uint8_t w = pgm_read_byte(transitionSet + 0);
+    const uint8_t h = pgm_read_byte(transitionSet + 1);
+    (void)w;
+    (void)h;
+
+    const uint8_t* framePtr = transitionSet + 2 + (uint16_t)frameIndex * 8;
+    int16_t tileX = 120;
+    int16_t tileY = 56;
+    while(true) {
+        DrawEraseTile8x8(tileX, tileY, framePtr);
+
+        tileX -= 8;
+        if(tileX < 0) {
+            tileX = 120;
+            tileY -= 8;
+            if(tileY < 0) break;
+        }
+    }
+}
+
+void Menu::ResetTimer() {
+    timer = 0;
+}
+
+static constexpr uint8_t TOTAL_TIME = 40;
+static constexpr uint8_t TOTAL_FRAMES = 8;
+
+void Menu::RunTransition(Menu* menu, uint8_t& t, TransitionNextFn next) {
+    uint8_t frameIndex = (uint16_t)t * TOTAL_FRAMES / TOTAL_TIME;
+    if(frameIndex >= TOTAL_FRAMES) frameIndex = TOTAL_FRAMES - 1;
+    menu->DrawTransitionFrame(frameIndex);
+    if(frameIndex >= TOTAL_FRAMES - 2) {
+        t = 0;
+        next();
+        return;
+    }
+    ++t;
+}
+
+void Menu::FadeOut() {
+    static uint8_t t = 0;
+    RunTransition(this, t, +[]() { Game::SwitchState(Game::State::GameOver); });
+}
+
+void Menu::ReadSave() {
+    uint8_t addr = EEPROM_BASE_ADDR;
+    m_score = (uint16_t)EEPROM.read(addr) | ((uint16_t)EEPROM.read(addr + 1) << 8); addr += 2;
+    m_high = (uint16_t)EEPROM.read(addr) | ((uint16_t)EEPROM.read(addr + 1) << 8);  addr += 2;
+    m_storedHigh = m_high;
+    
+    for(int i = 0; i < 9; i++) {
+        m_save[i] = EEPROM.read(addr++);
+    }
+}
+
+void Menu::SetScore(uint16_t score) {
+    if(score == 0) return;
+    m_high = (score > m_storedHigh) ? score : m_storedHigh;
+    m_score = score;
+}
+
+void Menu::WriteSave() {
+    uint8_t addr = EEPROM_BASE_ADDR;
+    EEPROM.update(addr++, (uint8_t)(m_score & 0xFF));
+    EEPROM.update(addr++, (uint8_t)(m_score >> 8));
+    EEPROM.update(addr++, (uint8_t)(m_high & 0xFF));
+    EEPROM.update(addr++, (uint8_t)(m_high >> 8));
+
+    for(int i = 0; i < 9; i++) {
+        EEPROM.update(addr++, m_save[i]);
+    }
+    EEPROM.commit();
+}

applications/system/FlipperDoom/game/Menu.h

@@ -0,0 +1,122 @@
+#pragma once
+#include <stdint.h>
+
+// 8x8, 8 кадров (0..7) — как в первом коде
+static const uint8_t PROGMEM transitionSet[] = {
+    8,
+    8,
+    // FRAME 00
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    // FRAME 01
+    0x00,
+    0x55,
+    0x00,
+    0x55,
+    0x00,
+    0x55,
+    0x00,
+    0x55,
+    // FRAME 02
+    0x00,
+    0xFF,
+    0x00,
+    0xFF,
+    0x00,
+    0xFF,
+    0x00,
+    0xFF,
+    // FRAME 03
+    0xAA,
+    0xFF,
+    0xAA,
+    0xFF,
+    0xAA,
+    0xFF,
+    0xAA,
+    0xFF,
+    // FRAME 04
+    0xFF,
+    0xFF,
+    0xFF,
+    0xFF,
+    0xFF,
+    0xFF,
+    0xFF,
+    0xFF,
+    // FRAME 05
+    0xFF,
+    0xAA,
+    0xFF,
+    0xAA,
+    0xFF,
+    0xAA,
+    0xFF,
+    0xAA,
+    // FRAME 06
+    0xFF,
+    0x00,
+    0xFF,
+    0x00,
+    0xFF,
+    0x00,
+    0xFF,
+    0x00,
+    // FRAME 07
+    0x55,
+    0x00,
+    0x55,
+    0x00,
+    0x55,
+    0x00,
+    0x55,
+    0x00,
+};
+
+class Menu {
+public:
+    void Init();
+    void Draw();
+    void Tick();
+
+    void ReadSave();
+    void WriteSave();
+
+    void TickEnteringLevel();
+    void DrawEnteringLevel();
+    void TransitionToLevel();
+
+    void TickGameOver();
+    void DrawGameOver();
+
+    void ResetTimer();
+    void FadeOut();
+
+private:
+    using TransitionNextFn = void (*)();
+    static void RunTransition(Menu* menu, uint8_t& t, TransitionNextFn next);
+    void DrawTransitionFrame(uint8_t frameIndex);
+
+    void SetScore(uint16_t score);
+    void PrintItem(uint8_t idx, uint8_t row);
+
+    uint8_t m_selection = 0;
+    uint8_t m_topIndex = 0;
+    uint8_t m_cursorPos = 0;
+
+    uint16_t m_score = 0;
+    uint16_t m_high = 0;
+    uint16_t m_storedHigh = 0;
+    uint8_t m_save[9] = {0};
+
+    union {
+        uint16_t timer;
+        uint16_t fizzleFade;
+    };
+};

applications/system/FlipperDoom/game/Particle.cpp

@@ -0,0 +1,149 @@
+#include "game/Particle.h"
+#include "game/FixedMath.h"
+#include "game/Platform.h"
+
+ParticleSystem ParticleSystemManager::systems[MAX_SYSTEMS];
+
+void ParticleSystem::Init()
+{
+	life = 0;
+}
+
+void ParticleSystem::Step()
+{
+	for (Particle& p : particles)
+	{
+		if (p.IsActive())
+		{
+			p.velY += gravity;
+
+			if (p.x + p.velX < -127 || p.x + p.velX > 127 || p.y + p.velY < -127)
+			{
+				p.x = -128;
+				continue;
+			}
+
+			if (p.y + p.velY >= 128)
+			{
+				p.velY = p.velX = 0;
+				p.y = 127;
+			}
+
+			p.x += p.velX;
+			p.y += p.velY;
+		}
+	}
+	
+	life--;
+}
+
+void ParticleSystem::Draw(int x, int halfScale)
+{
+	int scale = 2 * halfScale;
+	int8_t horizon = Renderer::GetHorizon(x);
+	uint8_t colour = isWhite ? COLOUR_WHITE : COLOUR_BLACK;
+	
+	for (Particle& p : particles)
+	{
+		if (p.IsActive())
+		{
+			int outX = x + ((p.x * scale) >> 8);
+			int outY = horizon + ((p.y * scale) >> 8);
+
+			if (outX >= 0 && outY >= 0 && outX < DISPLAY_WIDTH - 1 && outY < DISPLAY_HEIGHT - 1 && halfScale >= Renderer::wBuffer[outX])
+			{
+				Platform::PutPixel(outX, outY, colour);
+				Platform::PutPixel(outX + 1, outY, colour);
+				Platform::PutPixel(outX + 1, outY + 1, colour);
+				Platform::PutPixel(outX, outY + 1, colour);
+			}
+		}
+	}
+}
+
+void ParticleSystem::Explode()
+{
+	for (Particle& p : particles)
+	{
+		p.x = (Random() & 31) - 16;
+		p.y = (Random() & 31) - 16;
+
+		p.velX = (Random() & 31) - 16;
+		p.velY = (Random() & 31) - 25;
+	}
+	
+	life = 22;
+}
+
+void ParticleSystemManager::Draw()
+{
+	for (ParticleSystem& system : systems)
+	{
+		if(system.IsActive())
+		{
+			int16_t screenX, screenW;
+
+			if(Renderer::TransformAndCull(system.worldX, system.worldY, screenX, screenW))
+			{
+				QueuedDrawable* drawable = Renderer::CreateQueuedDrawable((uint8_t)screenW);
+				if(drawable)
+				{
+					drawable->type = DrawableType::ParticleSystem;
+					drawable->x = (int8_t)screenX;
+					drawable->inverseCameraDistance = (uint8_t)screenW;
+					drawable->particleSystem = &system;
+				}
+			}
+		}
+	}
+}
+
+void ParticleSystemManager::Init()
+{
+	for (ParticleSystem& system : systems)
+	{
+		system.Init();
+	}
+}
+
+void ParticleSystemManager::Update()
+{
+	for (ParticleSystem& system : systems)
+	{
+		if(system.IsActive())
+		{
+			system.Step();
+		}
+	}	
+}
+
+void ParticleSystemManager::CreateExplosion(int16_t worldX, int16_t worldY, bool isWhite)
+{
+	ParticleSystem* newSystem = nullptr;
+	for(ParticleSystem& system : systems)
+	{
+		if(!system.IsActive())
+		{
+			newSystem = &system;
+			break;
+		}
+	}	
+
+	if (!newSystem)
+	{
+		newSystem = &systems[0];
+
+		for (uint8_t n = 1; n < MAX_SYSTEMS; n++)
+		{
+			if (systems[n].life < newSystem->life)
+			{
+				newSystem = &systems[n];
+			}
+		}
+	}
+
+	newSystem->worldX = worldX;
+	newSystem->worldY = worldY;
+	newSystem->isWhite = isWhite;
+	newSystem->Explode();
+}

applications/system/FlipperDoom/game/Particle.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <stdint.h>
+#include "game/Defines.h"
+#include "game/Draw.h"
+#include "game/Game.h"
+
+struct Particle
+{
+	int8_t x, y;
+	int8_t velX, velY;
+
+	inline bool IsActive() { return x != -128; }
+};
+
+struct ParticleSystem
+{
+	static constexpr int8_t gravity = 3;
+	int16_t worldX, worldY;
+	bool isWhite : 1;
+	uint8_t life : 7;
+	Particle particles[PARTICLES_PER_SYSTEM];
+	
+	bool IsActive() { return life > 0; }
+
+	void Init();
+	void Step();
+	void Draw(int x, int scale);
+	void Explode();
+};
+
+class ParticleSystemManager
+{
+public:
+	static constexpr int MAX_SYSTEMS = 3;
+	static ParticleSystem systems[MAX_SYSTEMS];
+	
+	static void Init();
+	static void Draw();
+	static void Update();
+	static void CreateExplosion(int16_t x, int16_t y, bool isWhite = false);
+};

applications/system/FlipperDoom/game/Platform.cpp

@@ -0,0 +1,365 @@
+#include <furi.h>
+#include <furi_hal.h>
+#include <notification/notification.h>
+#include <notification/notification_messages.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "lib/flipper.h"
+
+#define COLOUR_WHITE 0
+#define COLOUR_BLACK 1
+
+#include "game/Game.h"
+#include "game/Draw.h"
+#include "game/FixedMath.h"
+#include "game/Platform.h"
+#include "game/Defines.h"
+#include "game/Sounds.h"
+#include "lib/EEPROM.h"
+
+// ---------------- SOUND ----------------
+
+typedef struct {
+    const uint16_t* pattern;
+} SoundRequest;
+
+static FuriMessageQueue* g_sound_queue = NULL;
+static FuriThread* g_sound_thread = NULL;
+static volatile bool g_sound_thread_running = false;
+static const float kSoundVolume = 1.0f;
+static const uint32_t kToneTickHz = 780;
+
+static inline uint32_t arduboy_ticks_to_ms(uint16_t ticks) {
+    return (uint32_t)((ticks * 1000u + (kToneTickHz / 2)) / kToneTickHz);
+}
+
+static int32_t sound_thread_fn(void* ctx) {
+    UNUSED(ctx);
+    SoundRequest req;
+
+    while(g_sound_thread_running) {
+        if(furi_message_queue_get(g_sound_queue, &req, 50) != FuriStatusOk) continue;
+        if(!g_state || !g_state->audio_enabled || !req.pattern) continue;
+        if(!furi_hal_speaker_acquire(50)) continue;
+
+        const uint16_t* p = req.pattern;
+        while(g_sound_thread_running && g_state && g_state->audio_enabled) {
+            SoundRequest new_req;
+            if(furi_message_queue_get(g_sound_queue, &new_req, 0) == FuriStatusOk) {
+                if(new_req.pattern) p = new_req.pattern;
+            }
+
+            uint16_t freq = *p++;
+            if(freq == TONES_END) break;
+
+            uint16_t dur_ticks = *p++;
+            uint32_t dur_ms = arduboy_ticks_to_ms(dur_ticks);
+            if(dur_ms == 0) dur_ms = 1;
+
+            if(freq == 0) {
+                furi_hal_speaker_stop();
+                furi_delay_ms(dur_ms);
+            } else {
+                furi_hal_speaker_start((float)freq, kSoundVolume);
+                furi_delay_ms(dur_ms);
+                furi_hal_speaker_stop();
+            }
+        }
+
+        furi_hal_speaker_stop();
+        furi_hal_speaker_release();
+    }
+
+    if(furi_hal_speaker_is_mine()) {
+        furi_hal_speaker_stop();
+        furi_hal_speaker_release();
+    }
+    return 0;
+}
+
+static void sound_system_init() {
+    if(g_sound_queue || g_sound_thread) return;
+
+    g_sound_queue = furi_message_queue_alloc(4, sizeof(SoundRequest));
+
+    g_sound_thread = furi_thread_alloc();
+    furi_thread_set_name(g_sound_thread, "GameSound");
+    furi_thread_set_stack_size(g_sound_thread, 1024);
+    furi_thread_set_priority(g_sound_thread, FuriThreadPriorityNormal);
+    furi_thread_set_callback(g_sound_thread, sound_thread_fn);
+
+    g_sound_thread_running = true;
+    furi_thread_start(g_sound_thread);
+}
+
+static void sound_system_deinit() {
+    if(!g_sound_thread) return;
+
+    g_sound_thread_running = false;
+    furi_thread_join(g_sound_thread);
+    furi_thread_free(g_sound_thread);
+    g_sound_thread = NULL;
+
+    if(g_sound_queue) {
+        furi_message_queue_free(g_sound_queue);
+        g_sound_queue = NULL;
+    }
+}
+
+void Platform::PlaySound(const uint16_t* audioPattern) {
+    if(!g_state || !g_state->audio_enabled || !audioPattern || !g_sound_queue) return;
+
+    SoundRequest req = {.pattern = audioPattern};
+    if(furi_message_queue_put(g_sound_queue, &req, 0) != FuriStatusOk) {
+        SoundRequest dummy;
+        (void)furi_message_queue_get(g_sound_queue, &dummy, 0);
+        (void)furi_message_queue_put(g_sound_queue, &req, 0);
+    }
+}
+
+bool Platform::IsAudioEnabled() {
+    return g_state && g_state->audio_enabled;
+}
+
+void Platform::SetAudioEnabled(bool enabled) {
+    if(!g_state) return;
+    bool was_enabled = g_state->audio_enabled;
+    g_state->audio_enabled = enabled;
+    if(enabled && !was_enabled)
+        sound_system_init();
+    else if(!enabled && was_enabled)
+        sound_system_deinit();
+}
+
+// ---------------- INPUT ----------------
+
+uint8_t Platform::GetInput() {
+    return g_state ? g_state->input_state : 0;
+}
+
+// ---------------- DRAW ----------------
+
+static constexpr uint8_t kDisplayPages = DISPLAY_HEIGHT / 8;
+
+static inline int16_t floor_div8(int16_t value) {
+    return (value >= 0) ? (value >> 3) : (int16_t)(-(((-value) + 7) >> 3));
+}
+
+static inline void set_pixel(int16_t x, int16_t y, bool color) {
+    if(!g_state) return;
+    if((uint16_t)x >= DISPLAY_WIDTH || (uint16_t)y >= DISPLAY_HEIGHT) return;
+
+    uint8_t* buf = g_state->back_buffer;
+    uint16_t idx = (uint16_t)(x + (y >> 3) * DISPLAY_WIDTH);
+    uint8_t mask = (uint8_t)(1u << (y & 7));
+
+    if(color)
+        buf[idx] |= mask;
+    else
+        buf[idx] &= (uint8_t)~mask;
+}
+
+void Platform::PutPixel(uint8_t x, uint8_t y, uint8_t color) {
+    set_pixel(x, y, color);
+}
+
+void Platform::FillScreen(uint8_t color) {
+    if(!g_state) return;
+    memset(g_state->back_buffer, color ? 0xFF : 0x00, BUFFER_SIZE);
+}
+
+uint8_t* Platform::GetScreenBuffer() {
+    return g_state ? g_state->back_buffer : NULL;
+}
+
+void Platform::DrawVLine(uint8_t x, int8_t y0, int8_t y1, uint8_t pattern) {
+    if(!g_state || pattern == 0 || x >= DISPLAY_WIDTH) return;
+
+    int16_t top = y0;
+    int16_t bottom = y1;
+
+    if(top > bottom) {
+        int16_t t = top;
+        top = bottom;
+        bottom = t;
+    }
+
+    if(bottom < 0 || top >= DISPLAY_HEIGHT) return;
+
+    if(top < 0) top = 0;
+    if(bottom >= DISPLAY_HEIGHT) bottom = DISPLAY_HEIGHT - 1;
+
+    uint8_t start_page = (uint8_t)(top >> 3);
+    uint8_t end_page = (uint8_t)(bottom >> 3);
+    uint8_t start_bit = (uint8_t)(top & 7);
+    uint8_t end_bit = (uint8_t)(bottom & 7);
+
+    uint8_t* buf = g_state->back_buffer;
+
+    if(start_page == end_page) {
+        uint8_t clip_mask =
+            (uint8_t)((uint8_t)(0xFFu << start_bit) & (uint8_t)(0xFFu >> (7u - end_bit)));
+        buf[(uint16_t)x + (uint16_t)start_page * DISPLAY_WIDTH] |= (uint8_t)(pattern & clip_mask);
+        return;
+    }
+
+    buf[(uint16_t)x + (uint16_t)start_page * DISPLAY_WIDTH] |=
+        (uint8_t)(pattern & (uint8_t)(0xFFu << start_bit));
+
+    for(uint8_t page = (uint8_t)(start_page + 1); page < end_page; page++) {
+        buf[(uint16_t)x + (uint16_t)page * DISPLAY_WIDTH] |= pattern;
+    }
+
+    buf[(uint16_t)x + (uint16_t)end_page * DISPLAY_WIDTH] |=
+        (uint8_t)(pattern & (uint8_t)(0xFFu >> (7u - end_bit)));
+}
+
+static inline uint8_t get_page_mask(uint8_t page, uint8_t total_pages, uint8_t height) {
+    if((page + 1u) != total_pages) return 0xFFu;
+    uint8_t tail_bits = (uint8_t)(height & 7u);
+    return tail_bits ? (uint8_t)((1u << tail_bits) - 1u) : 0xFFu;
+}
+
+void Platform::DrawBitmap(int16_t x, int16_t y, const uint8_t* bmp) {
+    if(!g_state || !bmp) return;
+
+    uint8_t w = bmp[0];
+    uint8_t h = bmp[1];
+    if(!w || !h) return;
+
+    int16_t x0 = x < 0 ? 0 : x;
+    int16_t x1 = x + w;
+    if(x1 > DISPLAY_WIDTH) x1 = DISPLAY_WIDTH;
+    if(x0 >= x1) return;
+
+    const uint8_t* data = bmp + 2;
+    uint8_t pages = (uint8_t)((h + 7u) >> 3);
+    uint8_t* dst = g_state->back_buffer;
+
+    for(int16_t dx = x0; dx < x1; dx++) {
+        uint8_t sx = (uint8_t)(dx - x);
+        const uint8_t* src_col = data + sx;
+
+        for(uint8_t page = 0; page < pages; page++) {
+            int16_t base_y = y + ((int16_t)page << 3);
+            if(base_y <= -8 || base_y >= DISPLAY_HEIGHT) continue;
+
+            uint8_t src = src_col[(uint16_t)page * w] & get_page_mask(page, pages, h);
+            if(src == 0) continue;
+
+            int16_t dst_page = floor_div8(base_y);
+            uint8_t y_shift = (uint8_t)(base_y - (dst_page << 3));
+
+            uint8_t low = (uint8_t)(src << y_shift);
+            if((uint16_t)dst_page < kDisplayPages) {
+                uint16_t idx = (uint16_t)dx + (uint16_t)dst_page * DISPLAY_WIDTH;
+                dst[idx] &= (uint8_t)~low;
+            }
+
+            if(y_shift && (uint16_t)(dst_page + 1) < kDisplayPages) {
+                uint8_t high = (uint8_t)(src >> (8u - y_shift));
+                uint16_t idx = (uint16_t)dx + (uint16_t)(dst_page + 1) * DISPLAY_WIDTH;
+                dst[idx] &= (uint8_t)~high;
+            }
+        }
+    }
+}
+
+void Platform::DrawSolidBitmap(int16_t x, int16_t y, const uint8_t* bmp) {
+    if(!g_state || !bmp) return;
+
+    uint8_t w = bmp[0];
+    uint8_t h = bmp[1];
+    if(!w || !h) return;
+
+    int16_t x0 = x < 0 ? 0 : x;
+    int16_t x1 = x + w;
+    if(x1 > DISPLAY_WIDTH) x1 = DISPLAY_WIDTH;
+    if(x0 >= x1) return;
+
+    const uint8_t* data = bmp + 2;
+    uint8_t pages = (uint8_t)((h + 7u) >> 3);
+    uint8_t* dst = g_state->back_buffer;
+
+    for(int16_t dx = x0; dx < x1; dx++) {
+        uint8_t sx = (uint8_t)(dx - x);
+        const uint8_t* src_col = data + sx;
+
+        for(uint8_t page = 0; page < pages; page++) {
+            int16_t base_y = y + ((int16_t)page << 3);
+            if(base_y <= -8 || base_y >= DISPLAY_HEIGHT) continue;
+
+            uint8_t page_mask = get_page_mask(page, pages, h);
+            uint8_t src = src_col[(uint16_t)page * w] & page_mask;
+            uint8_t fill = (uint8_t)(~src) & page_mask;
+
+            int16_t dst_page = floor_div8(base_y);
+            uint8_t y_shift = (uint8_t)(base_y - (dst_page << 3));
+
+            uint8_t region_low = (uint8_t)(page_mask << y_shift);
+            uint8_t fill_low = (uint8_t)(fill << y_shift);
+            if((uint16_t)dst_page < kDisplayPages) {
+                uint16_t idx = (uint16_t)dx + (uint16_t)dst_page * DISPLAY_WIDTH;
+                dst[idx] = (uint8_t)((dst[idx] & (uint8_t)~region_low) | fill_low);
+            }
+
+            if(y_shift && (uint16_t)(dst_page + 1) < kDisplayPages) {
+                uint8_t region_high = (uint8_t)(page_mask >> (8u - y_shift));
+                uint8_t fill_high = (uint8_t)(fill >> (8u - y_shift));
+                uint16_t idx = (uint16_t)dx + (uint16_t)(dst_page + 1) * DISPLAY_WIDTH;
+                dst[idx] = (uint8_t)((dst[idx] & (uint8_t)~region_high) | fill_high);
+            }
+        }
+    }
+}
+
+void Platform::DrawSprite(int16_t x, int16_t y, const uint8_t* bmp, uint8_t frame) {
+    if(!g_state || !bmp) return;
+
+    uint8_t w = bmp[0];
+    uint8_t h = bmp[1];
+    if(!w || !h) return;
+
+    int16_t x0 = x < 0 ? 0 : x;
+    int16_t x1 = x + w;
+    if(x1 > DISPLAY_WIDTH) x1 = DISPLAY_WIDTH;
+    if(x0 >= x1) return;
+
+    uint8_t pages = (uint8_t)((h + 7u) >> 3);
+    uint16_t frame_size = (uint16_t)(w * pages);
+    const uint8_t* data = bmp + 2 + (uint32_t)frame * frame_size * 2u;
+    uint8_t* dst = g_state->back_buffer;
+
+    for(int16_t dx = x0; dx < x1; dx++) {
+        uint8_t sx = (uint8_t)(dx - x);
+
+        for(uint8_t page = 0; page < pages; page++) {
+            int16_t base_y = y + ((int16_t)page << 3);
+            if(base_y <= -8 || base_y >= DISPLAY_HEIGHT) continue;
+
+            uint16_t src_index = (uint16_t)((page * w + sx) * 2u);
+            uint8_t src = data[src_index];
+            uint8_t mask = data[src_index + 1] & get_page_mask(page, pages, h);
+            if(mask == 0) continue;
+
+            uint8_t fill = (uint8_t)(src & mask);
+            int16_t dst_page = floor_div8(base_y);
+            uint8_t y_shift = (uint8_t)(base_y - (dst_page << 3));
+
+            uint8_t region_low = (uint8_t)(mask << y_shift);
+            uint8_t fill_low = (uint8_t)(fill << y_shift);
+            if((uint16_t)dst_page < kDisplayPages) {
+                uint16_t idx = (uint16_t)dx + (uint16_t)dst_page * DISPLAY_WIDTH;
+                dst[idx] = (uint8_t)((dst[idx] & (uint8_t)~region_low) | fill_low);
+            }
+
+            if(y_shift && (uint16_t)(dst_page + 1) < kDisplayPages) {
+                uint8_t region_high = (uint8_t)(mask >> (8u - y_shift));
+                uint8_t fill_high = (uint8_t)(fill >> (8u - y_shift));
+                uint16_t idx = (uint16_t)dx + (uint16_t)(dst_page + 1) * DISPLAY_WIDTH;
+                dst[idx] = (uint8_t)((dst[idx] & (uint8_t)~region_high) | fill_high);
+            }
+        }
+    }
+}

applications/system/FlipperDoom/game/Platform.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <stdint.h>
+
+class Platform
+{
+public:
+	static uint8_t GetInput(void);
+	static uint8_t* GetScreenBuffer(); 
+
+	static void PlaySound(const uint16_t* audioPattern);
+	static bool IsAudioEnabled();
+	static void SetAudioEnabled(bool isEnabled);
+	
+	static void FillScreen(uint8_t col);
+	static void PutPixel(uint8_t x, uint8_t y, uint8_t colour);
+	static void DrawBitmap(int16_t x, int16_t y, const uint8_t *bitmap);
+	static void DrawSolidBitmap(int16_t x, int16_t y, const uint8_t *bitmap);
+	static void DrawSprite(int16_t x, int16_t y, const uint8_t *bitmap, const uint8_t *mask, uint8_t frame, uint8_t mask_frame);
+	static void DrawSprite(int16_t x, int16_t y, const uint8_t *bitmap, uint8_t frame);	
+
+	static void DrawVLine(uint8_t x, int8_t y1, int8_t y2, uint8_t pattern);
+	static void DrawBackground();
+};

applications/system/FlipperDoom/game/Player.cpp

@@ -0,0 +1,328 @@
+#include "game/Player.h"
+#include "game/Game.h"
+#include "game/FixedMath.h"
+#include "game/Projectile.h"
+#include "game/Platform.h"
+#include "game/Draw.h"
+#include "game/Enemy.h"
+#include "game/Map.h"
+#include "game/Sounds.h"
+#include "game/Particle.h"
+
+#define USE_ROTATE_BOB 0
+#define STRAFE_TILT 14
+#define ROTATE_TILT 3
+
+const char SignMessage1[] PROGMEM = "Abandon all hope ye who enter!";
+
+void Player::Init()
+{
+	NextLevel();
+	hp = maxHP;
+}
+
+void Player::NextLevel()
+{
+	x = CELL_SIZE * 1 + CELL_SIZE / 2;
+	y = CELL_SIZE * 1 + CELL_SIZE / 2;
+	angle = FIXED_ANGLE_45;
+	mana = maxMana;
+	damageTime = 0;
+	shakeTime = 0;
+	reloadTime = 0;
+	velocityX = 0;
+	velocityY = 0;
+	angularVelocity = 0;
+}
+
+void Player::Fire()
+{
+	if (mana >= manaFireCost)
+	{
+		reloadTime = 8;
+		shakeTime = 6;
+
+		int16_t projectileX = x + FixedCos(angle + FIXED_ANGLE_90 / 2) / 4;
+		int16_t projectileY = y + FixedSin(angle + FIXED_ANGLE_90 / 2) / 4;
+
+		ProjectileManager::FireProjectile(this, projectileX, projectileY, angle);
+		mana -= manaFireCost;
+		Platform::PlaySound(Sounds::Attack);
+	}
+}
+
+void Player::Tick()
+{
+	uint8_t input = Platform::GetInput();
+	int8_t turnDelta = 0;
+	int8_t targetTilt = 0;
+	int8_t moveDelta = 0;
+	int8_t strafeDelta = 0;
+
+	// Doom-style circle strafe: holding OK (fire) makes left/right strafe
+	if (input & (INPUT_A | INPUT_B))
+	{
+		if (input & INPUT_LEFT)
+		{
+			strafeDelta--;
+		}
+		if (input & INPUT_RIGHT)
+		{
+			strafeDelta++;
+		}
+	}
+	else
+	{
+		if (input & INPUT_LEFT)
+		{
+			turnDelta -= TURN_SPEED * 2;
+		}
+		if (input & INPUT_RIGHT)
+		{
+			turnDelta += TURN_SPEED * 2;
+		}
+	}
+
+	// Testing shooting / recoil mechanic
+
+	if (reloadTime > 0)
+	{
+		reloadTime--;
+	}
+	else if (input & INPUT_B)
+	{
+		Fire();
+	}
+
+
+	if (angularVelocity < turnDelta)
+	{
+		angularVelocity++;
+	}
+	else if (angularVelocity > turnDelta)
+	{
+		angularVelocity--;
+	}
+
+	angle += angularVelocity >> 1;
+
+	if (input & INPUT_UP)
+	{
+		moveDelta++;
+	}
+	if (input & INPUT_DOWN)
+	{
+		moveDelta--;
+	}
+
+	static int tiltTimer = 0;
+	tiltTimer++;
+	if (moveDelta && USE_ROTATE_BOB)
+	{
+		targetTilt = (int8_t)(FixedSin(tiltTimer * 10) / 32);
+	}
+	else
+	{
+		targetTilt = 0;
+	}
+
+	targetTilt += angularVelocity * ROTATE_TILT;
+	targetTilt += strafeDelta * STRAFE_TILT;
+	int8_t targetBob = moveDelta || strafeDelta ? FixedSin(tiltTimer * 10) / 128 : 0;
+
+	if (shakeTime > 0)
+	{
+		shakeTime--;
+		targetBob += (Random() & 3) - 1;
+		targetTilt += (Random() & 31) - 16;
+	}
+
+	constexpr int tiltRate = 6;
+
+	if (Renderer::camera.tilt < targetTilt)
+	{
+		Renderer::camera.tilt += tiltRate;
+		if (Renderer::camera.tilt > targetTilt)
+		{
+			Renderer::camera.tilt = targetTilt;
+		}
+	}
+	else if (Renderer::camera.tilt > targetTilt)
+	{
+		Renderer::camera.tilt -= tiltRate;
+		if (Renderer::camera.tilt < targetTilt)
+		{
+			Renderer::camera.tilt = targetTilt;
+		}
+	}
+
+	constexpr int bobRate = 3;
+
+	if (Renderer::camera.bob < targetBob)
+	{
+		Renderer::camera.bob += bobRate;
+		if (Renderer::camera.bob > targetBob)
+		{
+			Renderer::camera.bob = targetBob;
+		}
+	}
+	else if (Renderer::camera.bob > targetBob)
+	{
+		Renderer::camera.bob -= bobRate;
+		if (Renderer::camera.bob < targetBob)
+		{
+			Renderer::camera.bob = targetBob;
+		}
+	}
+
+	int16_t cosAngle = FixedCos(angle);
+	int16_t sinAngle = FixedSin(angle);
+
+	int16_t cos90Angle = FixedCos(angle + FIXED_ANGLE_90);
+	int16_t sin90Angle = FixedSin(angle + FIXED_ANGLE_90);
+	//camera.x += (moveDelta * cosAngle) >> 4;
+	//camera.y += (moveDelta * sinAngle) >> 4;
+	velocityX += (moveDelta * cosAngle) / 24;
+	velocityY += (moveDelta * sinAngle) / 24;
+
+	velocityX += (strafeDelta * cos90Angle) / 24;
+	velocityY += (strafeDelta * sin90Angle) / 24;
+
+	Move(velocityX / 4, velocityY / 4);
+
+	velocityX = (velocityX * 7) / 8;
+	velocityY = (velocityY * 7) / 8;
+
+	if (mana < maxMana && reloadTime == 0)
+	{
+		mana += manaRechargeRate;
+	}
+
+	if (damageTime > 0)
+		damageTime--;
+
+	uint8_t cellX = x / CELL_SIZE;
+	uint8_t cellY = y / CELL_SIZE;
+
+	switch (Map::GetCellSafe(cellX, cellY))
+	{
+	case CellType::Potion:
+		if (hp < maxHP)
+		{
+			if (hp + potionStrength > maxHP)
+				hp = maxHP;
+			else
+				hp += potionStrength;
+			Map::SetCell(cellX, cellY, CellType::Empty);
+			Platform::PlaySound(Sounds::Pickup);
+			Game::ShowMessage(PSTR("Picked up a stimpack"));
+		}
+		break;
+	case CellType::Coins:
+		Map::SetCell(cellX, cellY, CellType::Empty);
+		Platform::PlaySound(Sounds::Pickup);
+		Game::ShowMessage(PSTR("Picked up a health bonus"));
+		Game::stats.coinsCollected++;
+		break;
+	case CellType::Crown:
+		Map::SetCell(cellX, cellY, CellType::Empty);
+		Platform::PlaySound(Sounds::Pickup);
+		Game::ShowMessage(PSTR("Picked up some armor"));
+		Game::stats.crownsCollected++;
+		break;
+	case CellType::Scroll:
+		Map::SetCell(cellX, cellY, CellType::Empty);
+		Platform::PlaySound(Sounds::Pickup);
+		Game::ShowMessage(PSTR("Picked up an armor bonus"));
+		Game::stats.scrollsCollected++;
+		break;
+	default:
+    break;
+	}
+}
+
+bool Player::IsWorldColliding() const
+{
+	return Map::IsBlockedAtWorldPosition(x - collisionSize, y - collisionSize)
+		|| Map::IsBlockedAtWorldPosition(x + collisionSize, y - collisionSize)
+		|| Map::IsBlockedAtWorldPosition(x + collisionSize, y + collisionSize)
+		|| Map::IsBlockedAtWorldPosition(x - collisionSize, y + collisionSize);
+}
+
+bool Player::CheckCollisions()
+{
+	int16_t lookAheadX = (x + (FixedCos(angle) * lookAheadDistance) / FIXED_ONE);
+	int16_t lookAheadY = (y + (FixedSin(angle) * lookAheadDistance) / FIXED_ONE);
+	uint8_t lookAheadCellX = (uint8_t)(lookAheadX / CELL_SIZE);
+	uint8_t lookAheadCellY = (uint8_t)(lookAheadY / CELL_SIZE);
+
+	CellType lookAheadCell = Map::GetCellSafe(lookAheadCellX, lookAheadCellY);
+	switch (lookAheadCell)
+	{
+	case CellType::Chest:
+		Map::SetCell(lookAheadCellX, lookAheadCellY, CellType::ChestOpened);
+		ParticleSystemManager::CreateExplosion(lookAheadX, lookAheadY, true);
+		Platform::PlaySound(Sounds::Pickup);
+		Game::ShowMessage(PSTR("Found a backpack of ammo!"));
+		Game::stats.chestsOpened++;
+		break;
+	case CellType::Sign:
+		Game::ShowMessage(SignMessage1);
+		break;
+	default:
+    break;
+
+	}
+
+	if (IsWorldColliding())
+	{
+		return true;
+	}
+
+	if (EnemyManager::GetOverlappingEnemy(*this))
+	{
+		return true;
+	}
+
+	return false;
+}
+
+void Player::Move(int16_t deltaX, int16_t deltaY)
+{
+	x += deltaX;
+	y += deltaY;
+
+	if (CheckCollisions())
+	{
+		y -= deltaY;
+		if (CheckCollisions())
+		{
+			x -= deltaX;
+			y += deltaY;
+
+			if (CheckCollisions())
+			{
+				y -= deltaY;
+			}
+		}
+	}
+}
+
+void Player::Damage(uint8_t damageAmount)
+{
+	if(shakeTime < 6)
+		shakeTime = 6;
+
+	damageTime = 8;
+	
+	if (hp <= damageAmount)
+	{
+		Platform::PlaySound(Sounds::PlayerDeath);
+		hp = 0;
+	}
+	else
+	{
+		Platform::PlaySound(Sounds::Ouch);
+		hp -= damageAmount;
+	}
+}

applications/system/FlipperDoom/game/Player.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <stdint.h>
+#include "game/Entity.h"
+
+class Player : public Entity
+{
+public:
+	uint8_t angle;
+	int16_t velocityX, velocityY;
+	int8_t angularVelocity;
+
+	uint8_t shakeTime;
+	uint8_t damageTime;
+	uint8_t reloadTime;
+
+	static constexpr uint8_t maxHP = 100;
+	static constexpr uint8_t maxMana = 100;
+	static constexpr uint8_t manaFireCost = 20;
+	static constexpr uint8_t manaRechargeRate = 1;
+	static constexpr uint8_t attackStrength = 10;
+	static constexpr uint8_t collisionSize = 48;
+	static constexpr uint8_t lookAheadDistance = 60;
+	static constexpr uint8_t potionStrength = 25;
+
+	uint8_t hp;
+	uint8_t mana;
+
+	void Init();
+	void NextLevel();
+	void Tick();
+	void Fire();
+	void Move(int16_t deltaX, int16_t deltaY);
+	bool CheckCollisions();
+	void Damage(uint8_t amount);
+	bool IsWorldColliding() const;
+};

applications/system/FlipperDoom/game/Projectile.cpp

@@ -0,0 +1,185 @@
+#include "game/Defines.h"
+#include "game/Projectile.h"
+#include "game/Map.h"
+#include "game/FixedMath.h"
+#include "game/Particle.h"
+#include "game/Enemy.h"
+#include "game/Generated/SpriteTypes.h"
+#include "game/Platform.h"
+#include "game/Sounds.h"
+
+Projectile ProjectileManager::projectiles[ProjectileManager::MAX_PROJECTILES];
+
+Projectile* ProjectileManager::FireProjectile(Entity* owner, int16_t x, int16_t y, uint8_t angle)
+{
+	for (Projectile& p : projectiles)
+	{
+		if(p.life == 0)
+		{
+			if (owner == &Game::player)
+				p.ownerId = Projectile::playerOwnerId;
+			else
+			{
+				for (uint8_t n = 0; n < EnemyManager::maxEnemies; n++)
+				{
+					if (&EnemyManager::enemies[n] == owner)
+					{
+						p.ownerId = n;
+						break;
+					}
+				}
+			}
+
+			p.life = 255;
+			p.x = x;
+			p.y = y;
+			p.angle = angle;
+			return &p;
+		}
+	}
+
+	return nullptr;
+}
+
+Entity* Projectile::GetOwner() const
+{
+	if (ownerId == playerOwnerId)
+		return &Game::player;
+	return &EnemyManager::enemies[ownerId];
+}
+
+void ProjectileManager::Update()
+{
+	for (Projectile& p : projectiles)
+	{
+		if(p.life > 0)
+		{
+			p.life--;
+
+			int16_t deltaX = FixedCos(p.angle) / 4;
+			int16_t deltaY = FixedSin(p.angle) / 4;
+
+			p.x += deltaX;
+			p.y += deltaY;
+
+			bool hitAnything = false;
+
+			Entity* owner = p.GetOwner();
+
+			if (Map::IsBlockedAtWorldPosition(p.x, p.y))
+			{
+				uint8_t cellX = p.x / CELL_SIZE;
+				uint8_t cellY = p.y / CELL_SIZE;
+
+				if (Map::GetCellSafe(cellX, cellY) == CellType::Urn)
+				{
+					// Exploding barrel: splash damage to everything nearby
+					int16_t barrelX = cellX * CELL_SIZE + CELL_SIZE / 2;
+					int16_t barrelY = cellY * CELL_SIZE + CELL_SIZE / 2;
+					constexpr int16_t blastRadius = CELL_SIZE + CELL_SIZE / 2;
+					constexpr uint8_t enemyBlastDamage = 40;
+					constexpr uint8_t playerBlastDamage = 15;
+
+					Map::SetCell(cellX, cellY, CellType::Empty);
+					ParticleSystemManager::CreateExplosion(barrelX, barrelY, true);
+
+					for (uint8_t n = 0; n < EnemyManager::maxEnemies; n++)
+					{
+						Enemy& enemy = EnemyManager::enemies[n];
+						if (!enemy.IsValid())
+							continue;
+						int16_t dx = enemy.x - barrelX;
+						int16_t dy = enemy.y - barrelY;
+						if (ABS(dx) < blastRadius && ABS(dy) < blastRadius)
+						{
+							enemy.Damage(enemyBlastDamage);
+						}
+					}
+
+					{
+						int16_t dx = Game::player.x - barrelX;
+						int16_t dy = Game::player.y - barrelY;
+						if (ABS(dx) < blastRadius && ABS(dy) < blastRadius)
+						{
+							// barrels hurt but never kill the player outright
+							uint8_t dmg = playerBlastDamage;
+							if (Game::player.hp <= dmg)
+								dmg = Game::player.hp > 1 ? (uint8_t)(Game::player.hp - 1) : 0;
+							if (dmg)
+								Game::player.Damage(dmg);
+						}
+					}
+
+					// occasionally the barrel leaves a pickup behind
+					switch ((Random() % 6))
+					{
+					case 0:
+						Map::SetCell(cellX, cellY, CellType::Potion);
+						break;
+					case 1:
+						Map::SetCell(cellX, cellY, CellType::Coins);
+						break;
+					}
+					Platform::PlaySound(Sounds::Kill);
+				}
+				else
+				{
+					Platform::PlaySound(Sounds::Hit);
+				}
+
+				hitAnything = true;
+			}
+			else
+			{
+				if (owner == &Game::player)
+				{
+					Enemy* overlappingEnemy = EnemyManager::GetOverlappingEnemy(p.x, p.y);
+					if (overlappingEnemy)
+					{
+						overlappingEnemy->Damage(Player::attackStrength);
+
+						hitAnything = true;
+					}
+				}
+				else if(Game::player.IsOverlappingPoint(p.x, p.y))
+				{
+					const EnemyArchetype* enemyArchetype = ((Enemy*)owner)->GetArchetype();
+					if (enemyArchetype)
+					{
+						Game::player.Damage(enemyArchetype->GetAttackStrength());
+						if (Game::player.hp == 0)
+						{
+							Game::stats.killedBy = ((Enemy*)owner)->GetType();
+						}
+					}
+					hitAnything = true;
+				}
+			}
+
+			if (hitAnything)
+			{
+				ParticleSystemManager::CreateExplosion(p.x - deltaX, p.y - deltaY);
+				p.life = 0;
+			}
+		}
+	}	
+}
+
+void ProjectileManager::Init()
+{
+	for (Projectile& p : projectiles)
+	{
+		p.life = 0;
+	}
+}
+
+void ProjectileManager::Draw()
+{
+	for(Projectile& p : projectiles)
+	{
+		if (p.life > 0)
+		{
+			Renderer::DrawObject(p.ownerId == Projectile::playerOwnerId ? projectileSpriteData : enemyProjectileSpriteData, p.x, p.y, 32, AnchorType::BelowCenter);
+		}
+	}
+}

applications/system/FlipperDoom/game/Projectile.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <stdint.h>
+#include "game/Entity.h"
+
+class Projectile : public Entity
+{
+public:
+	uint8_t angle;
+	uint8_t life;
+	uint8_t ownerId;
+
+	static constexpr uint8_t playerOwnerId = 0xff;
+
+	Entity* GetOwner() const;
+};
+
+class ProjectileManager
+{
+public:
+	static constexpr int MAX_PROJECTILES = 8;
+	static Projectile projectiles[MAX_PROJECTILES];
+
+	static Projectile* FireProjectile(Entity* owner, int16_t x, int16_t y, uint8_t angle);
+	static void Init();
+	static void Draw();
+	static void Update();
+};

applications/system/FlipperDoom/game/Sounds.cpp

@@ -0,0 +1,60 @@
+#include "game/Sounds.h"
+
+// Shotgun blast: sharp crack followed by a fast descending boom with a
+// short pump echo. All frequencies within the buzzer's 100-2500 Hz range.
+const uint16_t Sounds::Attack[] PROGMEM = {
+	900, 2, 500, 3, 320, 4, 230, 5,
+	180, 6, 150, 7, 128, 9, 112, 11, 104, 13, 100, 15,
+	0, 8,
+	170, 4, 135, 6, 112, 9, 100, 14,
+	TONES_END
+};
+
+const uint16_t Sounds::Kill[] PROGMEM = {
+	0x0151,0x0007,0x0000,0x0015,0x018d,0x0007,0x0000,0x0007,0x014b,0x0007,0x0136,0x0007,0x0146,0x0007,0x0169,0x0007,0x019e,0x0007,0x007f,0x0007,0x0185,
+	0x0007,0x0228,0x0007,0x026d,0x0007,0x02fc,0x0007,0x02e0,0x0007,0x01fd,0x0007,0x0219,0x0007,0x033c,0x0007,0x00e7,0x0007,0x0281,0x0007,0x026d,
+	0x000e,0x052d,0x000e,0x04da,0x000e,0x011c,0x0007,0x0387,0x0007,0x0360,0x0007,0x033c,0x0007,0x0387,0x0007,0x02ad,0x000e,0x02c6,0x0007,0x010c,
+	0x000e,0x02e0,0x0007,0x02c6,0x0007,0x0296,0x000e,0x0281,0x0007,0x02ad,0x0007,0x02c6,0x0007,0x02e0,0x0007,0x00e1,0x0007,0x031b,0x0007,0x0248,
+	0x0007,0x0219,0x0007,0x01f1,0x0007,0x01d9,0x000e,0x01f1,0x0007,0x020b,0x0007,0x02ad,0x0007,0x00d1,0x0007,0x0248,0x0007,0x0238,0x0007,0x0219,
+	0x0007,0x0228,0x000e,0x020b,0x0007,0x01e5,0x0007,0x01d9,0x0007, TONES_END
+};
+
+const uint16_t Sounds::Hit[] PROGMEM = {
+	0x0195,0x0007,0x0000,0x0015,0x018d,0x0007,0x0000,0x0007,0x0416,0x0007,0x007f,0x0007,0x0000,0x000e,0x0177,0x0007,0x0000,0x001d,0x0146,0x0007,0x0140,
+	0x0007,0x013b,0x0007,0x0000,0x0047,0x00e7,0x0007,0x00e4,0x0007,0x0000,0x0015,0x009f,0x0007,0x009d,0x0007,0x0000,0x0088,0x0088,0x0007, TONES_END
+};
+
+const uint16_t Sounds::PlayerDeath[] PROGMEM = {
+	0x01b0,0x0007,0x0000,0x0015,0x00c8,0x0007,0x0000,0x0007,0x03b2,0x0007,0x0360,0x0007,0x02e0,0x0007,0x0296,0x0007,0x0248,0x0007,0x0219,0x0007,0x01fd,
+	0x0007,0x0450,0x0007,0x01ce,0x0007,0x01b9,0x0007,0x01a7,0x0007,0x0450,0x0007,0x017e,0x0007,0x0163,0x0007,0x0140,0x0007,0x052d,0x0007,0x0110,
+	0x0007,0x0109,0x0007,0x0102,0x0007,0x00f8,0x0007,0x04da,0x0007,0x00ca,0x0007,0x00bb,0x0007,0x00b3,0x0007,0x0491,0x0007,0x0096,0x0007,0x00d8,
+	0x0007,0x0000,0x001d,0x0296,0x0007,0x0000,0x002b,0x0228,0x0007,0x0000,0x0024,0x00fb,0x000e, TONES_END
+};
+
+const uint16_t Sounds::SpotPlayer[] PROGMEM = {
+	0x0110,0x0007,0x0000,0x0015,0x018d,0x0007,0x0000,0x0007,0x01d9,0x0007,0x01fd,0x0007,0x020b,0x000e,0x0228,0x000e,0x0238,0x0007,0x0248,0x0007,0x026d,
+	0x0007,0x0281,0x0032,0x026d,0x0015,0x0248,0x0007,0x0238,0x0007,0x01b0,0x0007,0x017e,0x0007,0x0169,0x0007,0x014b,0x0007,0x0136,0x0007,0x0131,
+	0x0007,0x0102,0x0007,0x00f8,0x0007,0x00f2,0x0007,0x00e9,0x0007,0x00e4,0x0007,0x00d8,0x0007,0x00bd,0x0007,0x00ab,0x0007,0x009d,0x0007,0x0096,
+	0x0007,0x0094,0x0007,0x0092,0x0007,0x008e,0x0007,0x008b,0x0007,0x008a,0x0007,0x0089,0x0007,0x0088,0x0007,0x0087,0x0007,0x0086,0x0007,0x0085,
+	0x0007,0x0084,0x0007,0x0083,0x0007,0x0082,0x0007,0x0081,0x000e,0x0081,0x0007,0x0080,0x0007,0x007e,0x0007,0x007d,0x0007,0x007d,0x0007,0x0000,
+	0x0040,0x0090,0x0032, TONES_END
+};
+
+const uint16_t Sounds::Shoot[] PROGMEM = {
+	0x02e0,0x0007,0x0000,0x0015,0x03e2,0x0007,0x0000,0x0007,0x04da,0x0015,0x00b4,0x0007,0x01d9,0x0007,0x0000,0x0007,0x01f1,0x000e,0x0080,0x0007,0x01f1,
+	0x0007,0x0000,0x000e,0x025a,0x0007,0x00e4,0x0007,0x0000,0x0015,0x00c1,0x0007,0x0000,0x000e,0x01e5,0x0007,0x0000,0x0007,0x00ac,0x0007,0x0000,
+	0x0015,0x0091,0x0007, TONES_END
+};
+
+const uint16_t Sounds::Pickup[] PROGMEM = {
+	0x0120,0x0007,0x0000,0x0015,0x00e9,0x0007,0x0000,0x0007,0x0156,0x0015,0x0000,0x0032,0x0185,0x001d,0x0000,0x0040,0x020b,0x0015,0x0000,0x0032,0x0387,
+	0x0024,0x0000,0x0040,0x0387,0x002b,0x0000,0x0040,0x03b2,0x0032, TONES_END
+};
+
+const uint16_t Sounds::Ouch[] PROGMEM = {
+	0x01ce,0x0007,0x0000,0x0015,0x018d,0x0007,0x0000,0x0007,0x0416,0x0007,0x0491,0x0007,0x03b2,0x0007,0x04da,0x0007,0x052d,0x0015,0x04da,0x0007,0x0491,
+	0x0007,0x02e0,0x0007,0x0296,0x0007,0x025a,0x0007,0x01f1,0x0007,0x0219,0x0007,0x0000,0x0007,0x01ce,0x0007,0x007c,0x000e,0x015c,0x0007,0x007d,
+	0x000e,0x0120,0x0007,0x007d,0x000e,0x00ef,0x0007,0x00d5,0x0007,0x00ca,0x0007,0x0000,0x0007,0x00c1,0x0007,0x00b9,0x0007,0x00b3,0x0007,0x00a9,
+	0x0007,0x007d,0x0007,0x007e,0x0007,0x0093,0x0007,0x007e,0x0007,0x0000,0x0007,0x0089,0x0007,0x0085,0x0007,0x0082,0x0007,0x0080,0x0007,0x007e,
+	0x0007,0x007d,0x0007, TONES_END
+};

applications/system/FlipperDoom/game/Sounds.h

@@ -0,0 +1,18 @@
+#pragma once
+#include <stdint.h>
+#include "game/Defines.h"
+
+#define TONES_END 0x8000
+
+class Sounds
+{
+public:
+	static const uint16_t Attack[];
+	static const uint16_t Kill[];
+	static const uint16_t Hit[];
+	static const uint16_t PlayerDeath[];
+	static const uint16_t SpotPlayer[];
+	static const uint16_t Shoot[];
+	static const uint16_t Pickup[];
+	static const uint16_t Ouch[];
+};

applications/system/FlipperDoom/game/Textures.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include "game/Defines.h"
+
+// Tech-base wall panel: top/bottom seams with vertical panel gaps
+const uint8_t vectorTexture0[] PROGMEM =
+{
+	6,
+	0, 18, 128, 18,
+	0, 110, 128, 110,
+	32, 18, 32, 110,
+	64, 18, 64, 110,
+	96, 18, 96, 110,
+	48, 64, 80, 64,
+};
+
+const uint8_t vectorTexture1[] PROGMEM =
+{
+	6,
+	0, 16, 128, 16 ,
+	0, 112, 128, 112 ,
+	0, 16, 0, 112,
+	0, 16, 128, 112,
+	0, 112, 128, 16,
+	128, 16, 128, 112,
+
+	/*	16, 16, 112, 16 ,
+	16, 16, 16, 128,
+	48, 16, 48, 128,
+	80, 16, 80, 128,
+	112, 16, 112, 128,*/
+};
+
+const uint8_t vectorTexture2[] PROGMEM =
+{
+	12,
+	38,13,90,13,
+	38,13,64,38,
+	64,38,90,13,
+	13,38,38,64,
+	13,38,13,90,
+	13,90,38,64,
+	38,115,90,115,
+	38,115,64,90,
+	64,90,90,115,
+	90,64,115,38,
+	90,64,115,90,
+	115,38,115,90,
+};
+
+const uint8_t* const textures[] PROGMEM =
+{
+	vectorTexture0,
+	vectorTexture1,
+	vectorTexture2,
+};

applications/system/FlipperDoom/lib/EEPROM.h

@@ -0,0 +1,235 @@
+#pragma once
+#include <stdint.h>
+#include <stddef.h>
+#include <string.h>
+
+#include <furi.h>
+#include <storage/storage.h>
+
+#define EEPROM_LIB_PATH APP_DATA_PATH("eeprom.bin")
+
+class EEPROMClass {
+public:
+    static constexpr int kSize = 16;
+    static constexpr size_t kPathSize = 128;
+
+    EEPROMClass()
+        : loaded_(false)
+        , dirty_(false)
+        , path_resolved_(false) {
+        memset(mem_, 0x00, kSize);
+        memset(file_path_, 0x00, kPathSize);
+        strncpy(file_path_, EEPROM_LIB_PATH, kPathSize - 1);
+    }
+
+    void begin() {
+        ensureLoaded_();
+    }
+
+    int length() const {
+        return kSize;
+    }
+
+    uint8_t read(int addr) const {
+        ensureLoaded_();
+        if(addr < 0 || addr >= kSize) return 0;
+        return mem_[addr];
+    }
+
+    void write(int addr, uint8_t value) {
+        ensureLoaded_();
+        if(addr < 0 || addr >= kSize) return;
+        mem_[addr] = value;
+        dirty_ = true;
+    }
+
+    void update(int addr, uint8_t value) {
+        ensureLoaded_();
+        if(addr < 0 || addr >= kSize) return;
+        if(mem_[addr] != value) {
+            mem_[addr] = value;
+            dirty_ = true;
+        }
+    }
+
+    template <typename T>
+    T& get(int addr, T& out) const {
+        ensureLoaded_();
+        if(addr < 0 || addr + (int)sizeof(T) > kSize) return out;
+        memcpy(&out, mem_ + addr, sizeof(T));
+        return out;
+    }
+
+    template <typename T>
+    const T& put(int addr, const T& in) {
+        ensureLoaded_();
+        if(addr < 0 || addr + (int)sizeof(T) > kSize) return in;
+
+        bool changed = false;
+        const uint8_t* src = reinterpret_cast<const uint8_t*>(&in);
+        for(size_t i = 0; i < sizeof(T); i++) {
+            int a = addr + (int)i;
+            if(mem_[a] != src[i]) {
+                mem_[a] = src[i];
+                changed = true;
+            }
+        }
+        if(changed) dirty_ = true;
+        return in;
+    }
+
+    void clear(uint8_t value = 0) {
+        ensureLoaded_();
+        memset(mem_, value, kSize);
+        dirty_ = true;
+    }
+
+    bool commit() {
+        ensureLoaded_();
+        if(!dirty_) return true;
+
+        const bool ok = writeFile_();
+        if(ok) dirty_ = false;
+        return ok;
+    }
+
+    bool isDirty() const {
+        return dirty_;
+    }
+
+private:
+    bool resolvePathIfNeeded_(Storage* storage) const {
+        if(path_resolved_) return true;
+        if(!storage) return false;
+
+        FuriString* path = furi_string_alloc_set_str(file_path_);
+        if(!path) return false;
+
+        storage_common_resolve_path_and_ensure_app_directory(storage, path);
+        const char* resolved = furi_string_get_cstr(path);
+
+        bool ok = false;
+        if(resolved && resolved[0]) {
+            const size_t len = strlen(resolved);
+            if(len < kPathSize) {
+                memcpy(file_path_, resolved, len + 1);
+                path_resolved_ = true;
+                ok = true;
+            }
+        }
+
+        furi_string_free(path);
+        return ok;
+    }
+
+    static void ensureDefaultDir_(Storage* storage) {
+        if(!storage) return;
+        (void)storage_common_mkdir(storage, STORAGE_APP_DATA_PATH_PREFIX);
+    }
+
+    void ensureLoaded_() const {
+        if(loaded_) return;
+
+        Storage* storage = (Storage*)furi_record_open(RECORD_STORAGE);
+        if(!storage) {
+            return;
+        }
+
+        (void)resolvePathIfNeeded_(storage);
+        ensureDefaultDir_(storage);
+
+        File* file = storage_file_alloc(storage);
+        if(!file) {
+            furi_record_close(RECORD_STORAGE);
+            return;
+        }
+
+        memset(mem_, 0x00, kSize);
+        bool ok = storage_file_open(file, file_path_, FSAM_READ_WRITE, FSOM_OPEN_ALWAYS);
+        if(ok) {
+            const uint64_t file_size = storage_file_size(file);
+            bool need_rewrite = false;
+
+            (void)storage_file_seek(file, 0, true);
+            const size_t rd = storage_file_read(file, mem_, kSize);
+            if(rd < (size_t)kSize) {
+                need_rewrite = true;
+            }
+
+            if(file_size != (uint64_t)kSize) {
+                need_rewrite = true;
+            }
+
+            if(need_rewrite) {
+                (void)storage_file_seek(file, 0, true);
+                const size_t wr = storage_file_write(file, mem_, kSize);
+                if(wr == (size_t)kSize) {
+                    (void)storage_file_truncate(file);
+                    (void)storage_file_sync(file);
+                }
+            }
+            (void)storage_file_close(file);
+        } else {
+            (void)storage_file_close(file);
+        }
+
+        storage_file_free(file);
+        furi_record_close(RECORD_STORAGE);
+
+        loaded_ = true;
+        dirty_ = false;
+    }
+
+    bool writeFile_() const {
+        Storage* storage = (Storage*)furi_record_open(RECORD_STORAGE);
+        if(!storage) return false;
+
+        if(!path_resolved_ && !resolvePathIfNeeded_(storage)) {
+            furi_record_close(RECORD_STORAGE);
+            return false;
+        }
+
+        ensureDefaultDir_(storage);
+
+        File* file = storage_file_alloc(storage);
+        if(!file) {
+            furi_record_close(RECORD_STORAGE);
+            return false;
+        }
+
+        bool ok = storage_file_open(file, file_path_, FSAM_READ_WRITE, FSOM_OPEN_ALWAYS);
+        bool success = false;
+
+        if(ok) {
+            (void)storage_file_seek(file, 0, true);
+            size_t wr = storage_file_write(file, mem_, kSize);
+            (void)storage_file_truncate(file);
+            (void)storage_file_sync(file);
+            (void)storage_file_close(file);
+            success = (wr == (size_t)kSize);
+        } else {
+            (void)storage_file_close(file);
+        }
+
+        storage_file_free(file);
+        furi_record_close(RECORD_STORAGE);
+        return success;
+    }
+
+private:
+    mutable uint8_t mem_[kSize];
+    mutable bool loaded_;
+    mutable bool dirty_;
+    mutable bool path_resolved_;
+
+    mutable char file_path_[kPathSize];
+};
+
+#if (__cplusplus >= 201703L)
+inline EEPROMClass EEPROM;
+#else
+extern EEPROMClass EEPROM;
+#ifdef EEPROM_DEFINE_INSTANCE
+EEPROMClass EEPROM;
+#endif
+#endif

applications/system/FlipperDoom/lib/flipper.h

@@ -0,0 +1,36 @@
+//lib/flipper.h
+#pragma once
+
+#include <furi.h>
+#include <gui/gui.h>
+#include <input/input.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+#define DISPLAY_WIDTH  128
+#define DISPLAY_HEIGHT 64
+#define BUFFER_SIZE    (DISPLAY_WIDTH * DISPLAY_HEIGHT / 8)
+
+typedef struct {
+    uint8_t back_buffer[BUFFER_SIZE];
+    uint8_t front_buffer[BUFFER_SIZE];
+
+    Gui* gui;
+    Canvas* canvas;
+    FuriMutex* fb_mutex;
+
+    volatile uint8_t input_state;
+    volatile bool exit_requested;
+    volatile bool audio_enabled;
+
+    // back-hold логика
+    bool back_hold_active;
+    uint16_t back_hold_start;
+    bool back_hold_handled;
+
+    // input pubsub
+    FuriPubSub* input_events;
+    FuriPubSubSubscription* input_sub;
+} FlipperState;
+
+extern FlipperState* g_state;

applications/system/FlipperDoom/main.cpp

@@ -0,0 +1,261 @@
+#include <furi.h>
+#include <furi_hal.h>
+#include <gui/gui.h>
+#include <input/input.h>
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "lib/flipper.h"
+#include "lib/EEPROM.h"
+#include "game/Game.h"
+#include "game/Platform.h"
+
+#define TARGET_FRAMERATE 30
+#define HOLD_TIME_MS     300
+
+FlipperState* g_state = NULL;
+
+static volatile uint32_t s_input_cb_inflight = 0;
+static volatile uint32_t s_fb_cb_inflight = 0;
+static volatile uint8_t s_back_pressed = 0;
+
+static inline void wait_inflight_zero(volatile uint32_t* counter) {
+    while(__atomic_load_n(counter, __ATOMIC_ACQUIRE) != 0) {
+        furi_delay_ms(1);
+    }
+}
+
+inline bool audio_enable(){
+    return !furi_hal_rtc_is_flag_set(FuriHalRtcFlagStealthMode);
+}
+
+static void framebuffer_commit_callback(
+    uint8_t* data,
+    size_t size,
+    CanvasOrientation orientation,
+    void* context) {
+    __atomic_fetch_add(&s_fb_cb_inflight, 1, __ATOMIC_RELAXED);
+
+    FlipperState* state = (FlipperState*)context;
+    if(!state || !data || size < BUFFER_SIZE) {
+        __atomic_fetch_sub(&s_fb_cb_inflight, 1, __ATOMIC_RELAXED);
+        return;
+    }
+    (void)orientation;
+
+    if(furi_mutex_acquire(state->fb_mutex, 0) != FuriStatusOk) {
+        __atomic_fetch_sub(&s_fb_cb_inflight, 1, __ATOMIC_RELAXED);
+        return;
+    }
+
+    const uint8_t* src = state->front_buffer;
+    for(size_t i = 0; i < BUFFER_SIZE; i++) {
+        data[i] = (uint8_t)(src[i] ^ 0xFF);
+    }
+
+    furi_mutex_release(state->fb_mutex);
+
+    __atomic_fetch_sub(&s_fb_cb_inflight, 1, __ATOMIC_RELAXED);
+}
+
+static void input_events_callback(const void* value, void* ctx) {
+    if(!value || !ctx) return;
+
+    __atomic_fetch_add(&s_input_cb_inflight, 1, __ATOMIC_RELAXED);
+
+    FlipperState* state = (FlipperState*)ctx;
+    const InputEvent* event = (const InputEvent*)value;
+
+    uint8_t bit = 0;
+    switch(event->key) {
+    case InputKeyUp:
+        bit = INPUT_UP;
+        break;
+    case InputKeyDown:
+        bit = INPUT_DOWN;
+        break;
+    case InputKeyLeft:
+        bit = INPUT_LEFT;
+        break;
+    case InputKeyRight:
+        bit = INPUT_RIGHT;
+        break;
+    case InputKeyOk:
+        bit = INPUT_B;
+        break;
+    case InputKeyBack:
+        if((event->type == InputTypePress) || (event->type == InputTypeRepeat)) {
+            (void)__atomic_store_n(&s_back_pressed, 1, __ATOMIC_RELAXED);
+        } else if(event->type == InputTypeRelease) {
+            (void)__atomic_store_n(&s_back_pressed, 0, __ATOMIC_RELAXED);
+        }
+        break;
+    default:
+        break;
+    }
+
+    if(state && bit) {
+        if((event->type == InputTypePress) || (event->type == InputTypeRepeat)) {
+            (void)__atomic_fetch_or((uint8_t*)&state->input_state, bit, __ATOMIC_RELAXED);
+        } else if(event->type == InputTypeRelease) {
+            (void)__atomic_fetch_and(
+                (uint8_t*)&state->input_state, (uint8_t)~bit, __ATOMIC_RELAXED);
+        }
+    }
+
+    __atomic_fetch_sub(&s_input_cb_inflight, 1, __ATOMIC_RELAXED);
+}
+
+extern "C" int32_t flipdoom_app(void* p) {
+    UNUSED(p);
+
+    Gui* gui = NULL;
+    Canvas* canvas = NULL;
+    FuriPubSub* input_events = NULL;
+    FuriPubSubSubscription* input_sub = NULL;
+
+    FlipperState* st = (FlipperState*)malloc(sizeof(FlipperState));
+    if(!st) return -1;
+    memset(st, 0, sizeof(FlipperState));
+    g_state = st;
+
+    do {
+        st->fb_mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+        if(!st->fb_mutex) break;
+
+        memset(st->back_buffer, 0x00, BUFFER_SIZE);
+        memset(st->front_buffer, 0x00, BUFFER_SIZE);
+
+        EEPROM.begin();
+        furi_delay_ms(50);
+        Platform::SetAudioEnabled(audio_enable());
+        Game::menu.ReadSave();
+
+        gui = (Gui*)furi_record_open(RECORD_GUI);
+        if(!gui) break;
+        st->gui = gui;
+
+        gui_add_framebuffer_callback(gui, framebuffer_commit_callback, st);
+
+        canvas = gui_direct_draw_acquire(gui);
+        if(!canvas) break;
+        st->canvas = canvas;
+
+        input_events = (FuriPubSub*)furi_record_open(RECORD_INPUT_EVENTS);
+        if(!input_events) break;
+        st->input_events = input_events;
+
+        input_sub = furi_pubsub_subscribe(input_events, input_events_callback, st);
+        if(!input_sub) break;
+        st->input_sub = input_sub;
+
+        const uint32_t tick_hz = furi_kernel_get_tick_frequency();
+        uint32_t period_ticks = (tick_hz + (TARGET_FRAMERATE / 2)) / TARGET_FRAMERATE;
+        if(period_ticks == 0) period_ticks = 1;
+        const uint32_t hold_ticks = (uint32_t)((HOLD_TIME_MS * tick_hz + 999u) / 1000u);
+
+        uint32_t next_tick = furi_get_tick();
+
+        bool back_was_pressed = false;
+        bool back_hold_fired = false;
+        uint32_t back_press_tick = 0;
+
+        while(!st->exit_requested) {
+            uint32_t now = furi_get_tick();
+
+            // frame pacing
+            if((int32_t)(now - next_tick) < 0) {
+                uint32_t dt_ticks = next_tick - now;
+                uint32_t dt_ms = (dt_ticks * 1000u) / tick_hz;
+                furi_delay_ms(dt_ms ? dt_ms : 1);
+                continue;
+            }
+
+            if((int32_t)(now - next_tick) > (int32_t)(period_ticks * 2)) {
+                next_tick = now;
+            }
+            next_tick += period_ticks;
+
+            const bool back_pressed = (__atomic_load_n(&s_back_pressed, __ATOMIC_RELAXED) != 0);
+
+            // BACK hold logic
+            if(!back_pressed) {
+                back_was_pressed = false;
+                back_hold_fired = false;
+            } else {
+                if(!back_was_pressed) {
+                    back_was_pressed = true;
+                    back_press_tick = now;
+                    back_hold_fired = false;
+                }
+
+                if(!back_hold_fired && ((uint32_t)(now - back_press_tick) >= hold_ticks)) {
+                    back_hold_fired = true;
+                    if(Game::InMenu())
+                        st->exit_requested = true;
+                    else
+                        Game::GoToMenu();
+                }
+            }
+
+            if(st->exit_requested) break;
+
+            Game::Tick();
+            Game::Draw();
+
+            // swap for framebuffer callback
+            furi_mutex_acquire(st->fb_mutex, FuriWaitForever);
+            memcpy(st->front_buffer, st->back_buffer, BUFFER_SIZE);
+            furi_mutex_release(st->fb_mutex);
+
+            canvas_commit(canvas);
+        }
+    } while(false);
+
+    Game::menu.WriteSave();
+
+    if(input_sub && input_events) {
+        furi_pubsub_unsubscribe(input_events, input_sub);
+        input_sub = NULL;
+    }
+    st->input_sub = NULL;
+
+    wait_inflight_zero(&s_input_cb_inflight);
+    (void)__atomic_store_n(&s_back_pressed, 0, __ATOMIC_RELAXED);
+
+    if(input_events) {
+        furi_record_close(RECORD_INPUT_EVENTS);
+        input_events = NULL;
+    }
+    st->input_events = NULL;
+
+    if(gui) {
+        gui_remove_framebuffer_callback(gui, framebuffer_commit_callback, st);
+    }
+
+    wait_inflight_zero(&s_fb_cb_inflight);
+
+    if(gui) {
+        if(canvas) {
+            gui_direct_draw_release(gui);
+            canvas = NULL;
+        }
+        furi_record_close(RECORD_GUI);
+        gui = NULL;
+    }
+    st->gui = NULL;
+    st->canvas = NULL;
+
+    if(st->fb_mutex) {
+        furi_mutex_free(st->fb_mutex);
+        st->fb_mutex = NULL;
+    }
+
+    Platform::SetAudioEnabled(false);
+
+    free(st);
+    g_state = NULL;
+
+    return 0;
+}

applications/system/FlipperDoom/tools/extract_doom_assets.py

@@ -0,0 +1,521 @@
+#!/usr/bin/env python3
+"""
+extract_doom_assets.py
+
+Reads the user's own Doom shareware IWAD (Doom1.WAAD is freely distributable
+as a whole) and converts a selection of its sprites into 1-bit assets in the
+FlipperCatacombs engine formats. Nothing from the WAD is stored in this
+repository: the header is generated locally at build time from the WAD the
+user already has.
+
+Usage:
+    python3 tools/extract_doom_assets.py <path/to/Doom1.WAD> [output_header]
+
+Output (default): game/Generated/DoomSprites.inc.h
+
+Engine formats
+--------------
+1) Scaled sprite (16x16), uint16_t array, per frame:
+   16 columns x 2 words: [transparency mask, colour], bit v = row v (bit0=top)
+2) Page sprite (Platform::DrawSprite): uint8_t array:
+   w, h, then per page (8 rows), per column: [colour byte, mask byte]
+   (bit0 = top row of the page)
+3) Solid bitmap (Platform::DrawSolidBitmap): uint8_t array:
+   w, h, then per page, per column: colour byte where bit=1 means BLACK
+   (DrawSolidBitmap writes fill = ~src)
+4) HUD icon: 8 raw page bytes (bit=1 -> white pixel)
+"""
+
+import struct
+import sys
+import os
+
+# ---------------------------------------------------------------- WAD parsing
+
+
+class Wad:
+    def __init__(self, path):
+        self.data = open(path, "rb").read()
+        ident, numlumps, diroff = struct.unpack_from("<4sII", self.data, 0)
+        if ident not in (b"IWAD", b"PWAD"):
+            raise ValueError("Not a WAD file")
+        self.lumps = {}
+        for i in range(numlumps):
+            off, size, name = struct.unpack_from("<II8s", self.data, diroff + 16 * i)
+            name = name.rstrip(b"\0").decode("ascii", "replace")
+            # keep first occurrence (IWAD order)
+            if name not in self.lumps:
+                self.lumps[name] = (off, size)
+
+    def lump(self, name):
+        off, size = self.lumps[name]
+        return self.data[off : off + size]
+
+    def has(self, name):
+        return name in self.lumps
+
+
+def load_palette(wad):
+    pal = wad.lump("PLAYPAL")[:768]
+    grays = []
+    for i in range(256):
+        r, g, b = pal[i * 3], pal[i * 3 + 1], pal[i * 3 + 2]
+        grays.append(0.299 * r + 0.587 * g + 0.114 * b)
+    return grays
+
+
+def decode_picture(wad, name, grays):
+    """Decode Doom picture format -> (w, h, pixels) where pixels is a list of
+    rows; each entry is None (transparent) or gray 0..255."""
+    raw = wad.lump(name)
+    w, h, _lo, _to = struct.unpack_from("<hhhh", raw, 0)
+    colofs = struct.unpack_from("<%di" % w, raw, 8)
+    pix = [[None] * w for _ in range(h)]
+    for x in range(w):
+        p = colofs[x]
+        while raw[p] != 0xFF:
+            topdelta = raw[p]
+            length = raw[p + 1]
+            p += 3  # topdelta, length, pad
+            for i in range(length):
+                y = topdelta + i
+                if 0 <= y < h:
+                    pix[y][x] = grays[raw[p]]
+                p += 1
+            p += 1  # trailing pad
+    return w, h, pix
+
+
+# ------------------------------------------------------------- image helpers
+
+BAYER4 = [
+    [0, 8, 2, 10],
+    [12, 4, 14, 6],
+    [3, 11, 1, 9],
+    [15, 7, 13, 5],
+]
+
+
+def bbox(pix):
+    xs, ys = [], []
+    for y, row in enumerate(pix):
+        for x, v in enumerate(row):
+            if v is not None:
+                xs.append(x)
+                ys.append(y)
+    return min(xs), min(ys), max(xs) + 1, max(ys) + 1
+
+
+def crop(pix, x0, y0, x1, y1):
+    return [row[x0:x1] for row in pix[y0:y1]]
+
+
+def box_resize(pix, nw, nh):
+    """Box-filter resize of (gray|None) grid; alpha = coverage."""
+    h = len(pix)
+    w = len(pix[0])
+    out_gray = [[0.0] * nw for _ in range(nh)]
+    out_alpha = [[0.0] * nw for _ in range(nh)]
+    for ny in range(nh):
+        sy0 = ny * h / nh
+        sy1 = (ny + 1) * h / nh
+        for nx in range(nw):
+            sx0 = nx * w / nw
+            sx1 = (nx + 1) * w / nw
+            acc_g = acc_a = acc_w = 0.0
+            y = int(sy0)
+            while y < sy1 and y < h:
+                wy = min(sy1, y + 1) - max(sy0, y)
+                x = int(sx0)
+                while x < sx1 and x < w:
+                    wx = min(sx1, x + 1) - max(sx0, x)
+                    weight = wx * wy
+                    acc_w += weight
+                    v = pix[y][x]
+                    if v is not None:
+                        acc_a += weight
+                        acc_g += weight * v
+                    x += 1
+                y += 1
+            if acc_w > 0 and acc_a > 0:
+                out_gray[ny][nx] = acc_g / acc_a
+                out_alpha[ny][nx] = acc_a / acc_w
+    return out_gray, out_alpha
+
+
+def normalize(gray, alpha, thresh=0.5):
+    """Per-sprite contrast stretch over opaque pixels."""
+    vals = [
+        gray[y][x]
+        for y in range(len(gray))
+        for x in range(len(gray[0]))
+        if alpha[y][x] >= thresh
+    ]
+    if not vals:
+        return gray
+    lo, hi = min(vals), max(vals)
+    if hi - lo < 1e-6:
+        hi = lo + 1.0
+    return [
+        [(v - lo) * 255.0 / (hi - lo) for v in row]
+        for row in gray
+    ]
+
+
+def to_1bit(gray, alpha, bias=0.0):
+    """3-tone quantization (black / 50% checker / white) for clean tiny
+    sprites. Returns (colour, mask) row-major bools."""
+    h, w = len(gray), len(gray[0])
+    colour = [[False] * w for _ in range(h)]
+    mask = [[False] * w for _ in range(h)]
+    for y in range(h):
+        for x in range(w):
+            if alpha[y][x] >= 0.5:
+                mask[y][x] = True
+                v = gray[y][x] + bias
+                if v < 80:
+                    colour[y][x] = False
+                elif v < 175:
+                    colour[y][x] = ((x + y) & 1) == 0
+                else:
+                    colour[y][x] = True
+    return colour, mask
+
+
+def fit_grid(pix, size, valign, hpad=0):
+    """Crop to bbox, keep aspect, fit into size x size grid.
+    valign: 'bottom' or 'center'."""
+    x0, y0, x1, y1 = bbox(pix)
+    pix = crop(pix, x0, y0, x1, y1)
+    w = x1 - x0
+    h = y1 - y0
+    avail = size - hpad * 2
+    if w >= h:
+        nw = avail
+        nh = max(1, round(h * avail / w))
+    else:
+        nh = avail
+        nw = max(1, round(w * avail / h))
+    gray, alpha = box_resize(pix, nw, nh)
+    # paste into size x size
+    g = [[0.0] * size for _ in range(size)]
+    a = [[0.0] * size for _ in range(size)]
+    ox = (size - nw) // 2
+    oy = (size - nh) if valign == "bottom" else (size - nh) // 2
+    for y in range(nh):
+        for x in range(nw):
+            g[oy + y][ox + x] = gray[y][x]
+            a[oy + y][ox + x] = alpha[y][x]
+    return g, a
+
+
+# ------------------------------------------------------------ format emitters
+
+
+def emit_scaled16(frames):
+    """frames: list of (colour, mask) 16x16 row-major -> list of uint16 words."""
+    words = []
+    for colour, mask in frames:
+        for x in range(16):
+            t = c = 0
+            for y in range(16):
+                if mask[y][x]:
+                    t |= 1 << y
+                    if colour[y][x]:
+                        c |= 1 << y
+            words.append(t)
+            words.append(c)
+    return words
+
+
+def emit_page_sprite(colour, mask):
+    """-> list of bytes: w, h, then per page per column [colour, mask]."""
+    h, w = len(colour), len(colour[0])
+    pages = (h + 7) // 8
+    out = [w, h]
+    for page in range(pages):
+        for x in range(w):
+            cb = mb = 0
+            for bit in range(8):
+                y = page * 8 + bit
+                if y < h and mask[y][x]:
+                    mb |= 1 << bit
+                    if colour[y][x]:
+                        cb |= 1 << bit
+            out.append(cb)
+            out.append(mb)
+    return out
+
+
+def emit_solid_bitmap(colour):
+    """DrawSolidBitmap: bit=1 -> black. colour True = white pixel."""
+    h, w = len(colour), len(colour[0])
+    pages = (h + 7) // 8
+    out = [w, h]
+    for page in range(pages):
+        for x in range(w):
+            b = 0
+            for bit in range(8):
+                y = page * 8 + bit
+                if y < h and not colour[y][x]:
+                    b |= 1 << bit
+            out.append(b)
+    return out
+
+
+def fmt_words(words, per_line=16):
+    lines = []
+    for i in range(0, len(words), per_line):
+        lines.append(",".join("0x%x" % v for v in words[i : i + per_line]))
+    return ",\n\t".join(lines)
+
+
+# ------------------------------------------------------------------ pipeline
+
+
+def sprite16(wad, grays, names, valign, bias=0.0):
+    frames = []
+    for n in names:
+        w, h, pix = decode_picture(wad, n, grays)
+        g, a = fit_grid(pix, 16, valign)
+        g = normalize(g, a)
+        frames.append(to_1bit(g, a, bias))
+    return emit_scaled16(frames)
+
+
+def first_present(wad, *names):
+    for n in names:
+        if wad.has(n):
+            return n
+    raise KeyError("none of %s in WAD" % (names,))
+
+
+def build_weapon(wad, grays, target_w=46):
+    """Idle shotgun + firing frame (shotgun with muzzle flash composited)."""
+    w, h, gun = decode_picture(wad, "SHTGA0", grays)
+    x0, y0, x1, y1 = bbox(gun)
+    gun = crop(gun, x0, y0, x1, y1)
+    gw, gh = x1 - x0, y1 - y0
+    nw = target_w
+    nh = max(1, round(gh * nw / gw))
+    g, a = box_resize(gun, nw, nh)
+    g = normalize(g, a)
+    # limit height so it doesn't cover too much of the 64px screen: keep the
+    # top rows (barrel); the grip sticks out of the screen bottom like in Doom
+    max_h = 28
+    if nh > max_h:
+        g = g[:max_h]
+        a = a[:max_h]
+        nh = max_h
+    idle = to_1bit(g, a)
+
+    # firing frame: muzzle flash above the barrel
+    fname = first_present(wad, "SHTFB0", "SHTFA0")
+    fw, fh, fl = decode_picture(wad, fname, grays)
+    fx0, fy0, fx1, fy1 = bbox(fl)
+    fl = crop(fl, fx0, fy0, fx1, fy1)
+    fsw = max(1, round((fx1 - fx0) * nw / gw))
+    fsh = max(1, round((fy1 - fy0) * nw / gw))
+    fg, fa = box_resize(fl, fsw, fsh)
+    fg = normalize(fg, fa)
+    # keep total height reasonable: crop the top of the flash if needed
+    max_total = 38
+    if nh + fsh > max_total:
+        cut = nh + fsh - max_total
+        fg = fg[cut:]
+        fa = fa[cut:]
+        fsh -= cut
+
+    # find barrel top-center of scaled gun: centroid of top opaque row
+    top_row = 0
+    for y in range(nh):
+        if any(a[y][x] >= 0.5 for x in range(nw)):
+            top_row = y
+            break
+    cols = [x for x in range(nw) if a[top_row][x] >= 0.5]
+    cx = sum(cols) // len(cols) if cols else nw // 2
+
+    fire_h = nh + fsh
+    FG = [[0.0] * nw for _ in range(fire_h)]
+    FA = [[0.0] * nw for _ in range(fire_h)]
+    for y in range(nh):
+        for x in range(nw):
+            FG[fsh + y][x] = g[y][x]
+            FA[fsh + y][x] = a[y][x]
+    ox = cx - fsw // 2
+    for y in range(fsh):
+        for x in range(fsw):
+            dx = ox + x
+            if 0 <= dx < nw and fa[y][x] >= 0.5:
+                FG[y][dx] = fg[y][x]
+                FA[y][dx] = fa[y][x]
+    fire = to_1bit(FG, FA, bias=40.0)  # flash reads brighter
+
+    return emit_page_sprite(*idle), emit_page_sprite(*fire)
+
+
+TITLE_LETTERS = {
+    "D": [
+        "######.",
+        "##..##.",
+        "##..###",
+        "##...##",
+        "##...##",
+        "##..###",
+        "##..##.",
+        "######.",
+    ],
+    "O": [
+        ".#####.",
+        "##...##",
+        "##...##",
+        "##...##",
+        "##...##",
+        "##...##",
+        "##...##",
+        ".#####.",
+    ],
+    "M": [
+        "##...##",
+        "###.###",
+        "#######",
+        "##.#.##",
+        "##...##",
+        "##...##",
+        "##...##",
+        "##...##",
+    ],
+}
+
+
+def build_title(wad, grays):
+    """Original blocky 'DOOM' pixel title with dithered gradient, 128x64."""
+    W, H = 128, 64
+    colour = [[False] * W for _ in range(H)]
+    scale = 4  # each letter 7x8 -> 28x32
+    lw, lh = 7 * scale, 8 * scale
+    gap = 4
+    total = 4 * lw + 3 * gap
+    x0 = (W - total) // 2
+    y0 = (H - lh) // 2
+    for i, ch in enumerate("DOOM"):
+        gl = TITLE_LETTERS[ch]
+        ox = x0 + i * (lw + gap)
+        for gy in range(8):
+            for gx in range(7):
+                if gl[gy][gx] != "#":
+                    continue
+                for sy in range(scale):
+                    for sx in range(scale):
+                        x = ox + gx * scale + sx
+                        y = y0 + gy * scale + sy
+                        # metallic gradient: solid on top, dithered below
+                        if y - y0 < lh * 5 // 8:
+                            colour[y][x] = True
+                        else:
+                            colour[y][x] = ((x + y) & 1) == 0
+    return emit_solid_bitmap(colour)
+
+
+def icon_from_pixmap(rows):
+    """8x8 pixmap ('#'=white) -> 8 page bytes, bit0 = top row."""
+    out = []
+    for x in range(8):
+        b = 0
+        for y in range(8):
+            if rows[y][x] == "#":
+                b |= 1 << y
+        out.append(b)
+    return out
+
+
+HEALTH_ICON = [
+    "..###...",
+    "..#.#...",
+    "###.###.",
+    "#.....#.",
+    "###.###.",
+    "..#.#...",
+    "..###...",
+    "........",
+]
+
+AMMO_ICON = [
+    ".#..#...",
+    "###.###.",
+    "###.###.",
+    "###.###.",
+    "###.###.",
+    "###.###.",
+    "###.###.",
+    "........",
+]
+
+
+def main():
+    wad_path = sys.argv[1] if len(sys.argv) > 1 else "../doomgeneric/Doom1.WAD"
+    root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    out_path = (
+        sys.argv[2]
+        if len(sys.argv) > 2
+        else os.path.join(root, "game", "Generated", "DoomSprites.inc.h")
+    )
+
+    wad = Wad(wad_path)
+    grays = load_palette(wad)
+
+    scaled = []  # (symbol, numFrames, words)
+
+    def add16(symbol, names, valign, bias=0.0):
+        scaled.append((symbol, len(names), sprite16(wad, grays, names, valign, bias)))
+
+    # enemies (2 walk frames each)
+    add16("skeletonSpriteData", ["SARGA1", "SARGB1"], "bottom")  # pinky demon
+    add16("mageSpriteData", ["TROOA1", "TROOB1"], "bottom")      # imp
+    add16("batSpriteData", ["SPOSA1", "SPOSB1"], "bottom")       # shotgun sergeant
+    add16("spiderSpriteData", ["POSSA1", "POSSB1"], "bottom")    # zombieman
+
+    # projectiles
+    ball = first_present(wad, "BAL1A0")
+    ball2 = first_present(wad, "BAL1B0", "BAL1A0")
+    add16("projectileSpriteData", [ball], "center", bias=60.0)
+    add16("enemyProjectileSpriteData", [ball2], "center", bias=60.0)
+
+    # decorations / pickups
+    torch1 = first_present(wad, "TREDA0", "CANDA0")
+    torch2 = first_present(wad, "TREDC0", "TREDB0", "CANDA0")
+    add16("torchSpriteData1", [torch1], "center", bias=40.0)
+    add16("torchSpriteData2", [torch2], "center", bias=40.0)
+    add16("urnSpriteData", ["BAR1A0"], "bottom")                 # barrel
+    add16("potionSpriteData", ["STIMA0"], "bottom", bias=30.0)   # stimpack
+    add16("chestSpriteData", ["BPAKA0"], "bottom", bias=30.0)    # backpack
+    add16("chestOpenSpriteData", ["CLIPA0"], "bottom", bias=30.0)
+    add16("scrollSpriteData", ["BON2A0"], "bottom", bias=30.0)   # armor helmet
+    add16("coinsSpriteData", ["BON1A0"], "bottom", bias=30.0)    # potion bottle
+    add16("crownSpriteData", ["ARM1A0"], "bottom", bias=30.0)    # green armor
+    add16("signSpriteData", ["POL5A0"], "bottom", bias=20.0)     # skull pile
+
+    weapon_idle, weapon_fire = build_weapon(wad, grays)
+    title = build_title(wad, grays)
+    health = icon_from_pixmap(HEALTH_ICON)
+    ammo = icon_from_pixmap(AMMO_ICON)
+
+    with open(out_path, "w") as f:
+        f.write("// Auto-generated by tools/extract_doom_assets.py\n")
+        f.write("// Derived at build time from the user's local Doom shareware WAD.\n")
+        f.write("// Do not commit WAD-derived data to public repositories.\n\n")
+        for symbol, nframes, words in scaled:
+            f.write("constexpr uint8_t %s_numFrames = %d;\n" % (symbol, nframes))
+            f.write("extern const uint16_t %s[] PROGMEM =\n{\n\t%s\n};\n" % (symbol, fmt_words(words)))
+        f.write("extern const uint8_t handSpriteData1[] PROGMEM =\n{\n\t%s\n};\n" % fmt_words(weapon_idle, 24))
+        f.write("extern const uint8_t handSpriteData2[] PROGMEM =\n{\n\t%s\n};\n" % fmt_words(weapon_fire, 24))
+        f.write("extern const uint8_t titleBitmapData[] PROGMEM =\n{\n\t%s\n};\n" % fmt_words(title, 24))
+        f.write("extern const uint8_t heartSpriteData[] PROGMEM =\n{\n%s\n};\n" % fmt_words(health))
+        f.write("extern const uint8_t manaSpriteData[] PROGMEM =\n{\n%s\n};\n" % fmt_words(ammo))
+
+    total = sum(len(w) * 2 for _, _, w in scaled) + len(weapon_idle) + len(weapon_fire) + len(title) + 16
+    print("Wrote %s (%d bytes of asset data)" % (out_path, total))
+
+
+if __name__ == "__main__":
+    main()

applications/system/FlipperGB/README.md

@@ -0,0 +1,202 @@
+# FlipGB — Game Boy Emulator for Flipper Zero
+
+A Game Boy (DMG) emulator for the Flipper Zero, based on the
+[jgilchrist/gbemu](https://github.com/jgilchrist/gbemu) core, heavily adapted
+for microcontrollers. Loads `.gb` ROMs from the SD card, streams ROM banks,
+supports battery saves and adaptive frameskip.
+
+---
+
+## Quick Start
+
+1. Copy `dist/flipgb.fap` to your SD card under `SD/apps/Games/`
+   (or run `ufbt launch` with the Flipper connected via USB).
+2. Copy your `.gb` ROM files anywhere on the SD card (e.g. `SD/gb_roms/`).
+3. On the Flipper: **Apps → Games → FlipGB**.
+4. Pick a ROM with the file browser. The game starts immediately.
+5. To open the emulator menu at any time: **press Up + Down together**.
+
+> Only use ROMs you legally own or free homebrew (e.g. µCity, Tobu Tobu Girl).
+
+---
+
+## Controls
+
+### In game
+
+| Flipper button | Game Boy button |
+|---|---|
+| **Up / Down / Left / Right** | D-pad |
+| **OK (center)** | **A** |
+| **Back** | **B** |
+| **Up + Down pressed together** | Open the emulator menu |
+
+There is no direct Start/Select button on the Flipper — they are sent from
+the emulator menu (see below).
+
+**Why Up+Down for the menu?** A real Game Boy d-pad physically cannot press
+opposite directions at the same time, so no game ever reads that combination
+— it can never conflict with gameplay. (A long-press on Back was rejected
+because Back is B, and many games hold B continuously — e.g. running in
+platformers — which would keep popping the menu open.)
+
+### Emulator menu (Up + Down)
+
+Navigate with **Up/Down**, activate with **OK**, close with **Back**.
+
+| Item | What it does |
+|---|---|
+| **Continue** | Close the menu and resume the game |
+| **Press START** | Sends a Start press to the game (pause menus, "PRESS START" screens) and resumes |
+| **Press SELECT** | Sends a Select press to the game and resumes |
+| **Frameskip** | Change with **Left/Right**: `auto` (recommended), or fixed `0–4`. `auto` shows the skip level currently in use |
+| **Sound** | Toggle piezo sound on/off (`n/a` if the speaker is in use by another app) |
+| **Save SRAM** | Writes the cartridge battery save (`.sav`) to the SD card immediately |
+| **Exit** | Saves SRAM (if the cartridge has a battery) and quits the app |
+
+The game is paused while the menu is open; all buttons are released for the
+game so nothing stays "stuck".
+
+---
+
+## Saves
+
+- Games with battery-backed cartridge RAM (Zelda, Pokémon, etc.) are saved to
+  a file **next to the ROM**: `MyGame.gb` → `MyGame.gb.sav`.
+- Saving happens **automatically on Exit**, and manually via **Save SRAM** in
+  the menu (recommended before pulling the battery/USB, since a hard power
+  loss cannot auto-save).
+- Save states are **not** supported — only real in-game saving, like original
+  hardware.
+
+---
+
+## Display
+
+The Game Boy screen (160×144, 4 shades of gray) is downscaled to the
+Flipper's 128×64 1-bit LCD:
+
+- Full screen is always visible (no cropping), slightly squashed vertically.
+- The 4 shades become ordered-dither patterns: white → lit, light gray → 3/4
+  lit, dark gray → 1/4 lit, black → off.
+
+## Sound
+
+The Flipper's speaker is a single-tone piezo — it plays exactly one
+frequency at one volume at a time, so the real 4-channel Game Boy mix
+cannot be reproduced. Instead, FlipGB emulates the APU **at register level**
+(frequencies, CH1 frequency sweep, volume envelopes, length counters,
+NR52 power/status) and every frame sends the **dominant voice** to the
+piezo:
+
+1. the louder of the two pulse channels (they carry the melody in almost
+   every GB soundtrack); the most recently triggered wins ties,
+2. otherwise the wave channel (bass lines),
+3. otherwise the noise channel, mapped to a short low buzz (percussion).
+
+The result is a monophonic ringtone-style rendition of the game's music
+and sound effects (sweeps like Mario's jump work). It can be toggled in
+the emulator menu. Since no waveforms are synthesized, the CPU cost is
+negligible (one counter per emulated instruction) and RAM cost is ~120
+bytes.
+
+## Performance
+
+- The upstream core had a cycle-domain mismatch: the CPU tables count
+  machine cycles but the PPU counted them against T-cycle constants, so
+  **every frame emulated 4x the hardware-correct amount of CPU work**
+  (70224 M-cycles instead of 17556). Unnoticeable on a desktop, a slideshow
+  on a 64 MHz Cortex-M4. Fixed — this alone made everything ~4.5x faster.
+- While halted (games spend most of each frame in HALT waiting for vblank),
+  the CPU steps 4 M-cycles at a time instead of 1, making the idle part of
+  the frame cheap.
+- **Frameskip `auto`** (default) measures the real cost of each emulated frame
+  and skips *rendering* (never emulation) to keep the game running at correct
+  speed. Games stay full-speed logically; visible FPS drops instead.
+- Fixed frameskip `0–4` is available in the menu if you prefer consistency.
+- The PPU only renders the 64 scanlines (out of 144) that survive the
+  downscale to the Flipper LCD — ~55% of the per-frame rendering work is
+  skipped with zero visual difference.
+- Bank-switch heavy games may micro-stutter when a 16 KB bank has to be
+  streamed from the SD card (only happens when the ROM doesn't fit in RAM).
+- The emulator menu shows the free heap (`NNk free`) so you can see the
+  memory headroom of the current game at a glance.
+
+## Compatibility
+
+| Feature | Status |
+|---|---|
+| Mappers | ROM-only, MBC1, MBC2, MBC3 (no RTC), MBC5 |
+| Game Boy Color | Not supported. CGB-only ROMs are rejected with a message; dual-mode ROMs run in DMG mode |
+| MBC3 real-time clock | Not emulated (Pokémon Gold/Silver run without the clock) |
+| Audio | Monophonic: register-level APU + dominant voice on the piezo (see *Sound* above). No waveform mixing — the hardware physically can't play it |
+| Link cable | Not supported |
+| ROM size | Any (streamed from SD; small ROMs are fully loaded to RAM) |
+
+---
+
+## Building from source
+
+```sh
+pip install ufbt
+cd FlipperGB
+ufbt          # produces dist/flipgb.fap
+ufbt launch   # builds, installs and runs on a connected Flipper
+```
+
+### Verifying the emulator core on your PC
+
+The exact core that ships in the FAP can be compiled and tested on a desktop:
+
+```sh
+g++ -std=c++17 -O2 -fno-exceptions -fno-rtti -I gb \
+    -o hosttest/hosttest hosttest/main.cpp gb/*.cc
+
+# Blargg CPU tests (print Passed/Failed via the serial port):
+./hosttest/hosttest path/to/01-special.gb 4000
+
+# ASCII dump of a game frame:
+./hosttest/hosttest game.gb 600 --dump-frame
+
+# Trace of what the piezo would play (dominant APU voice per frame):
+./hosttest/hosttest game.gb 1500 --dump-audio
+```
+
+Current status: **Blargg `cpu_instrs` 11/11 PASS**.
+
+---
+
+## Technical notes (PC core → MCU adaptations)
+
+| Upstream (PC) | This port (Flipper) |
+|---|---|
+| Whole ROM in RAM (with several transient copies) | 16 KB bank streaming from SD with an adaptive LRU cache; bank 0 resident; when every bank fits, the whole ROM is preloaded into individual 16 KB slots (O(1) switching, SD file closed) |
+| — | All ROM-dependent allocations are 16 KB or smaller and are checked against the largest free heap block first: heap fragmentation can never crash the firmware, the app degrades to streaming or shows "Not enough RAM" instead |
+| Renders all 144 scanlines | Renders only the 64 scanlines that are actually displayed after the 144→64 downscale (row mask, ~2x faster rendering) |
+| PPU counts M-cycles against T-cycle constants (4x too much CPU emulation per frame) | Hardware-correct M-cycle constants (114 per scanline): ~4.5x faster overall |
+| DIV register incremented every M-cycle (64x too fast) | Correct 16384 Hz rate (games use DIV for delays and randomness) |
+| Framebuffer stores all 144 rows | Flipper build stores only the 64 displayed rows (2.5 KB instead of 5.7 KB) |
+| 92 KB framebuffer of 4-byte enums + unused 256 KB background map | Packed 2bpp framebuffer (5.7 KB); dead buffer removed |
+| 32 KB WRAM / 16 KB VRAM (CGB provision) | Real DMG sizes: 8 KB / 8 KB |
+| Virtual methods on every CPU register access | Devirtualized, inlined registers |
+| Heap allocation per tile per scanline in the PPU | Zero-alloc per-tile rendering |
+| `std::function` / `std::string` / `ifstream` / exceptions | Function pointers + Flipper Storage API, builds with `-fno-exceptions -fno-rtti` |
+| Nintendo boot ROM embedded | Removed; documented post-boot register state instead |
+| MBC1 partial (bugs, 512 KB max), no MBC2/MBC5 | MBC1 complete, MBC2/MBC3/MBC5 implemented |
+| No joypad interrupt | Added (wakes games waiting in HALT/STOP) |
+| No APU at all | Register-level APU (sweep/envelope/length/NR52, proper read-back masks) driving the piezo with the dominant voice |
+
+RAM budget on device (256 KB total, ~140 KB heap; the app binary itself
+loads into ~32 KB of that heap): ~19.5 KB emulation state, 16 KB bank 0,
+adaptive bank cache (10 KB heap kept in reserve for the system), 0–32 KB
+cartridge RAM per game, 4 KB stack. The bank cache is allocated greedily in
+independent 16 KB blocks until the reserve would be touched, so any `.gb`
+ROM size works: small ROMs end up fully resident, large ones stream through
+however many slots fit. Worst case (1 MB ROM + 32 KB battery RAM, e.g.
+Pokémon Red/Blue) needs ~78 KB before the first cache slot, which fits the
+post-launch heap with room for 1–2 streaming slots.
+
+## License
+
+The emulator core derives from jgilchrist/gbemu — see its upstream license.
+No Nintendo code or assets are included in this repository.

applications/system/FlipperGB/application.fam

@@ -0,0 +1,15 @@
+App(
+    appid="flipgb",
+    name="FlipGB",
+    apptype=FlipperAppType.EXTERNAL,
+    entry_point="flipgb_app",
+    sources=["*.c*", "!hosttest"],
+    requires=["gui", "dialogs", "storage"],
+    stack_size=8 * 1024,
+    cdefines=[("GB_FB_ROWS", "64")],
+    fap_category="Games",
+    fap_icon="flipgb_icon.png",
+    fap_author="user",
+    fap_version="1.0",
+    fap_description="Game Boy (DMG) emulator. Loads .gb ROMs from the SD card, streams ROM banks, battery saves, adaptive frameskip.",
+)

applications/system/FlipperGB/gb/address.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "definitions.h"
+#include "register.h"
+
+class Address {
+public:
+    Address(u16 location) : addr(location) {}
+    explicit Address(const RegisterPair& from) : addr(from.value()) {}
+    explicit Address(const WordRegister& from) : addr(from.value()) {}
+
+    auto value() const -> u16 { return addr; }
+
+    auto in_range(Address low, Address high) const -> bool {
+        return low.value() <= value() && value() <= high.value();
+    }
+
+    auto operator==(u16 other) const -> bool { return addr == other; }
+    auto operator+(uint other) const -> Address {
+        return Address(static_cast<u16>(addr + other));
+    }
+    auto operator-(uint other) const -> Address {
+        return Address(static_cast<u16>(addr - other));
+    }
+
+private:
+    u16 addr = 0x0;
+};

applications/system/FlipperGB/gb/apu.cc

@@ -0,0 +1,242 @@
+#include "apu.h"
+
+/* One frame-sequencer step every 2048 M-cycles (8192 T-cycles = 512 Hz),
+ * in the same M-cycle domain the CPU/PPU/timer now share. */
+static const uint FRAME_SEQ_PERIOD = 2048;
+
+void Apu::tick(uint cycles) {
+    if(!power) return;
+
+    seq_counter += cycles;
+    while(seq_counter >= FRAME_SEQ_PERIOD) {
+        seq_counter -= FRAME_SEQ_PERIOD;
+        seq_step = (u8)((seq_step + 1) & 7);
+
+        if((seq_step & 1) == 0) clock_lengths(); /* 256 Hz */
+        if(seq_step == 2 || seq_step == 6) clock_sweep(); /* 128 Hz */
+        if(seq_step == 7) clock_envelopes(); /* 64 Hz */
+    }
+}
+
+void Apu::clock_lengths() {
+    for(uint n = 0; n < 4; n++) {
+        Ch& c = ch[n];
+        if((c.nr4 & 0x40) && c.length > 0) {
+            c.length--;
+            if(c.length == 0) c.enabled = false;
+        }
+    }
+}
+
+void Apu::clock_envelopes() {
+    static const u8 env_channels[3] = {0, 1, 3}; /* wave has no envelope */
+    for(uint i = 0; i < 3; i++) {
+        Ch& c = ch[env_channels[i]];
+        u8 period = c.nr2 & 0x07;
+        if(!period || !c.enabled) continue;
+        if(c.env_timer > 0) c.env_timer--;
+        if(c.env_timer == 0) {
+            c.env_timer = period;
+            if(c.nr2 & 0x08) {
+                if(c.env_volume < 15) c.env_volume++;
+            } else {
+                if(c.env_volume > 0) c.env_volume--;
+            }
+        }
+    }
+}
+
+auto Apu::sweep_calc() const -> uint {
+    uint delta = sweep_shadow >> (ch[0].nr0 & 0x07);
+    return (ch[0].nr0 & 0x08) ? sweep_shadow - delta : sweep_shadow + delta;
+}
+
+void Apu::clock_sweep() {
+    Ch& c = ch[0];
+    if(!c.enabled || !sweep_enabled) return;
+
+    if(sweep_timer > 0) sweep_timer--;
+    if(sweep_timer != 0) return;
+
+    u8 period = (c.nr0 >> 4) & 0x07;
+    sweep_timer = period ? period : 8;
+    if(!period) return;
+
+    uint nf = sweep_calc();
+    if(nf > 2047) {
+        c.enabled = false;
+    } else if(c.nr0 & 0x07) {
+        sweep_shadow = nf;
+        set_ch_freq(0, nf);
+        if(sweep_calc() > 2047) c.enabled = false;
+    }
+}
+
+void Apu::trigger(uint n) {
+    Ch& c = ch[n];
+
+    c.enabled = dac_on(n);
+    if(c.length == 0) c.length = (n == 2) ? 256 : 64;
+    c.env_volume = c.nr2 >> 4;
+    u8 period = c.nr2 & 0x07;
+    c.env_timer = period ? period : 8;
+    c.order = ++trigger_counter;
+
+    if(n == 0) {
+        sweep_shadow = ch_freq(0);
+        u8 sw_period = (c.nr0 >> 4) & 0x07;
+        u8 sw_shift = c.nr0 & 0x07;
+        sweep_timer = sw_period ? sw_period : 8;
+        sweep_enabled = (sw_period != 0) || (sw_shift != 0);
+        if(sw_shift && sweep_calc() > 2047) c.enabled = false;
+    }
+}
+
+void Apu::power_off() {
+    for(uint n = 0; n < 4; n++) {
+        ch[n] = Ch(); /* wave RAM survives power-off, registers do not */
+    }
+    nr50 = 0;
+    nr51 = 0;
+    sweep_shadow = 0;
+    sweep_timer = 0;
+    sweep_enabled = false;
+    seq_counter = 0;
+    seq_step = 0;
+}
+
+void Apu::write(u16 addr, u8 value) {
+    /* wave RAM is accessible regardless of power */
+    if(addr >= 0xFF30 && addr <= 0xFF3F) {
+        wave_ram[addr - 0xFF30] = value;
+        return;
+    }
+
+    if(addr == 0xFF26) { /* NR52: only the power bit is writable */
+        bool new_power = (value & 0x80) != 0;
+        if(power && !new_power) power_off();
+        if(!power && new_power) {
+            seq_counter = 0;
+            seq_step = 0;
+        }
+        power = new_power;
+        return;
+    }
+
+    if(!power) return; /* all other registers are dead while powered off */
+
+    if(addr >= 0xFF10 && addr <= 0xFF23) {
+        uint idx = addr - 0xFF10;
+        uint n = idx / 5; /* channel */
+        Ch& c = ch[n];
+        switch(idx % 5) {
+        case 0: /* NRx0: CH1 sweep / CH3 DAC enable */
+            c.nr0 = value;
+            if(n == 2 && !dac_on(2)) c.enabled = false;
+            break;
+        case 1: /* NRx1: duty/length load */
+            c.nr1 = value;
+            c.length = (n == 2) ? 256u - value : 64u - (value & 0x3F);
+            break;
+        case 2: /* NRx2: envelope (CH3: output level) */
+            c.nr2 = value;
+            if(n != 2 && !dac_on(n)) c.enabled = false;
+            break;
+        case 3: /* NRx3: frequency low (CH4: polynomial counter) */
+            c.nr3 = value;
+            break;
+        case 4: /* NRx4: frequency high / length enable / trigger */
+            c.nr4 = value;
+            if(value & 0x80) trigger(n);
+            break;
+        }
+        return;
+    }
+
+    if(addr == 0xFF24) {
+        nr50 = value;
+        return;
+    }
+    if(addr == 0xFF25) {
+        nr51 = value;
+        return;
+    }
+    /* 0xFF27 - 0xFF2F: unmapped */
+}
+
+auto Apu::read(u16 addr) const -> u8 {
+    if(addr >= 0xFF30 && addr <= 0xFF3F) return wave_ram[addr - 0xFF30];
+
+    /* unused bits read back as 1 (hardware OR masks) */
+    static const u8 masks[0x17] = {
+        0x80, 0x3F, 0x00, 0xFF, 0xBF, /* NR10-NR14 */
+        0xFF, 0x3F, 0x00, 0xFF, 0xBF, /* ----, NR21-NR24 */
+        0x7F, 0xFF, 0x9F, 0xFF, 0xBF, /* NR30-NR34 */
+        0xFF, 0xFF, 0x00, 0x00, 0xBF, /* ----, NR41-NR44 */
+        0x00, 0x00, 0x70, /* NR50, NR51, NR52 */
+    };
+
+    if(addr >= 0xFF10 && addr <= 0xFF23) {
+        uint idx = addr - 0xFF10;
+        const Ch& c = ch[idx / 5];
+        u8 raw;
+        switch(idx % 5) {
+        case 0: raw = c.nr0; break;
+        case 1: raw = c.nr1; break;
+        case 2: raw = c.nr2; break;
+        case 3: raw = c.nr3; break;
+        default: raw = c.nr4; break;
+        }
+        return raw | masks[idx];
+    }
+
+    switch(addr) {
+    case 0xFF24:
+        return nr50;
+    case 0xFF25:
+        return nr51;
+    case 0xFF26: {
+        u8 v = (u8)(power ? 0x80 : 0x00) | 0x70;
+        for(uint n = 0; n < 4; n++)
+            if(ch[n].enabled) v |= (u8)(1 << n);
+        return v;
+    }
+    default:
+        return 0xFF; /* 0xFF27 - 0xFF2F */
+    }
+}
+
+void Apu::get_voice(uint n, ApuVoice* out) const {
+    const Ch& c = ch[n];
+
+    out->order = c.order;
+
+    bool routed = ((nr51 >> n) & 1) || ((nr51 >> (n + 4)) & 1);
+
+    u8 vol;
+    if(n == 2) {
+        /* wave output level: mute / 100% / 50% / 25% */
+        switch((c.nr2 >> 5) & 3) {
+        case 0: vol = 0; break;
+        case 1: vol = 15; break;
+        case 2: vol = 7; break;
+        default: vol = 3; break;
+        }
+    } else {
+        vol = c.env_volume;
+    }
+    out->volume = vol;
+    out->active = power && c.enabled && dac_on(n) && routed && vol > 0;
+
+    if(n == 3) {
+        /* noise: LFSR clock rate (the frontend maps it to a percussive
+         * buzz; a piezo cannot reproduce real noise) */
+        u8 shift = c.nr3 >> 4;
+        u8 r = c.nr3 & 0x07;
+        u32 divisor = r ? ((u32)r << 4) : 8u;
+        out->freq_hz = (524288u / divisor) >> (shift + 1);
+    } else {
+        uint x = ch_freq(n);
+        out->freq_hz = ((n == 2) ? 65536u : 131072u) / (2048u - x);
+    }
+}

applications/system/FlipperGB/gb/apu.h

@@ -0,0 +1,89 @@
+#pragma once
+
+#include "definitions.h"
+
+/* Register-level APU (no waveform synthesis).
+ *
+ * The Flipper Zero speaker is a single-tone piezo: it can play exactly one
+ * frequency at one volume at a time. Synthesizing the real 4-channel GB mix
+ * would be wasted CPU (there is no DAC to play it on), so this APU only
+ * models what games actually program into the sound registers:
+ *
+ *  - channel frequencies (including the CH1 frequency sweep)
+ *  - volume envelopes (64 Hz), length counters (256 Hz), sweep (128 Hz)
+ *  - trigger / DAC-enable / NR52 power semantics and register read-back
+ *    masks (some games poll NR52 channel-status bits)
+ *
+ * The frontend queries the per-channel state once per frame and decides
+ * which voice to send to the piezo. Cost per emulated instruction: one
+ * counter add + compare. Extra RAM: ~120 bytes.
+ */
+
+struct ApuVoice {
+    bool active; /* audible now: triggered, DAC on, length alive, routed */
+    u32 freq_hz; /* square/wave: tone frequency. noise: LFSR clock rate */
+    u8 volume; /* current volume 0..15 (wave level mapped to 0/3/7/15) */
+    u32 order; /* trigger recency; higher = more recently triggered */
+};
+
+class Apu {
+public:
+    void tick(uint cycles);
+
+    /* 0xFF10 - 0xFF3F (sound registers + wave RAM) */
+    auto read(u16 addr) const -> u8;
+    void write(u16 addr, u8 value);
+
+    /* n: 0 = pulse 1, 1 = pulse 2, 2 = wave, 3 = noise */
+    void get_voice(uint n, ApuVoice* out) const;
+
+    /* Master volume 0..7 (louder of the two NR50 output terminals) */
+    auto master_volume() const -> u8 {
+        u8 l = (nr50 >> 4) & 7;
+        u8 r = nr50 & 7;
+        return l > r ? l : r;
+    }
+
+private:
+    struct Ch {
+        u8 nr0 = 0, nr1 = 0, nr2 = 0, nr3 = 0, nr4 = 0;
+        bool enabled = false;
+        uint length = 0;
+        u8 env_volume = 0;
+        u8 env_timer = 0;
+        u32 order = 0;
+    };
+    Ch ch[4]; /* 0 = pulse1, 1 = pulse2, 2 = wave, 3 = noise */
+
+    /* channel 1 sweep unit */
+    uint sweep_shadow = 0;
+    u8 sweep_timer = 0;
+    bool sweep_enabled = false;
+
+    u8 nr50 = 0, nr51 = 0;
+    bool power = false;
+    u8 wave_ram[16] = {};
+
+    uint seq_counter = 0;
+    u8 seq_step = 0;
+    u32 trigger_counter = 0;
+
+    auto dac_on(uint n) const -> bool {
+        if(n == 2) return (ch[2].nr0 & 0x80) != 0;
+        return (ch[n].nr2 & 0xF8) != 0;
+    }
+    auto ch_freq(uint n) const -> uint {
+        return ((uint)(ch[n].nr4 & 0x07) << 8) | ch[n].nr3;
+    }
+    void set_ch_freq(uint n, uint f) {
+        ch[n].nr3 = (u8)(f & 0xFF);
+        ch[n].nr4 = (u8)((ch[n].nr4 & ~0x07) | ((f >> 8) & 0x07));
+    }
+
+    void trigger(uint n);
+    void clock_lengths();
+    void clock_envelopes();
+    void clock_sweep();
+    auto sweep_calc() const -> uint;
+    void power_off();
+};

applications/system/FlipperGB/gb/bitwise.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include "definitions.h"
+
+namespace bitwise {
+
+inline auto compose_bits(const u8 high, const u8 low) -> u8 {
+    return static_cast<u8>(high << 1 | low);
+}
+
+inline auto compose_nibbles(const u8 high, const u8 low) -> u8 {
+    return static_cast<u8>((high << 4) | low);
+}
+
+inline auto compose_bytes(const u8 high, const u8 low) -> u16 {
+    return static_cast<u16>((high << 8) | low);
+}
+
+inline auto check_bit(const u8 value, const u8 bit) -> bool { return (value & (1 << bit)) != 0; }
+
+inline auto bit_value(const u8 value, const u8 bit) -> u8 { return (value >> bit) & 1; }
+
+inline auto set_bit(const u8 value, const u8 bit) -> u8 {
+    auto value_set = value | (1 << bit);
+    return static_cast<u8>(value_set);
+}
+
+inline auto clear_bit(const u8 value, const u8 bit) -> u8 {
+    auto value_cleared = value & ~(1 << bit);
+    return static_cast<u8>(value_cleared);
+}
+
+inline auto set_bit_to(const u8 value, const u8 bit, bool bit_on) -> u8 {
+    return bit_on
+        ? set_bit(value, bit)
+        : clear_bit(value, bit);
+}
+
+} // namespace bitwise

applications/system/FlipperGB/gb/cartridge.cc

@@ -0,0 +1,236 @@
+#include "cartridge.h"
+
+void Cartridge::init(
+    const u8* bank0_data,
+    uint rom_bank_count,
+    MBCType mbc_type,
+    u8* cart_ram,
+    u32 cart_ram_size,
+    RomBankProvider rom_provider,
+    void* rom_provider_ctx) {
+    bank0 = bank0_data;
+    bank_count = rom_bank_count > 0 ? rom_bank_count : 2;
+    mbc = mbc_type;
+    ram = cart_ram;
+    ram_size = cart_ram_size;
+    provider = rom_provider;
+    provider_ctx = rom_provider_ctx;
+
+    ram_enabled = false;
+    advanced_banking_mode = false;
+    bank_low = 1;
+    bank_high = 0;
+    ram_bank = 0;
+
+    update_rom_bank();
+}
+
+void Cartridge::update_rom_bank() {
+    uint bank;
+
+    switch(mbc) {
+    case MBCType::None:
+        bank = 1;
+        break;
+    case MBCType::MBC1:
+        bank = (bank_high << 5) | bank_low;
+        /* bank_low == 0 is translated to 1 at write time */
+        break;
+    case MBCType::MBC2:
+    case MBCType::MBC3:
+        bank = bank_low;
+        break;
+    case MBCType::MBC5:
+        /* MBC5 genuinely allows bank 0 in the switchable slot */
+        bank = (bank_high << 8) | bank_low;
+        break;
+    default:
+        bank = 1;
+        break;
+    }
+
+    if(bank_count) bank %= bank_count;
+
+    bankN = provider(provider_ctx, bank);
+}
+
+void Cartridge::write(u16 addr, u8 value) {
+    if(addr >= 0xA000) {
+        write_ram(addr, value);
+        return;
+    }
+
+    switch(mbc) {
+    case MBCType::None:
+        return;
+
+    case MBCType::MBC1:
+        if(addr < 0x2000) {
+            ram_enabled = (value & 0x0F) == 0x0A;
+        } else if(addr < 0x4000) {
+            bank_low = value & 0x1F;
+            if(bank_low == 0) bank_low = 1;
+            update_rom_bank();
+        } else if(addr < 0x6000) {
+            bank_high = value & 0x03;
+            if(advanced_banking_mode) {
+                ram_bank = value & 0x03;
+            }
+            update_rom_bank();
+        } else {
+            advanced_banking_mode = (value & 0x01) != 0;
+            ram_bank = advanced_banking_mode ? (bank_high & 0x03) : 0;
+            update_rom_bank();
+        }
+        return;
+
+    case MBCType::MBC2:
+        if(addr < 0x4000) {
+            /* bit 8 of the address selects RAM-enable vs ROM-bank */
+            if(addr & 0x0100) {
+                bank_low = value & 0x0F;
+                if(bank_low == 0) bank_low = 1;
+                update_rom_bank();
+            } else {
+                ram_enabled = (value & 0x0F) == 0x0A;
+            }
+        }
+        return;
+
+    case MBCType::MBC3:
+        if(addr < 0x2000) {
+            ram_enabled = (value & 0x0F) == 0x0A;
+        } else if(addr < 0x4000) {
+            bank_low = value & 0x7F;
+            if(bank_low == 0) bank_low = 1;
+            update_rom_bank();
+        } else if(addr < 0x6000) {
+            /* 0x00-0x03: RAM bank. 0x08-0x0C: RTC register (unsupported,
+             * reads return 0xFF via ram_bank marker) */
+            ram_bank = value;
+        } else {
+            /* RTC latch: unsupported */
+        }
+        return;
+
+    case MBCType::MBC5:
+        if(addr < 0x2000) {
+            ram_enabled = (value & 0x0F) == 0x0A;
+        } else if(addr < 0x3000) {
+            bank_low = value;
+            update_rom_bank();
+        } else if(addr < 0x4000) {
+            bank_high = value & 0x01;
+            update_rom_bank();
+        } else if(addr < 0x6000) {
+            ram_bank = value & 0x0F;
+        }
+        return;
+
+    default:
+        return;
+    }
+}
+
+auto Cartridge::read_ram(u16 addr) const -> u8 {
+    if(!ram || !ram_enabled) return 0xFF;
+
+    if(mbc == MBCType::MBC2) {
+        /* 512 half-bytes, mirrored */
+        return static_cast<u8>(ram[(addr - 0xA000) & 0x1FF] | 0xF0);
+    }
+
+    if(mbc == MBCType::MBC3 && ram_bank > 0x03) return 0xFF; /* RTC regs */
+
+    u32 idx = static_cast<u32>(addr - 0xA000) + static_cast<u32>(ram_bank & 0x0F) * 0x2000;
+    if(idx >= ram_size) idx %= ram_size;
+    return ram[idx];
+}
+
+void Cartridge::write_ram(u16 addr, u8 value) {
+    if(!ram || !ram_enabled) return;
+
+    if(mbc == MBCType::MBC2) {
+        ram[(addr - 0xA000) & 0x1FF] = value & 0x0F;
+        return;
+    }
+
+    if(mbc == MBCType::MBC3 && ram_bank > 0x03) return; /* RTC regs */
+
+    u32 idx = static_cast<u32>(addr - 0xA000) + static_cast<u32>(ram_bank & 0x0F) * 0x2000;
+    if(idx >= ram_size) idx %= ram_size;
+    ram[idx] = value;
+}
+
+auto Cartridge::parse_mbc(u8 t) -> MBCType {
+    switch(t) {
+    case 0x00:
+    case 0x08:
+    case 0x09:
+        return MBCType::None;
+    case 0x01:
+    case 0x02:
+    case 0x03:
+        return MBCType::MBC1;
+    case 0x05:
+    case 0x06:
+        return MBCType::MBC2;
+    case 0x0F:
+    case 0x10:
+    case 0x11:
+    case 0x12:
+    case 0x13:
+        return MBCType::MBC3;
+    case 0x19:
+    case 0x1A:
+    case 0x1B:
+    case 0x1C:
+    case 0x1D:
+    case 0x1E:
+        return MBCType::MBC5;
+    default:
+        return MBCType::Unsupported;
+    }
+}
+
+auto Cartridge::has_battery(u8 t) -> bool {
+    switch(t) {
+    case 0x03: /* MBC1+RAM+BATTERY */
+    case 0x06: /* MBC2+BATTERY */
+    case 0x09: /* ROM+RAM+BATTERY */
+    case 0x0F: /* MBC3+TIMER+BATTERY */
+    case 0x10: /* MBC3+TIMER+RAM+BATTERY */
+    case 0x13: /* MBC3+RAM+BATTERY */
+    case 0x1B: /* MBC5+RAM+BATTERY */
+    case 0x1E: /* MBC5+RUMBLE+RAM+BATTERY */
+        return true;
+    default:
+        return false;
+    }
+}
+
+auto Cartridge::rom_bank_count_from_header(u8 rom_size_byte) -> uint {
+    /* 0x00 = 32KB (2 banks), each step doubles */
+    if(rom_size_byte <= 0x08) return 2u << rom_size_byte;
+    return 2;
+}
+
+auto Cartridge::ram_size_from_header(u8 ram_size_byte, MBCType mbc) -> u32 {
+    if(mbc == MBCType::MBC2) return 512; /* built-in, not in header */
+    switch(ram_size_byte) {
+    case 0x00:
+        return 0;
+    case 0x01:
+        return 0x800; /* 2 KB */
+    case 0x02:
+        return 0x2000; /* 8 KB */
+    case 0x03:
+        return 0x8000; /* 32 KB */
+    case 0x04:
+        return 0x20000; /* 128 KB */
+    case 0x05:
+        return 0x10000; /* 64 KB */
+    default:
+        return 0;
+    }
+}

applications/system/FlipperGB/gb/cartridge.h

@@ -0,0 +1,80 @@
+#pragma once
+
+#include "definitions.h"
+
+/* Cartridge with pluggable ROM bank provider.
+ *
+ * Instead of holding the whole ROM in RAM (impossible on Flipper Zero for
+ * anything above 32 KB), the cartridge asks the platform for a pointer to a
+ * 16 KB bank whenever the game switches banks. On the desktop test build the
+ * provider just returns `rom + bank * 0x4000`; on the Flipper it is backed
+ * by an LRU cache streaming from the SD card.
+ *
+ * Supported mappers: ROM only, MBC1 (incl. upper bits / mode select),
+ * MBC2 (built-in 512x4 RAM), MBC3 (no RTC), MBC5.
+ */
+
+using RomBankProvider = const u8* (*)(void* ctx, uint bank);
+
+enum class MBCType : u8 {
+    None,
+    MBC1,
+    MBC2,
+    MBC3,
+    MBC5,
+    Unsupported,
+};
+
+class Cartridge {
+public:
+    /* bank0 must stay valid for the lifetime of the cartridge */
+    void init(
+        const u8* bank0_data,
+        uint rom_bank_count,
+        MBCType mbc_type,
+        u8* cart_ram,
+        u32 cart_ram_size,
+        RomBankProvider provider,
+        void* provider_ctx);
+
+    auto read(u16 addr) const -> u8 {
+        if(addr < 0x4000) return bank0[addr];
+        if(addr < 0x8000) return bankN[addr - 0x4000];
+        /* 0xA000 - 0xBFFF: cartridge RAM */
+        return read_ram(addr);
+    }
+
+    void write(u16 addr, u8 value);
+
+    auto get_ram() -> u8* { return ram; }
+    auto get_ram_size() const -> u32 { return ram_size; }
+
+    /* Header helpers (operate on the first bank) */
+    static auto parse_mbc(u8 cartridge_type_byte) -> MBCType;
+    static auto has_battery(u8 cartridge_type_byte) -> bool;
+    static auto rom_bank_count_from_header(u8 rom_size_byte) -> uint;
+    static auto ram_size_from_header(u8 ram_size_byte, MBCType mbc) -> u32;
+
+private:
+    auto read_ram(u16 addr) const -> u8;
+    void write_ram(u16 addr, u8 value);
+    void update_rom_bank();
+
+    const u8* bank0 = nullptr;
+    const u8* bankN = nullptr;
+
+    u8* ram = nullptr;
+    u32 ram_size = 0;
+
+    RomBankProvider provider = nullptr;
+    void* provider_ctx = nullptr;
+
+    MBCType mbc = MBCType::None;
+    uint bank_count = 2;
+
+    bool ram_enabled = false;
+    bool advanced_banking_mode = false; /* MBC1 mode 1 */
+    uint bank_low = 1; /* MBC1: 5 bits, MBC3: 7 bits, MBC5: 8 bits */
+    uint bank_high = 0; /* MBC1: 2 bits, MBC5: 9th bit */
+    uint ram_bank = 0;
+};

applications/system/FlipperGB/gb/cpu.cc

@@ -0,0 +1,225 @@
+#include "cpu.h"
+
+#include "gameboy.h"
+#include "opcode_cycles.h"
+#include "bitwise.h"
+
+using bitwise::compose_bytes;
+
+CPU::CPU(Gameboy& inGb) :
+    gb(inGb),
+    af(a, f, 0xF0),
+    bc(b, c),
+    de(d, e),
+    hl(h, l)
+{
+}
+
+void CPU::init_post_boot() {
+    af.set(0x01B0);
+    bc.set(0x0013);
+    de.set(0x00D8);
+    hl.set(0x014D);
+    sp.set(0xFFFE);
+    pc.set(0x0100);
+    interrupt_flag.set(0xE1);
+    interrupt_enabled.set(0x00);
+    interrupts_enabled = false;
+    halted = false;
+}
+
+auto CPU::tick() -> Cycles {
+    handle_interrupts();
+
+    /* Halted: batch 4 M-cycles per iteration. Games spend most of every
+     * frame in HALT waiting for vblank; stepping 1 cycle at a time made
+     * the idle part of the frame as expensive to emulate as the busy part.
+     * Interrupt recognition is delayed by at most 3 M-cycles (12 T-cycles),
+     * well within what real hardware tolerates. */
+    if (halted) { return 4; }
+
+    u16 opcode_pc = pc.value();
+    auto opcode = get_byte_from_pc();
+    auto cycles = execute_opcode(opcode, opcode_pc);
+    return cycles;
+}
+
+auto CPU::execute_opcode(const u8 opcode, u16 opcode_pc) -> Cycles {
+    branch_taken = false;
+
+    if (opcode == 0xCB) {
+        u8 cb_opcode = get_byte_from_pc();
+        return execute_cb_opcode(cb_opcode, opcode_pc);
+    }
+
+    return execute_normal_opcode(opcode, opcode_pc);
+}
+
+void CPU::handle_interrupts() {
+    u8 fired_interrupts = interrupt_flag.value() & interrupt_enabled.value();
+    if (!fired_interrupts) { return; }
+
+    if (halted && fired_interrupts != 0x0) {
+        // TODO: Handle halt bug
+        halted = false;
+    }
+
+    if (!interrupts_enabled) {
+        return;
+    }
+
+    stack_push(pc);
+
+    bool handled_interrupt = false;
+
+    handled_interrupt = handle_interrupt(0, interrupts::vblank, fired_interrupts);
+    if (handled_interrupt) { return; }
+
+    handled_interrupt = handle_interrupt(1, interrupts::lcdc_status, fired_interrupts);
+    if (handled_interrupt) { return; }
+
+    handled_interrupt = handle_interrupt(2, interrupts::timer, fired_interrupts);
+    if (handled_interrupt) { return; }
+
+    handled_interrupt = handle_interrupt(3, interrupts::serial, fired_interrupts);
+    if (handled_interrupt) { return; }
+
+    handled_interrupt = handle_interrupt(4, interrupts::joypad, fired_interrupts);
+    if (handled_interrupt) { return; }
+}
+
+auto CPU::handle_interrupt(u8 interrupt_bit, u16 interrupt_vector, u8 fired_interrupts) -> bool {
+    using bitwise::check_bit;
+
+    if (!check_bit(fired_interrupts, interrupt_bit)) { return false; }
+
+    interrupt_flag.set_bit_to(interrupt_bit, false);
+    pc.set(interrupt_vector);
+    interrupts_enabled = false;
+    return true;
+}
+
+auto CPU::get_byte_from_pc() -> u8 {
+    u8 byte = gb.mmu.read(Address(pc));
+    pc.increment();
+
+    return byte;
+}
+
+auto CPU::get_signed_byte_from_pc() -> s8 {
+    u8 byte = get_byte_from_pc();
+    return static_cast<s8>(byte);
+}
+
+auto CPU::get_word_from_pc() -> u16 {
+    u8 low_byte = get_byte_from_pc();
+    u8 high_byte = get_byte_from_pc();
+
+    return compose_bytes(high_byte, low_byte);
+}
+
+void CPU::set_flag_zero(bool set) { f.set_flag_zero(set); }
+void CPU::set_flag_subtract(bool set) { f.set_flag_subtract(set); }
+void CPU::set_flag_half_carry(bool set) { f.set_flag_half_carry(set); }
+void CPU::set_flag_carry(bool set) { f.set_flag_carry(set); }
+
+auto CPU::is_condition(Condition condition) -> bool {
+    bool should_branch = false;
+
+    switch (condition) {
+        case Condition::C:
+            should_branch = f.flag_carry();
+            break;
+        case Condition::NC:
+            should_branch = !f.flag_carry();
+            break;
+        case Condition::Z:
+            should_branch = f.flag_zero();
+            break;
+        case Condition::NZ:
+            should_branch = !f.flag_zero();
+            break;
+    }
+
+    /* If the branch is taken, remember so that the correct processor cycles
+     * can be used */
+    branch_taken = should_branch;
+    return should_branch;
+}
+
+template <typename T>
+void CPU::stack_push(const T& reg) {
+    sp.decrement();
+    gb.mmu.write(Address(sp), reg.high());
+    sp.decrement();
+    gb.mmu.write(Address(sp), reg.low());
+}
+
+template <typename T>
+void CPU::stack_pop(T& reg) {
+    u8 low_byte = gb.mmu.read(Address(sp));
+    sp.increment();
+    u8 high_byte = gb.mmu.read(Address(sp));
+    sp.increment();
+
+    u16 value = compose_bytes(high_byte, low_byte);
+    reg.set(value);
+}
+
+template void CPU::stack_push<WordRegister>(const WordRegister&);
+template void CPU::stack_push<RegisterPair>(const RegisterPair&);
+template void CPU::stack_pop<WordRegister>(WordRegister&);
+template void CPU::stack_pop<RegisterPair>(RegisterPair&);
+
+/* clang-format off */
+auto CPU::execute_normal_opcode(const u8 opcode, u16 opcode_pc) -> Cycles {
+    (void)opcode_pc;
+
+    switch (opcode) {
+        case 0x00: opcode_00(); break; case 0x01: opcode_01(); break; case 0x02: opcode_02(); break; case 0x03: opcode_03(); break; case 0x04: opcode_04(); break; case 0x05: opcode_05(); break; case 0x06: opcode_06(); break; case 0x07: opcode_07(); break; case 0x08: opcode_08(); break; case 0x09: opcode_09(); break; case 0x0A: opcode_0A(); break; case 0x0B: opcode_0B(); break; case 0x0C: opcode_0C(); break; case 0x0D: opcode_0D(); break; case 0x0E: opcode_0E(); break; case 0x0F: opcode_0F(); break;
+        case 0x10: opcode_10(); break; case 0x11: opcode_11(); break; case 0x12: opcode_12(); break; case 0x13: opcode_13(); break; case 0x14: opcode_14(); break; case 0x15: opcode_15(); break; case 0x16: opcode_16(); break; case 0x17: opcode_17(); break; case 0x18: opcode_18(); break; case 0x19: opcode_19(); break; case 0x1A: opcode_1A(); break; case 0x1B: opcode_1B(); break; case 0x1C: opcode_1C(); break; case 0x1D: opcode_1D(); break; case 0x1E: opcode_1E(); break; case 0x1F: opcode_1F(); break;
+        case 0x20: opcode_20(); break; case 0x21: opcode_21(); break; case 0x22: opcode_22(); break; case 0x23: opcode_23(); break; case 0x24: opcode_24(); break; case 0x25: opcode_25(); break; case 0x26: opcode_26(); break; case 0x27: opcode_27(); break; case 0x28: opcode_28(); break; case 0x29: opcode_29(); break; case 0x2A: opcode_2A(); break; case 0x2B: opcode_2B(); break; case 0x2C: opcode_2C(); break; case 0x2D: opcode_2D(); break; case 0x2E: opcode_2E(); break; case 0x2F: opcode_2F(); break;
+        case 0x30: opcode_30(); break; case 0x31: opcode_31(); break; case 0x32: opcode_32(); break; case 0x33: opcode_33(); break; case 0x34: opcode_34(); break; case 0x35: opcode_35(); break; case 0x36: opcode_36(); break; case 0x37: opcode_37(); break; case 0x38: opcode_38(); break; case 0x39: opcode_39(); break; case 0x3A: opcode_3A(); break; case 0x3B: opcode_3B(); break; case 0x3C: opcode_3C(); break; case 0x3D: opcode_3D(); break; case 0x3E: opcode_3E(); break; case 0x3F: opcode_3F(); break;
+        case 0x40: opcode_40(); break; case 0x41: opcode_41(); break; case 0x42: opcode_42(); break; case 0x43: opcode_43(); break; case 0x44: opcode_44(); break; case 0x45: opcode_45(); break; case 0x46: opcode_46(); break; case 0x47: opcode_47(); break; case 0x48: opcode_48(); break; case 0x49: opcode_49(); break; case 0x4A: opcode_4A(); break; case 0x4B: opcode_4B(); break; case 0x4C: opcode_4C(); break; case 0x4D: opcode_4D(); break; case 0x4E: opcode_4E(); break; case 0x4F: opcode_4F(); break;
+        case 0x50: opcode_50(); break; case 0x51: opcode_51(); break; case 0x52: opcode_52(); break; case 0x53: opcode_53(); break; case 0x54: opcode_54(); break; case 0x55: opcode_55(); break; case 0x56: opcode_56(); break; case 0x57: opcode_57(); break; case 0x58: opcode_58(); break; case 0x59: opcode_59(); break; case 0x5A: opcode_5A(); break; case 0x5B: opcode_5B(); break; case 0x5C: opcode_5C(); break; case 0x5D: opcode_5D(); break; case 0x5E: opcode_5E(); break; case 0x5F: opcode_5F(); break;
+        case 0x60: opcode_60(); break; case 0x61: opcode_61(); break; case 0x62: opcode_62(); break; case 0x63: opcode_63(); break; case 0x64: opcode_64(); break; case 0x65: opcode_65(); break; case 0x66: opcode_66(); break; case 0x67: opcode_67(); break; case 0x68: opcode_68(); break; case 0x69: opcode_69(); break; case 0x6A: opcode_6A(); break; case 0x6B: opcode_6B(); break; case 0x6C: opcode_6C(); break; case 0x6D: opcode_6D(); break; case 0x6E: opcode_6E(); break; case 0x6F: opcode_6F(); break;
+        case 0x70: opcode_70(); break; case 0x71: opcode_71(); break; case 0x72: opcode_72(); break; case 0x73: opcode_73(); break; case 0x74: opcode_74(); break; case 0x75: opcode_75(); break; case 0x76: opcode_76(); break; case 0x77: opcode_77(); break; case 0x78: opcode_78(); break; case 0x79: opcode_79(); break; case 0x7A: opcode_7A(); break; case 0x7B: opcode_7B(); break; case 0x7C: opcode_7C(); break; case 0x7D: opcode_7D(); break; case 0x7E: opcode_7E(); break; case 0x7F: opcode_7F(); break;
+        case 0x80: opcode_80(); break; case 0x81: opcode_81(); break; case 0x82: opcode_82(); break; case 0x83: opcode_83(); break; case 0x84: opcode_84(); break; case 0x85: opcode_85(); break; case 0x86: opcode_86(); break; case 0x87: opcode_87(); break; case 0x88: opcode_88(); break; case 0x89: opcode_89(); break; case 0x8A: opcode_8A(); break; case 0x8B: opcode_8B(); break; case 0x8C: opcode_8C(); break; case 0x8D: opcode_8D(); break; case 0x8E: opcode_8E(); break; case 0x8F: opcode_8F(); break;
+        case 0x90: opcode_90(); break; case 0x91: opcode_91(); break; case 0x92: opcode_92(); break; case 0x93: opcode_93(); break; case 0x94: opcode_94(); break; case 0x95: opcode_95(); break; case 0x96: opcode_96(); break; case 0x97: opcode_97(); break; case 0x98: opcode_98(); break; case 0x99: opcode_99(); break; case 0x9A: opcode_9A(); break; case 0x9B: opcode_9B(); break; case 0x9C: opcode_9C(); break; case 0x9D: opcode_9D(); break; case 0x9E: opcode_9E(); break; case 0x9F: opcode_9F(); break;
+        case 0xA0: opcode_A0(); break; case 0xA1: opcode_A1(); break; case 0xA2: opcode_A2(); break; case 0xA3: opcode_A3(); break; case 0xA4: opcode_A4(); break; case 0xA5: opcode_A5(); break; case 0xA6: opcode_A6(); break; case 0xA7: opcode_A7(); break; case 0xA8: opcode_A8(); break; case 0xA9: opcode_A9(); break; case 0xAA: opcode_AA(); break; case 0xAB: opcode_AB(); break; case 0xAC: opcode_AC(); break; case 0xAD: opcode_AD(); break; case 0xAE: opcode_AE(); break; case 0xAF: opcode_AF(); break;
+        case 0xB0: opcode_B0(); break; case 0xB1: opcode_B1(); break; case 0xB2: opcode_B2(); break; case 0xB3: opcode_B3(); break; case 0xB4: opcode_B4(); break; case 0xB5: opcode_B5(); break; case 0xB6: opcode_B6(); break; case 0xB7: opcode_B7(); break; case 0xB8: opcode_B8(); break; case 0xB9: opcode_B9(); break; case 0xBA: opcode_BA(); break; case 0xBB: opcode_BB(); break; case 0xBC: opcode_BC(); break; case 0xBD: opcode_BD(); break; case 0xBE: opcode_BE(); break; case 0xBF: opcode_BF(); break;
+        case 0xC0: opcode_C0(); break; case 0xC1: opcode_C1(); break; case 0xC2: opcode_C2(); break; case 0xC3: opcode_C3(); break; case 0xC4: opcode_C4(); break; case 0xC5: opcode_C5(); break; case 0xC6: opcode_C6(); break; case 0xC7: opcode_C7(); break; case 0xC8: opcode_C8(); break; case 0xC9: opcode_C9(); break; case 0xCA: opcode_CA(); break; case 0xCB: opcode_CB(); break; case 0xCC: opcode_CC(); break; case 0xCD: opcode_CD(); break; case 0xCE: opcode_CE(); break; case 0xCF: opcode_CF(); break;
+        case 0xD0: opcode_D0(); break; case 0xD1: opcode_D1(); break; case 0xD2: opcode_D2(); break; case 0xD3: opcode_D3(); break; case 0xD4: opcode_D4(); break; case 0xD5: opcode_D5(); break; case 0xD6: opcode_D6(); break; case 0xD7: opcode_D7(); break; case 0xD8: opcode_D8(); break; case 0xD9: opcode_D9(); break; case 0xDA: opcode_DA(); break; case 0xDB: opcode_DB(); break; case 0xDC: opcode_DC(); break; case 0xDD: opcode_DD(); break; case 0xDE: opcode_DE(); break; case 0xDF: opcode_DF(); break;
+        case 0xE0: opcode_E0(); break; case 0xE1: opcode_E1(); break; case 0xE2: opcode_E2(); break; case 0xE3: opcode_E3(); break; case 0xE4: opcode_E4(); break; case 0xE5: opcode_E5(); break; case 0xE6: opcode_E6(); break; case 0xE7: opcode_E7(); break; case 0xE8: opcode_E8(); break; case 0xE9: opcode_E9(); break; case 0xEA: opcode_EA(); break; case 0xEB: opcode_EB(); break; case 0xEC: opcode_EC(); break; case 0xED: opcode_ED(); break; case 0xEE: opcode_EE(); break; case 0xEF: opcode_EF(); break;
+        case 0xF0: opcode_F0(); break; case 0xF1: opcode_F1(); break; case 0xF2: opcode_F2(); break; case 0xF3: opcode_F3(); break; case 0xF4: opcode_F4(); break; case 0xF5: opcode_F5(); break; case 0xF6: opcode_F6(); break; case 0xF7: opcode_F7(); break; case 0xF8: opcode_F8(); break; case 0xF9: opcode_F9(); break; case 0xFA: opcode_FA(); break; case 0xFB: opcode_FB(); break; case 0xFC: opcode_FC(); break; case 0xFD: opcode_FD(); break; case 0xFE: opcode_FE(); break; case 0xFF: opcode_FF(); break;
+    }
+
+    return !branch_taken
+        ? opcode_cycles[opcode]
+        : opcode_cycles_branched[opcode];
+}
+
+auto CPU::execute_cb_opcode(const u8 opcode, u16 opcode_pc) -> Cycles {
+    (void)opcode_pc;
+
+    switch (opcode) {
+        case 0x00: opcode_CB_00(); break; case 0x01: opcode_CB_01(); break; case 0x02: opcode_CB_02(); break; case 0x03: opcode_CB_03(); break; case 0x04: opcode_CB_04(); break; case 0x05: opcode_CB_05(); break; case 0x06: opcode_CB_06(); break; case 0x07: opcode_CB_07(); break; case 0x08: opcode_CB_08(); break; case 0x09: opcode_CB_09(); break; case 0x0A: opcode_CB_0A(); break; case 0x0B: opcode_CB_0B(); break; case 0x0C: opcode_CB_0C(); break; case 0x0D: opcode_CB_0D(); break; case 0x0E: opcode_CB_0E(); break; case 0x0F: opcode_CB_0F(); break;
+        case 0x10: opcode_CB_10(); break; case 0x11: opcode_CB_11(); break; case 0x12: opcode_CB_12(); break; case 0x13: opcode_CB_13(); break; case 0x14: opcode_CB_14(); break; case 0x15: opcode_CB_15(); break; case 0x16: opcode_CB_16(); break; case 0x17: opcode_CB_17(); break; case 0x18: opcode_CB_18(); break; case 0x19: opcode_CB_19(); break; case 0x1A: opcode_CB_1A(); break; case 0x1B: opcode_CB_1B(); break; case 0x1C: opcode_CB_1C(); break; case 0x1D: opcode_CB_1D(); break; case 0x1E: opcode_CB_1E(); break; case 0x1F: opcode_CB_1F(); break;
+        case 0x20: opcode_CB_20(); break; case 0x21: opcode_CB_21(); break; case 0x22: opcode_CB_22(); break; case 0x23: opcode_CB_23(); break; case 0x24: opcode_CB_24(); break; case 0x25: opcode_CB_25(); break; case 0x26: opcode_CB_26(); break; case 0x27: opcode_CB_27(); break; case 0x28: opcode_CB_28(); break; case 0x29: opcode_CB_29(); break; case 0x2A: opcode_CB_2A(); break; case 0x2B: opcode_CB_2B(); break; case 0x2C: opcode_CB_2C(); break; case 0x2D: opcode_CB_2D(); break; case 0x2E: opcode_CB_2E(); break; case 0x2F: opcode_CB_2F(); break;
+        case 0x30: opcode_CB_30(); break; case 0x31: opcode_CB_31(); break; case 0x32: opcode_CB_32(); break; case 0x33: opcode_CB_33(); break; case 0x34: opcode_CB_34(); break; case 0x35: opcode_CB_35(); break; case 0x36: opcode_CB_36(); break; case 0x37: opcode_CB_37(); break; case 0x38: opcode_CB_38(); break; case 0x39: opcode_CB_39(); break; case 0x3A: opcode_CB_3A(); break; case 0x3B: opcode_CB_3B(); break; case 0x3C: opcode_CB_3C(); break; case 0x3D: opcode_CB_3D(); break; case 0x3E: opcode_CB_3E(); break; case 0x3F: opcode_CB_3F(); break;
+        case 0x40: opcode_CB_40(); break; case 0x41: opcode_CB_41(); break; case 0x42: opcode_CB_42(); break; case 0x43: opcode_CB_43(); break; case 0x44: opcode_CB_44(); break; case 0x45: opcode_CB_45(); break; case 0x46: opcode_CB_46(); break; case 0x47: opcode_CB_47(); break; case 0x48: opcode_CB_48(); break; case 0x49: opcode_CB_49(); break; case 0x4A: opcode_CB_4A(); break; case 0x4B: opcode_CB_4B(); break; case 0x4C: opcode_CB_4C(); break; case 0x4D: opcode_CB_4D(); break; case 0x4E: opcode_CB_4E(); break; case 0x4F: opcode_CB_4F(); break;
+        case 0x50: opcode_CB_50(); break; case 0x51: opcode_CB_51(); break; case 0x52: opcode_CB_52(); break; case 0x53: opcode_CB_53(); break; case 0x54: opcode_CB_54(); break; case 0x55: opcode_CB_55(); break; case 0x56: opcode_CB_56(); break; case 0x57: opcode_CB_57(); break; case 0x58: opcode_CB_58(); break; case 0x59: opcode_CB_59(); break; case 0x5A: opcode_CB_5A(); break; case 0x5B: opcode_CB_5B(); break; case 0x5C: opcode_CB_5C(); break; case 0x5D: opcode_CB_5D(); break; case 0x5E: opcode_CB_5E(); break; case 0x5F: opcode_CB_5F(); break;
+        case 0x60: opcode_CB_60(); break; case 0x61: opcode_CB_61(); break; case 0x62: opcode_CB_62(); break; case 0x63: opcode_CB_63(); break; case 0x64: opcode_CB_64(); break; case 0x65: opcode_CB_65(); break; case 0x66: opcode_CB_66(); break; case 0x67: opcode_CB_67(); break; case 0x68: opcode_CB_68(); break; case 0x69: opcode_CB_69(); break; case 0x6A: opcode_CB_6A(); break; case 0x6B: opcode_CB_6B(); break; case 0x6C: opcode_CB_6C(); break; case 0x6D: opcode_CB_6D(); break; case 0x6E: opcode_CB_6E(); break; case 0x6F: opcode_CB_6F(); break;
+        case 0x70: opcode_CB_70(); break; case 0x71: opcode_CB_71(); break; case 0x72: opcode_CB_72(); break; case 0x73: opcode_CB_73(); break; case 0x74: opcode_CB_74(); break; case 0x75: opcode_CB_75(); break; case 0x76: opcode_CB_76(); break; case 0x77: opcode_CB_77(); break; case 0x78: opcode_CB_78(); break; case 0x79: opcode_CB_79(); break; case 0x7A: opcode_CB_7A(); break; case 0x7B: opcode_CB_7B(); break; case 0x7C: opcode_CB_7C(); break; case 0x7D: opcode_CB_7D(); break; case 0x7E: opcode_CB_7E(); break; case 0x7F: opcode_CB_7F(); break;
+        case 0x80: opcode_CB_80(); break; case 0x81: opcode_CB_81(); break; case 0x82: opcode_CB_82(); break; case 0x83: opcode_CB_83(); break; case 0x84: opcode_CB_84(); break; case 0x85: opcode_CB_85(); break; case 0x86: opcode_CB_86(); break; case 0x87: opcode_CB_87(); break; case 0x88: opcode_CB_88(); break; case 0x89: opcode_CB_89(); break; case 0x8A: opcode_CB_8A(); break; case 0x8B: opcode_CB_8B(); break; case 0x8C: opcode_CB_8C(); break; case 0x8D: opcode_CB_8D(); break; case 0x8E: opcode_CB_8E(); break; case 0x8F: opcode_CB_8F(); break;
+        case 0x90: opcode_CB_90(); break; case 0x91: opcode_CB_91(); break; case 0x92: opcode_CB_92(); break; case 0x93: opcode_CB_93(); break; case 0x94: opcode_CB_94(); break; case 0x95: opcode_CB_95(); break; case 0x96: opcode_CB_96(); break; case 0x97: opcode_CB_97(); break; case 0x98: opcode_CB_98(); break; case 0x99: opcode_CB_99(); break; case 0x9A: opcode_CB_9A(); break; case 0x9B: opcode_CB_9B(); break; case 0x9C: opcode_CB_9C(); break; case 0x9D: opcode_CB_9D(); break; case 0x9E: opcode_CB_9E(); break; case 0x9F: opcode_CB_9F(); break;
+        case 0xA0: opcode_CB_A0(); break; case 0xA1: opcode_CB_A1(); break; case 0xA2: opcode_CB_A2(); break; case 0xA3: opcode_CB_A3(); break; case 0xA4: opcode_CB_A4(); break; case 0xA5: opcode_CB_A5(); break; case 0xA6: opcode_CB_A6(); break; case 0xA7: opcode_CB_A7(); break; case 0xA8: opcode_CB_A8(); break; case 0xA9: opcode_CB_A9(); break; case 0xAA: opcode_CB_AA(); break; case 0xAB: opcode_CB_AB(); break; case 0xAC: opcode_CB_AC(); break; case 0xAD: opcode_CB_AD(); break; case 0xAE: opcode_CB_AE(); break; case 0xAF: opcode_CB_AF(); break;
+        case 0xB0: opcode_CB_B0(); break; case 0xB1: opcode_CB_B1(); break; case 0xB2: opcode_CB_B2(); break; case 0xB3: opcode_CB_B3(); break; case 0xB4: opcode_CB_B4(); break; case 0xB5: opcode_CB_B5(); break; case 0xB6: opcode_CB_B6(); break; case 0xB7: opcode_CB_B7(); break; case 0xB8: opcode_CB_B8(); break; case 0xB9: opcode_CB_B9(); break; case 0xBA: opcode_CB_BA(); break; case 0xBB: opcode_CB_BB(); break; case 0xBC: opcode_CB_BC(); break; case 0xBD: opcode_CB_BD(); break; case 0xBE: opcode_CB_BE(); break; case 0xBF: opcode_CB_BF(); break;
+        case 0xC0: opcode_CB_C0(); break; case 0xC1: opcode_CB_C1(); break; case 0xC2: opcode_CB_C2(); break; case 0xC3: opcode_CB_C3(); break; case 0xC4: opcode_CB_C4(); break; case 0xC5: opcode_CB_C5(); break; case 0xC6: opcode_CB_C6(); break; case 0xC7: opcode_CB_C7(); break; case 0xC8: opcode_CB_C8(); break; case 0xC9: opcode_CB_C9(); break; case 0xCA: opcode_CB_CA(); break; case 0xCB: opcode_CB_CB(); break; case 0xCC: opcode_CB_CC(); break; case 0xCD: opcode_CB_CD(); break; case 0xCE: opcode_CB_CE(); break; case 0xCF: opcode_CB_CF(); break;
+        case 0xD0: opcode_CB_D0(); break; case 0xD1: opcode_CB_D1(); break; case 0xD2: opcode_CB_D2(); break; case 0xD3: opcode_CB_D3(); break; case 0xD4: opcode_CB_D4(); break; case 0xD5: opcode_CB_D5(); break; case 0xD6: opcode_CB_D6(); break; case 0xD7: opcode_CB_D7(); break; case 0xD8: opcode_CB_D8(); break; case 0xD9: opcode_CB_D9(); break; case 0xDA: opcode_CB_DA(); break; case 0xDB: opcode_CB_DB(); break; case 0xDC: opcode_CB_DC(); break; case 0xDD: opcode_CB_DD(); break; case 0xDE: opcode_CB_DE(); break; case 0xDF: opcode_CB_DF(); break;
+        case 0xE0: opcode_CB_E0(); break; case 0xE1: opcode_CB_E1(); break; case 0xE2: opcode_CB_E2(); break; case 0xE3: opcode_CB_E3(); break; case 0xE4: opcode_CB_E4(); break; case 0xE5: opcode_CB_E5(); break; case 0xE6: opcode_CB_E6(); break; case 0xE7: opcode_CB_E7(); break; case 0xE8: opcode_CB_E8(); break; case 0xE9: opcode_CB_E9(); break; case 0xEA: opcode_CB_EA(); break; case 0xEB: opcode_CB_EB(); break; case 0xEC: opcode_CB_EC(); break; case 0xED: opcode_CB_ED(); break; case 0xEE: opcode_CB_EE(); break; case 0xEF: opcode_CB_EF(); break;
+        case 0xF0: opcode_CB_F0(); break; case 0xF1: opcode_CB_F1(); break; case 0xF2: opcode_CB_F2(); break; case 0xF3: opcode_CB_F3(); break; case 0xF4: opcode_CB_F4(); break; case 0xF5: opcode_CB_F5(); break; case 0xF6: opcode_CB_F6(); break; case 0xF7: opcode_CB_F7(); break; case 0xF8: opcode_CB_F8(); break; case 0xF9: opcode_CB_F9(); break; case 0xFA: opcode_CB_FA(); break; case 0xFB: opcode_CB_FB(); break; case 0xFC: opcode_CB_FC(); break; case 0xFD: opcode_CB_FD(); break; case 0xFE: opcode_CB_FE(); break; case 0xFF: opcode_CB_FF(); break;
+    }
+
+    return opcode_cycles_cb[opcode];
+}

applications/system/FlipperGB/gb/cpu.h

@@ -0,0 +1,387 @@
+#pragma once
+
+#include "address.h"
+#include "register.h"
+#include "definitions.h"
+
+class Gameboy;
+
+enum class Condition {
+    NZ,
+    Z,
+    NC,
+    C,
+};
+
+namespace rst {
+const u16 rst1 = 0x00;
+const u16 rst2 = 0x08;
+const u16 rst3 = 0x10;
+const u16 rst4 = 0x18;
+const u16 rst5 = 0x20;
+const u16 rst6 = 0x28;
+const u16 rst7 = 0x30;
+const u16 rst8 = 0x38;
+} // namespace rst
+
+namespace interrupts {
+const u16 vblank = 0x40;
+const u16 lcdc_status = 0x48;
+const u16 timer = 0x50;
+const u16 serial = 0x58;
+const u16 joypad = 0x60;
+} // namespace interrupts
+
+
+class CPU {
+public:
+    CPU(Gameboy& inGb);
+
+    /* Initialise registers to the documented DMG post-boot state
+     * (the Nintendo boot ROM is not shipped nor emulated) */
+    void init_post_boot();
+
+    auto tick() -> Cycles;
+
+    auto execute_opcode(u8 opcode, u16 opcode_pc) -> Cycles;
+
+    auto execute_normal_opcode(u8 opcode, u16 opcode_pc) -> Cycles;
+    auto execute_cb_opcode(u8 opcode, u16 opcode_pc) -> Cycles;
+
+    ByteRegister interrupt_flag;
+    ByteRegister interrupt_enabled;
+
+private:
+    void handle_interrupts();
+    auto handle_interrupt(u8 interrupt_bit, u16 interrupt_vector, u8 fired_interrupts) -> bool;
+
+    Gameboy& gb;
+
+    bool interrupts_enabled = false;
+    bool halted = false;
+
+    bool branch_taken = false;
+
+    /* Basic registers */
+    ByteRegister a, b, c, d, e, h, l;
+
+    /* 'Group' registers for operations which use two registers as a word */
+    RegisterPair af;
+    RegisterPair bc;
+    RegisterPair de;
+    RegisterPair hl;
+
+    /*
+     * Flags set dependant on the result of the last operation
+     *  0x80 - produced 0
+     *  0x40 - was a subtraction
+     *  0x20 - lower half of the byte overflowed 15
+     *  0x10 - overflowed 255 or underflowed 0 for additions/subtractions
+     */
+    FlagRegister f;
+
+    void set_flag_zero(bool set);
+    void set_flag_subtract(bool set);
+    void set_flag_half_carry(bool set);
+    void set_flag_carry(bool set);
+
+    /* Note: Not const because this also sets the 'branch_taken' member
+     * variable if a branch is taken. This allows the correct cycle
+     * count to be used */
+    auto is_condition(Condition condition) -> bool;
+
+    /* Program counter */
+    WordRegister pc;
+
+    /* Stack pointer */
+    WordRegister sp;
+
+    auto get_byte_from_pc() -> u8;
+    auto get_signed_byte_from_pc() -> s8;
+    auto get_word_from_pc() -> u16;
+
+    template <typename T> void stack_push(const T& reg);
+    template <typename T> void stack_pop(T& reg);
+
+    /* Opcode Helper Functions */
+
+    /* ADC */
+    void _opcode_adc(u8 value);
+
+    void opcode_adc();
+    void opcode_adc(const ByteRegister& reg);
+    void opcode_adc(const Address&& addr);
+
+    /* ADD */
+    void _opcode_add(u8 reg, u8 value);
+
+    void opcode_add_a();
+    void opcode_add_a(const ByteRegister& reg);
+    void opcode_add_a(const Address& addr);
+
+    void _opcode_add_hl(u16 value);
+    void opcode_add_hl(const RegisterPair& reg_pair);
+    void opcode_add_hl(const WordRegister& word_reg);
+
+    void opcode_add_sp();
+
+    void opcode_add_signed();
+
+    /* AND */
+    void _opcode_and(u8 value);
+
+    void opcode_and();
+    void opcode_and(ByteRegister& reg);
+    void opcode_and(Address&& addr);
+
+    /* BIT */
+    void _opcode_bit(u8 bit, u8 value);
+
+    void opcode_bit(u8 bit, ByteRegister& reg);
+    void opcode_bit(u8 bit, Address&& addr);
+
+    /* CALL */
+    void opcode_call();
+    void opcode_call(Condition condition);
+
+    /* CCF */
+    void opcode_ccf();
+
+    /* CP */
+    void _opcode_cp(u8 value);
+
+    void opcode_cp();
+    void opcode_cp(const ByteRegister& reg);
+    void opcode_cp(const Address& addr);
+
+    /* CPL */
+    void opcode_cpl();
+
+    /* DAA */
+    void opcode_daa();
+
+    /* DEC */
+    void opcode_dec(ByteRegister& reg);
+    void opcode_dec(RegisterPair& reg);
+    void opcode_dec(WordRegister& reg);
+    void opcode_dec(Address&& addr);
+
+    /* DI */
+    void opcode_di();
+
+    /* EI */
+    void opcode_ei();
+
+    /* INC */
+    void opcode_inc(ByteRegister& reg);
+    void opcode_inc(RegisterPair& reg);
+    void opcode_inc(WordRegister& reg);
+    void opcode_inc(Address&& addr);
+
+    /* JP */
+    void opcode_jp();
+    void opcode_jp(Condition condition);
+    void opcode_jp(const Address& addr);
+
+    /* JR */
+    void opcode_jr();
+    void opcode_jr(Condition condition);
+
+    /* HALT */
+    void opcode_halt();
+
+    /* LD */
+    void opcode_ld(ByteRegister& reg);
+    void opcode_ld(ByteRegister& reg, const ByteRegister& byte_reg);
+    void opcode_ld(ByteRegister& reg, const Address& address);
+
+    void opcode_ld(RegisterPair& reg);
+
+    void opcode_ld(WordRegister& reg);
+    void opcode_ld(WordRegister& reg, const RegisterPair& reg_pair);
+
+    void opcode_ld(const Address& address);
+    void opcode_ld(const Address& address, const ByteRegister& byte_reg);
+    void opcode_ld(const Address& address, const WordRegister& word_reg);
+
+    // (nn), A
+    void opcode_ld_to_addr(const ByteRegister& reg);
+    void opcode_ld_from_addr(ByteRegister& reg);
+
+    /* LDD */
+    auto _opcode_ldd(u8 value) -> u8;
+
+    void opcode_ldd(ByteRegister& reg, const Address& address);
+    void opcode_ldd(const Address& address, const ByteRegister& reg);
+
+    /* LDH */
+    // A, (n)
+    void opcode_ldh_into_a();
+    // (n), A
+    void opcode_ldh_into_data();
+    // (reg), A
+    void opcode_ldh_into_c();
+    // A, (reg)
+    void opcode_ldh_c_into_a();
+
+    /* LDHL */
+    void opcode_ldhl();
+
+    /* LDI */
+    void opcode_ldi(ByteRegister& reg, const Address& address);
+    void opcode_ldi(const Address& address, const ByteRegister& reg);
+
+    /* NOP */
+    void opcode_nop();
+
+    /* OR */
+    void _opcode_or(u8 value);
+
+    void opcode_or();
+    void opcode_or(const ByteRegister& reg);
+    void opcode_or(const Address& addr);
+
+    /* POP */
+    void opcode_pop(RegisterPair& reg);
+
+    /* PUSH */
+    void opcode_push(const RegisterPair& reg);
+
+    /* RES */
+    void opcode_res(u8 bit, ByteRegister& reg);
+    void opcode_res(u8 bit, Address&& addr);
+
+    /* RET */
+    void opcode_ret();
+    void opcode_ret(Condition condition);
+
+    /* RETI */
+    void opcode_reti();
+
+    /* RL */
+    auto _opcode_rl(u8 value) -> u8;
+
+    void opcode_rla();
+    void opcode_rl(ByteRegister& reg);
+    void opcode_rl(Address&& addr);
+
+    /* RLC */
+    auto _opcode_rlc(u8 value) -> u8;
+
+    void opcode_rlca();
+    void opcode_rlc(ByteRegister& reg);
+    void opcode_rlc(Address&& addr);
+
+    /* RR */
+    auto _opcode_rr(u8 value) -> u8;
+
+    void opcode_rra();
+    void opcode_rr(ByteRegister& reg);
+    void opcode_rr(Address&& addr);
+
+    /* RRC */
+    auto _opcode_rrc(u8 value) -> u8;
+
+    void opcode_rrca();
+    void opcode_rrc(ByteRegister& reg);
+    void opcode_rrc(Address&& addr);
+
+    /* RST */
+    void opcode_rst(u8 offset);
+
+    /* SBC */
+    void _opcode_sbc(u8 value);
+
+    void opcode_sbc();
+    void opcode_sbc(ByteRegister& reg);
+    void opcode_sbc(Address&& addr);
+
+    /* SCF */
+    void opcode_scf();
+
+    /* SET */
+    void opcode_set(u8 bit, ByteRegister& reg);
+    void opcode_set(u8 bit, Address&& addr);
+
+    /* SLA */
+    auto _opcode_sla(u8 value) -> u8;
+
+    void opcode_sla(ByteRegister& reg);
+    void opcode_sla(Address&& addr);
+
+    /* SRA */
+    auto _opcode_sra(u8 value) -> u8;
+
+    void opcode_sra(ByteRegister& reg);
+    void opcode_sra(Address&& addr);
+
+    /* SRL */
+    auto _opcode_srl(u8 value) -> u8;
+
+    void opcode_srl(ByteRegister& reg);
+    void opcode_srl(Address&& addr);
+
+    /* STOP */
+    void opcode_stop();
+
+    /* SUB */
+    void _opcode_sub(u8 value);
+
+    void opcode_sub();
+    void opcode_sub(ByteRegister& reg);
+    void opcode_sub(Address&& addr);
+
+    /* SWAP */
+    auto _opcode_swap(u8 value) -> u8;
+
+    void opcode_swap(ByteRegister& reg);
+    void opcode_swap(Address&& addr);
+
+    /* XOR */
+    void _opcode_xor(u8 value);
+
+    void opcode_xor();
+    void opcode_xor(const ByteRegister& reg);
+    void opcode_xor(const Address& addr);
+
+
+    /* clang-format off */
+    /* Opcodes */
+    void opcode_00(); void opcode_01(); void opcode_02(); void opcode_03(); void opcode_04(); void opcode_05(); void opcode_06(); void opcode_07(); void opcode_08(); void opcode_09(); void opcode_0A(); void opcode_0B(); void opcode_0C(); void opcode_0D(); void opcode_0E(); void opcode_0F();
+    void opcode_10(); void opcode_11(); void opcode_12(); void opcode_13(); void opcode_14(); void opcode_15(); void opcode_16(); void opcode_17(); void opcode_18(); void opcode_19(); void opcode_1A(); void opcode_1B(); void opcode_1C(); void opcode_1D(); void opcode_1E(); void opcode_1F();
+    void opcode_20(); void opcode_21(); void opcode_22(); void opcode_23(); void opcode_24(); void opcode_25(); void opcode_26(); void opcode_27(); void opcode_28(); void opcode_29(); void opcode_2A(); void opcode_2B(); void opcode_2C(); void opcode_2D(); void opcode_2E(); void opcode_2F();
+    void opcode_30(); void opcode_31(); void opcode_32(); void opcode_33(); void opcode_34(); void opcode_35(); void opcode_36(); void opcode_37(); void opcode_38(); void opcode_39(); void opcode_3A(); void opcode_3B(); void opcode_3C(); void opcode_3D(); void opcode_3E(); void opcode_3F();
+    void opcode_40(); void opcode_41(); void opcode_42(); void opcode_43(); void opcode_44(); void opcode_45(); void opcode_46(); void opcode_47(); void opcode_48(); void opcode_49(); void opcode_4A(); void opcode_4B(); void opcode_4C(); void opcode_4D(); void opcode_4E(); void opcode_4F();
+    void opcode_50(); void opcode_51(); void opcode_52(); void opcode_53(); void opcode_54(); void opcode_55(); void opcode_56(); void opcode_57(); void opcode_58(); void opcode_59(); void opcode_5A(); void opcode_5B(); void opcode_5C(); void opcode_5D(); void opcode_5E(); void opcode_5F();
+    void opcode_60(); void opcode_61(); void opcode_62(); void opcode_63(); void opcode_64(); void opcode_65(); void opcode_66(); void opcode_67(); void opcode_68(); void opcode_69(); void opcode_6A(); void opcode_6B(); void opcode_6C(); void opcode_6D(); void opcode_6E(); void opcode_6F();
+    void opcode_70(); void opcode_71(); void opcode_72(); void opcode_73(); void opcode_74(); void opcode_75(); void opcode_76(); void opcode_77(); void opcode_78(); void opcode_79(); void opcode_7A(); void opcode_7B(); void opcode_7C(); void opcode_7D(); void opcode_7E(); void opcode_7F();
+    void opcode_80(); void opcode_81(); void opcode_82(); void opcode_83(); void opcode_84(); void opcode_85(); void opcode_86(); void opcode_87(); void opcode_88(); void opcode_89(); void opcode_8A(); void opcode_8B(); void opcode_8C(); void opcode_8D(); void opcode_8E(); void opcode_8F();
+    void opcode_90(); void opcode_91(); void opcode_92(); void opcode_93(); void opcode_94(); void opcode_95(); void opcode_96(); void opcode_97(); void opcode_98(); void opcode_99(); void opcode_9A(); void opcode_9B(); void opcode_9C(); void opcode_9D(); void opcode_9E(); void opcode_9F();
+    void opcode_A0(); void opcode_A1(); void opcode_A2(); void opcode_A3(); void opcode_A4(); void opcode_A5(); void opcode_A6(); void opcode_A7(); void opcode_A8(); void opcode_A9(); void opcode_AA(); void opcode_AB(); void opcode_AC(); void opcode_AD(); void opcode_AE(); void opcode_AF();
+    void opcode_B0(); void opcode_B1(); void opcode_B2(); void opcode_B3(); void opcode_B4(); void opcode_B5(); void opcode_B6(); void opcode_B7(); void opcode_B8(); void opcode_B9(); void opcode_BA(); void opcode_BB(); void opcode_BC(); void opcode_BD(); void opcode_BE(); void opcode_BF();
+    void opcode_C0(); void opcode_C1(); void opcode_C2(); void opcode_C3(); void opcode_C4(); void opcode_C5(); void opcode_C6(); void opcode_C7(); void opcode_C8(); void opcode_C9(); void opcode_CA(); void opcode_CB(); void opcode_CC(); void opcode_CD(); void opcode_CE(); void opcode_CF();
+    void opcode_D0(); void opcode_D1(); void opcode_D2(); void opcode_D3(); void opcode_D4(); void opcode_D5(); void opcode_D6(); void opcode_D7(); void opcode_D8(); void opcode_D9(); void opcode_DA(); void opcode_DB(); void opcode_DC(); void opcode_DD(); void opcode_DE(); void opcode_DF();
+    void opcode_E0(); void opcode_E1(); void opcode_E2(); void opcode_E3(); void opcode_E4(); void opcode_E5(); void opcode_E6(); void opcode_E7(); void opcode_E8(); void opcode_E9(); void opcode_EA(); void opcode_EB(); void opcode_EC(); void opcode_ED(); void opcode_EE(); void opcode_EF();
+    void opcode_F0(); void opcode_F1(); void opcode_F2(); void opcode_F3(); void opcode_F4(); void opcode_F5(); void opcode_F6(); void opcode_F7(); void opcode_F8(); void opcode_F9(); void opcode_FA(); void opcode_FB(); void opcode_FC(); void opcode_FD(); void opcode_FE(); void opcode_FF();
+
+    /* CB Opcodes */
+    void opcode_CB_00(); void opcode_CB_01(); void opcode_CB_02(); void opcode_CB_03(); void opcode_CB_04(); void opcode_CB_05(); void opcode_CB_06(); void opcode_CB_07(); void opcode_CB_08(); void opcode_CB_09(); void opcode_CB_0A(); void opcode_CB_0B(); void opcode_CB_0C(); void opcode_CB_0D(); void opcode_CB_0E(); void opcode_CB_0F();
+    void opcode_CB_10(); void opcode_CB_11(); void opcode_CB_12(); void opcode_CB_13(); void opcode_CB_14(); void opcode_CB_15(); void opcode_CB_16(); void opcode_CB_17(); void opcode_CB_18(); void opcode_CB_19(); void opcode_CB_1A(); void opcode_CB_1B(); void opcode_CB_1C(); void opcode_CB_1D(); void opcode_CB_1E(); void opcode_CB_1F();
+    void opcode_CB_20(); void opcode_CB_21(); void opcode_CB_22(); void opcode_CB_23(); void opcode_CB_24(); void opcode_CB_25(); void opcode_CB_26(); void opcode_CB_27(); void opcode_CB_28(); void opcode_CB_29(); void opcode_CB_2A(); void opcode_CB_2B(); void opcode_CB_2C(); void opcode_CB_2D(); void opcode_CB_2E(); void opcode_CB_2F();
+    void opcode_CB_30(); void opcode_CB_31(); void opcode_CB_32(); void opcode_CB_33(); void opcode_CB_34(); void opcode_CB_35(); void opcode_CB_36(); void opcode_CB_37(); void opcode_CB_38(); void opcode_CB_39(); void opcode_CB_3A(); void opcode_CB_3B(); void opcode_CB_3C(); void opcode_CB_3D(); void opcode_CB_3E(); void opcode_CB_3F();
+    void opcode_CB_40(); void opcode_CB_41(); void opcode_CB_42(); void opcode_CB_43(); void opcode_CB_44(); void opcode_CB_45(); void opcode_CB_46(); void opcode_CB_47(); void opcode_CB_48(); void opcode_CB_49(); void opcode_CB_4A(); void opcode_CB_4B(); void opcode_CB_4C(); void opcode_CB_4D(); void opcode_CB_4E(); void opcode_CB_4F();
+    void opcode_CB_50(); void opcode_CB_51(); void opcode_CB_52(); void opcode_CB_53(); void opcode_CB_54(); void opcode_CB_55(); void opcode_CB_56(); void opcode_CB_57(); void opcode_CB_58(); void opcode_CB_59(); void opcode_CB_5A(); void opcode_CB_5B(); void opcode_CB_5C(); void opcode_CB_5D(); void opcode_CB_5E(); void opcode_CB_5F();
+    void opcode_CB_60(); void opcode_CB_61(); void opcode_CB_62(); void opcode_CB_63(); void opcode_CB_64(); void opcode_CB_65(); void opcode_CB_66(); void opcode_CB_67(); void opcode_CB_68(); void opcode_CB_69(); void opcode_CB_6A(); void opcode_CB_6B(); void opcode_CB_6C(); void opcode_CB_6D(); void opcode_CB_6E(); void opcode_CB_6F();
+    void opcode_CB_70(); void opcode_CB_71(); void opcode_CB_72(); void opcode_CB_73(); void opcode_CB_74(); void opcode_CB_75(); void opcode_CB_76(); void opcode_CB_77(); void opcode_CB_78(); void opcode_CB_79(); void opcode_CB_7A(); void opcode_CB_7B(); void opcode_CB_7C(); void opcode_CB_7D(); void opcode_CB_7E(); void opcode_CB_7F();
+    void opcode_CB_80(); void opcode_CB_81(); void opcode_CB_82(); void opcode_CB_83(); void opcode_CB_84(); void opcode_CB_85(); void opcode_CB_86(); void opcode_CB_87(); void opcode_CB_88(); void opcode_CB_89(); void opcode_CB_8A(); void opcode_CB_8B(); void opcode_CB_8C(); void opcode_CB_8D(); void opcode_CB_8E(); void opcode_CB_8F();
+    void opcode_CB_90(); void opcode_CB_91(); void opcode_CB_92(); void opcode_CB_93(); void opcode_CB_94(); void opcode_CB_95(); void opcode_CB_96(); void opcode_CB_97(); void opcode_CB_98(); void opcode_CB_99(); void opcode_CB_9A(); void opcode_CB_9B(); void opcode_CB_9C(); void opcode_CB_9D(); void opcode_CB_9E(); void opcode_CB_9F();
+    void opcode_CB_A0(); void opcode_CB_A1(); void opcode_CB_A2(); void opcode_CB_A3(); void opcode_CB_A4(); void opcode_CB_A5(); void opcode_CB_A6(); void opcode_CB_A7(); void opcode_CB_A8(); void opcode_CB_A9(); void opcode_CB_AA(); void opcode_CB_AB(); void opcode_CB_AC(); void opcode_CB_AD(); void opcode_CB_AE(); void opcode_CB_AF();
+    void opcode_CB_B0(); void opcode_CB_B1(); void opcode_CB_B2(); void opcode_CB_B3(); void opcode_CB_B4(); void opcode_CB_B5(); void opcode_CB_B6(); void opcode_CB_B7(); void opcode_CB_B8(); void opcode_CB_B9(); void opcode_CB_BA(); void opcode_CB_BB(); void opcode_CB_BC(); void opcode_CB_BD(); void opcode_CB_BE(); void opcode_CB_BF();
+    void opcode_CB_C0(); void opcode_CB_C1(); void opcode_CB_C2(); void opcode_CB_C3(); void opcode_CB_C4(); void opcode_CB_C5(); void opcode_CB_C6(); void opcode_CB_C7(); void opcode_CB_C8(); void opcode_CB_C9(); void opcode_CB_CA(); void opcode_CB_CB(); void opcode_CB_CC(); void opcode_CB_CD(); void opcode_CB_CE(); void opcode_CB_CF();
+    void opcode_CB_D0(); void opcode_CB_D1(); void opcode_CB_D2(); void opcode_CB_D3(); void opcode_CB_D4(); void opcode_CB_D5(); void opcode_CB_D6(); void opcode_CB_D7(); void opcode_CB_D8(); void opcode_CB_D9(); void opcode_CB_DA(); void opcode_CB_DB(); void opcode_CB_DC(); void opcode_CB_DD(); void opcode_CB_DE(); void opcode_CB_DF();
+    void opcode_CB_E0(); void opcode_CB_E1(); void opcode_CB_E2(); void opcode_CB_E3(); void opcode_CB_E4(); void opcode_CB_E5(); void opcode_CB_E6(); void opcode_CB_E7(); void opcode_CB_E8(); void opcode_CB_E9(); void opcode_CB_EA(); void opcode_CB_EB(); void opcode_CB_EC(); void opcode_CB_ED(); void opcode_CB_EE(); void opcode_CB_EF();
+    void opcode_CB_F0(); void opcode_CB_F1(); void opcode_CB_F2(); void opcode_CB_F3(); void opcode_CB_F4(); void opcode_CB_F5(); void opcode_CB_F6(); void opcode_CB_F7(); void opcode_CB_F8(); void opcode_CB_F9(); void opcode_CB_FA(); void opcode_CB_FB(); void opcode_CB_FC(); void opcode_CB_FD(); void opcode_CB_FE(); void opcode_CB_FF();
+    /* clang-format on */
+
+    friend class Debugger;
+};

applications/system/FlipperGB/gb/definitions.h

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <cstdint>
+
+using uint = unsigned int;
+
+using u8 = uint8_t;
+using u16 = uint16_t;
+using u32 = uint32_t;
+using s8 = int8_t;
+using s16 = uint16_t; /* kept as upstream (unused alias) */
+
+struct Noncopyable {
+    auto operator=(const Noncopyable&) -> Noncopyable& = delete;
+    Noncopyable(const Noncopyable&) = delete;
+    Noncopyable() = default;
+    ~Noncopyable() = default;
+};
+
+template <typename... T> inline void unused(T&&...) {}
+
+/* Logging compiled out for the embedded target */
+#define log_error(...) ((void)0)
+#define log_warn(...) ((void)0)
+#define log_info(...) ((void)0)
+#define log_debug(...) ((void)0)
+#define log_trace(...) ((void)0)
+#define log_unimplemented(...) ((void)0)
+
+/* Fatal errors: platform provides the handler (never returns) */
+extern "C" [[noreturn]] void gb_fatal(const char* msg);
+#define fatal_error(...) gb_fatal("gb core fatal error")
+
+const uint GAMEBOY_WIDTH = 160;
+const uint GAMEBOY_HEIGHT = 144;
+
+const int CLOCK_RATE = 4194304;
+
+/* Shades are plain bytes now: 0=White .. 3=Black */
+using Shade = u8;
+const Shade SHADE_WHITE = 0;
+const Shade SHADE_LIGHT = 1;
+const Shade SHADE_DARK = 2;
+const Shade SHADE_BLACK = 3;
+
+struct Palette {
+    Shade color0 = 0;
+    Shade color1 = 1;
+    Shade color2 = 2;
+    Shade color3 = 3;
+};
+
+class Cycles {
+public:
+    Cycles(uint nCycles) : cycles(nCycles) {}
+    const uint cycles;
+};

applications/system/FlipperGB/gb/framebuffer.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include "definitions.h"
+
+/* Packed 2 bits-per-pixel framebuffer (the original stored one 4-byte enum
+ * per pixel = 92 KB).
+ *
+ * GB_FB_ROWS storage rows are kept (default: all 144 = 5.7 KB). The Flipper
+ * build compiles with GB_FB_ROWS=64: only the 64 scanlines that survive the
+ * 144 -> 64 downscale are stored (2.5 KB, saving 3.2 KB of always-resident
+ * RAM). row_slot[] maps screen y -> storage slot; rows without a slot are
+ * write-ignored / read-as-white, and the render row mask already prevents
+ * the PPU from touching them anyway. */
+#ifndef GB_FB_ROWS
+#define GB_FB_ROWS GAMEBOY_HEIGHT
+#endif
+
+class FrameBuffer {
+public:
+    FrameBuffer() {
+        for(uint y = 0; y < GAMEBOY_HEIGHT; y++)
+            row_slot[y] = (y < GB_FB_ROWS) ? static_cast<u8>(y) : NO_ROW;
+    }
+
+    /* Compact storage to exactly the rows enabled in mask. Storage slots
+     * are assigned in ascending y order, so the frontend's n-th displayed
+     * row lives in slot n. No-op when every row fits (host build). */
+    void set_row_map(const u8* mask) {
+        if(!mask || GB_FB_ROWS >= GAMEBOY_HEIGHT) return;
+        uint slot = 0;
+        for(uint y = 0; y < GAMEBOY_HEIGHT; y++) {
+            if(mask[y] && slot < GB_FB_ROWS)
+                row_slot[y] = static_cast<u8>(slot++);
+            else
+                row_slot[y] = NO_ROW;
+        }
+    }
+
+    void set_pixel(uint x, uint y, Shade shade) {
+        uint slot = row_slot[y];
+        if(slot == NO_ROW) return;
+        uint i = slot * GAMEBOY_WIDTH + x;
+        uint byte = i >> 2;
+        uint shift = (i & 3) * 2;
+        buf[byte] = static_cast<u8>((buf[byte] & ~(0x3 << shift)) | (shade << shift));
+    }
+
+    auto get_pixel(uint x, uint y) const -> Shade {
+        uint slot = row_slot[y];
+        if(slot == NO_ROW) return 0;
+        uint i = slot * GAMEBOY_WIDTH + x;
+        return static_cast<Shade>((buf[i >> 2] >> ((i & 3) * 2)) & 0x3);
+    }
+
+    void reset() {
+        for(uint i = 0; i < sizeof(buf); i++)
+            buf[i] = 0;
+    }
+
+    /* Raw packed 2bpp storage (4 pixels per byte, LSB first), slot-major:
+     * storage slot s starts at bit offset s * GAMEBOY_WIDTH * 2. */
+    auto raw() const -> const u8* { return buf; }
+
+private:
+    static const u8 NO_ROW = 0xFF;
+
+    u8 buf[GAMEBOY_WIDTH * GB_FB_ROWS / 4] = {};
+    u8 row_slot[GAMEBOY_HEIGHT];
+};

applications/system/FlipperGB/gb/gameboy.cc

@@ -0,0 +1,67 @@
+#include "gameboy.h"
+
+Gameboy::Gameboy(
+    const u8* bank0,
+    uint rom_bank_count,
+    MBCType mbc,
+    u8* cart_ram,
+    u32 cart_ram_size,
+    RomBankProvider provider,
+    void* provider_ctx)
+    : cpu(*this)
+    , video(*this)
+    , mmu(*this)
+    , timer(*this) {
+    cartridge.init(bank0, rom_bank_count, mbc, cart_ram, cart_ram_size, provider, provider_ctx);
+
+    video.register_vblank_callback(&Gameboy::vblank_trampoline, this);
+
+    /* The DMG boot ROM is not shipped with this emulator. The CPU and IO
+     * registers are initialised directly to the well-documented post-boot
+     * state instead. */
+    cpu.init_post_boot();
+
+    mmu.write(0xFF26, 0x80); /* NR52: APU powered on (post-boot state) */
+    mmu.write(0xFF25, 0xF3); /* NR51: all channels routed */
+    mmu.write(0xFF24, 0x77); /* NR50: max master volume */
+    mmu.write(0xFF40, 0x91); /* LCDC */
+    mmu.write(0xFF42, 0x00); /* SCY */
+    mmu.write(0xFF43, 0x00); /* SCX */
+    mmu.write(0xFF45, 0x00); /* LYC */
+    mmu.write(0xFF47, 0xFC); /* BGP */
+    mmu.write(0xFF48, 0xFF); /* OBP0 */
+    mmu.write(0xFF49, 0xFF); /* OBP1 */
+    mmu.write(0xFF4A, 0x00); /* WY */
+    mmu.write(0xFF4B, 0x00); /* WX */
+}
+
+void Gameboy::vblank_trampoline(void* ctx) {
+    Gameboy* self = static_cast<Gameboy*>(ctx);
+    if(self->user_frame_cb) self->user_frame_cb(self->user_frame_ctx);
+    self->frame_done = true;
+}
+
+void Gameboy::button_pressed(GbButton button) {
+    input.button_pressed(button);
+    /* Request the joypad interrupt (missing upstream); mainly wakes
+     * games waiting in HALT/STOP for input. */
+    cpu.interrupt_flag.set_bit_to(4, true);
+}
+
+void Gameboy::button_released(GbButton button) {
+    input.button_released(button);
+}
+
+void Gameboy::run_to_vblank() {
+    frame_done = false;
+    while(!frame_done) {
+        tick();
+    }
+}
+
+void Gameboy::tick() {
+    auto cycles = cpu.tick();
+    video.tick(cycles);
+    timer.tick(cycles.cycles);
+    apu.tick(cycles.cycles);
+}

applications/system/FlipperGB/gb/gameboy.h

@@ -0,0 +1,73 @@
+#pragma once
+
+#include "input.h"
+#include "cpu.h"
+#include "video.h"
+#include "timer.h"
+#include "mmu.h"
+#include "cartridge.h"
+#include "apu.h"
+
+class Gameboy {
+public:
+    /* bank0: pointer to the first 16 KB of ROM (stays resident).
+     * provider: returns pointers to 16 KB switchable banks. */
+    Gameboy(
+        const u8* bank0,
+        uint rom_bank_count,
+        MBCType mbc,
+        u8* cart_ram,
+        u32 cart_ram_size,
+        RomBankProvider provider,
+        void* provider_ctx);
+
+    /* Runs the emulator until the next vblank (one full frame). */
+    void run_to_vblank();
+
+    /* Called on every vblank BEFORE the framebuffer is cleared for the next
+     * frame: this is where the frontend must convert/copy the image. */
+    void set_frame_callback(void (*cb)(void*), void* ctx) {
+        user_frame_cb = cb;
+        user_frame_ctx = ctx;
+    }
+
+    void button_pressed(GbButton button);
+    void button_released(GbButton button);
+
+    void set_skip_render(bool skip) { video.skip_render = skip; }
+
+    /* Optional display-line mask (see Video::row_mask). The array must stay
+     * valid for the lifetime of the emulator. */
+    void set_row_mask(const u8* mask) { video.set_row_mask(mask); }
+    auto get_framebuffer() const -> const FrameBuffer& { return video.get_framebuffer(); }
+
+    auto get_cartridge_ram() -> u8* { return cartridge.get_ram(); }
+    auto get_cartridge_ram_size() const -> u32 { return cartridge.get_ram_size(); }
+
+    Cartridge cartridge;
+
+    CPU cpu;
+    friend class CPU;
+
+    Video video;
+    friend class Video;
+
+    MMU mmu;
+    friend class MMU;
+
+    Timer timer;
+    friend class Timer;
+
+    Apu apu;
+
+    Input input;
+
+private:
+    void tick();
+
+    static void vblank_trampoline(void* ctx);
+    volatile bool frame_done = false;
+
+    void (*user_frame_cb)(void*) = nullptr;
+    void* user_frame_ctx = nullptr;
+};

applications/system/FlipperGB/gb/input.cc

@@ -0,0 +1,54 @@
+#include "input.h"
+
+#include "bitwise.h"
+
+void Input::button_pressed(GbButton button) {
+    set_button(button, true);
+}
+
+void Input::button_released(GbButton button) {
+    set_button(button, false);
+}
+
+void Input::set_button(GbButton button, bool set) {
+    if (button == GbButton::Up) { up = set; }
+    if (button == GbButton::Down) { down = set; }
+    if (button == GbButton::Left) { left = set; }
+    if (button == GbButton::Right) { right = set; }
+    if (button == GbButton::A) { a = set; }
+    if (button == GbButton::B) { b = set; }
+    if (button == GbButton::Select) { select = set; }
+    if (button == GbButton::Start) { start = set; }
+}
+
+void Input::write(u8 set) {
+    using bitwise::check_bit;
+
+    direction_switch = !check_bit(set, 4);
+    button_switch = !check_bit(set, 5);
+}
+
+auto Input::get_input() const -> u8 {
+    using bitwise::set_bit_to;
+
+    u8 buttons = 0b1111;
+
+    if (direction_switch) {
+        buttons = set_bit_to(buttons, 0, !right);
+        buttons = set_bit_to(buttons, 1, !left);
+        buttons = set_bit_to(buttons, 2, !up);
+        buttons = set_bit_to(buttons, 3, !down);
+    }
+
+    if (button_switch) {
+        buttons = set_bit_to(buttons, 0, !a);
+        buttons = set_bit_to(buttons, 1, !b);
+        buttons = set_bit_to(buttons, 2, !select);
+        buttons = set_bit_to(buttons, 3, !start);
+    }
+
+    buttons = set_bit_to(buttons, 4, !direction_switch);
+    buttons = set_bit_to(buttons, 5, !button_switch);
+
+    return buttons;
+}

applications/system/FlipperGB/gb/input.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include "definitions.h"
+
+enum class GbButton {
+    Up,
+    Down,
+    Left,
+    Right,
+    A,
+    B,
+    Select,
+    Start,
+};
+
+class Input {
+public:
+    void button_pressed(GbButton button);
+    void button_released(GbButton button);
+    void write(u8 set);
+
+    auto get_input() const -> u8;
+
+private:
+    void set_button(GbButton button, bool set);
+
+    bool up = false;
+    bool down = false;
+    bool left = false;
+    bool right = false;
+    bool a = false;
+    bool b = false;
+    bool select = false;
+    bool start = false;
+
+    bool button_switch = false;
+    bool direction_switch = false;
+};

applications/system/FlipperGB/gb/mmu.cc

@@ -0,0 +1,274 @@
+#include "mmu.h"
+#include "gameboy.h"
+#include "input.h"
+#include "timer.h"
+#include "cpu.h"
+#include "video.h"
+
+void (*gb_serial_hook)(u8 byte) = nullptr;
+
+MMU::MMU(Gameboy& inGb)
+    : gb(inGb) {
+}
+
+auto MMU::read(const Address& address) const -> u8 {
+    u16 a = address.value();
+
+    /* Cartridge ROM (boot ROM is skipped: CPU starts with post-boot state) */
+    if(a < 0x8000) return gb.cartridge.read(a);
+
+    /* VRAM */
+    if(a < 0xA000) return gb.video.vram_read(static_cast<u16>(a - 0x8000));
+
+    /* External (cartridge) RAM */
+    if(a < 0xC000) return gb.cartridge.read(a);
+
+    /* Internal work RAM */
+    if(a < 0xE000) return work_ram[a - 0xC000];
+
+    /* Echo RAM */
+    if(a < 0xFE00) return work_ram[a - 0xE000];
+
+    /* OAM */
+    if(a < 0xFEA0) return oam_ram[a - 0xFE00];
+
+    /* Unusable region */
+    if(a < 0xFF00) return 0xFF;
+
+    /* Mapped IO */
+    if(a < 0xFF80) return read_io(address);
+
+    /* Zero page RAM */
+    if(a < 0xFFFF) return high_ram[a - 0xFF80];
+
+    /* Interrupt enable register */
+    return gb.cpu.interrupt_enabled.value();
+}
+
+void MMU::write(const Address& address, u8 byte) {
+    u16 a = address.value();
+
+    if(a < 0x8000) {
+        gb.cartridge.write(a, byte);
+        return;
+    }
+
+    if(a < 0xA000) {
+        gb.video.vram_write(static_cast<u16>(a - 0x8000), byte);
+        return;
+    }
+
+    if(a < 0xC000) {
+        gb.cartridge.write(a, byte);
+        return;
+    }
+
+    if(a < 0xE000) {
+        work_ram[a - 0xC000] = byte;
+        return;
+    }
+
+    if(a < 0xFE00) {
+        work_ram[a - 0xE000] = byte;
+        return;
+    }
+
+    if(a < 0xFEA0) {
+        oam_ram[a - 0xFE00] = byte;
+        return;
+    }
+
+    if(a < 0xFF00) return; /* unusable */
+
+    if(a < 0xFF80) {
+        write_io(address, byte);
+        return;
+    }
+
+    if(a < 0xFFFF) {
+        high_ram[a - 0xFF80] = byte;
+        return;
+    }
+
+    gb.cpu.interrupt_enabled.set(byte);
+}
+
+auto MMU::read_io(const Address& address) const -> u8 {
+    u16 a = address.value();
+
+    /* Sound registers + wave RAM */
+    if(a >= 0xFF10 && a <= 0xFF3F) return gb.apu.read(a);
+
+    switch(address.value()) {
+    case 0xFF00:
+        return gb.input.get_input();
+
+    case 0xFF01:
+        return serial_data;
+
+    case 0xFF02:
+        return 0xFF;
+
+    case 0xFF04:
+        return gb.timer.get_divider();
+
+    case 0xFF05:
+        return gb.timer.get_timer();
+
+    case 0xFF06:
+        return gb.timer.get_timer_modulo();
+
+    case 0xFF07:
+        return gb.timer.get_timer_control();
+
+    case 0xFF0F:
+        return gb.cpu.interrupt_flag.value();
+
+    case 0xFF40:
+        return gb.video.control_byte;
+
+    case 0xFF41:
+        return gb.video.lcd_status.value();
+
+    case 0xFF42:
+        return gb.video.scroll_y.value();
+
+    case 0xFF43:
+        return gb.video.scroll_x.value();
+
+    case 0xFF44:
+        return gb.video.line.value();
+
+    case 0xFF45:
+        return gb.video.ly_compare.value();
+
+    case 0xFF47:
+        return gb.video.bg_palette.value();
+
+    case 0xFF48:
+        return gb.video.sprite_palette_0.value();
+
+    case 0xFF49:
+        return gb.video.sprite_palette_1.value();
+
+    case 0xFF4A:
+        return gb.video.window_y.value();
+
+    case 0xFF4B:
+        return gb.video.window_x.value();
+
+    case 0xFF4D: /* CGB speed switch: report normal speed */
+        return 0x00;
+
+    default:
+        /* Audio registers, CGB registers and unmapped IO */
+        return 0xFF;
+    }
+}
+
+void MMU::write_io(const Address& address, u8 byte) {
+    u16 a = address.value();
+
+    /* Sound registers + wave RAM */
+    if(a >= 0xFF10 && a <= 0xFF3F) {
+        gb.apu.write(a, byte);
+        return;
+    }
+
+    switch(address.value()) {
+    case 0xFF00:
+        gb.input.write(byte);
+        return;
+
+    case 0xFF01:
+        serial_data = byte;
+        return;
+
+    case 0xFF02:
+        /* Serial control: transfer start with internal clock -> deliver
+         * the byte immediately (enough for link-less games and for the
+         * Blargg test ROMs which print through the serial port) */
+        if((byte & 0x81) == 0x81 && gb_serial_hook) gb_serial_hook(serial_data);
+        return;
+
+    case 0xFF04:
+        gb.timer.reset_divider();
+        return;
+
+    case 0xFF05:
+        gb.timer.set_timer(byte);
+        return;
+
+    case 0xFF06:
+        gb.timer.set_timer_modulo(byte);
+        return;
+
+    case 0xFF07:
+        gb.timer.set_timer_control(byte);
+        return;
+
+    case 0xFF0F:
+        gb.cpu.interrupt_flag.set(byte);
+        return;
+
+    case 0xFF40:
+        gb.video.control_byte = byte;
+        return;
+
+    case 0xFF41:
+        gb.video.lcd_status.set(byte);
+        return;
+
+    case 0xFF42:
+        gb.video.scroll_y.set(byte);
+        return;
+
+    case 0xFF43:
+        gb.video.scroll_x.set(byte);
+        return;
+
+    case 0xFF44:
+        gb.video.line.set(0x0);
+        return;
+
+    case 0xFF45:
+        gb.video.ly_compare.set(byte);
+        return;
+
+    case 0xFF46:
+        dma_transfer(byte);
+        return;
+
+    case 0xFF47:
+        gb.video.bg_palette.set(byte);
+        return;
+
+    case 0xFF48:
+        gb.video.sprite_palette_0.set(byte);
+        return;
+
+    case 0xFF49:
+        gb.video.sprite_palette_1.set(byte);
+        return;
+
+    case 0xFF4A:
+        gb.video.window_y.set(byte);
+        return;
+
+    case 0xFF4B:
+        gb.video.window_x.set(byte);
+        return;
+
+    default:
+        /* Audio registers, CGB registers and unmapped IO: ignored */
+        return;
+    }
+}
+
+void MMU::dma_transfer(u8 byte) {
+    u16 start_address = static_cast<u16>(byte) * 0x100;
+
+    for(u8 i = 0x0; i <= 0x9F; i++) {
+        oam_ram[i] = read(static_cast<u16>(start_address + i));
+    }
+}

applications/system/FlipperGB/gb/mmu.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "address.h"
+#include "definitions.h"
+
+class Gameboy;
+
+/* Serial output hook, used by the host test harness to capture Blargg test
+ * ROM output. Null on the Flipper build. */
+extern "C" {
+extern void (*gb_serial_hook)(u8 byte);
+}
+
+class MMU {
+public:
+    MMU(Gameboy& inGb);
+
+    auto read(const Address& address) const -> u8;
+    void write(const Address& address, u8 byte);
+
+private:
+    auto read_io(const Address& address) const -> u8;
+    void write_io(const Address& address, u8 byte);
+    void dma_transfer(u8 byte);
+
+    Gameboy& gb;
+
+    u8 work_ram[0x2000] = {}; /* DMG: 8 KB (was 32 KB upstream) */
+    u8 oam_ram[0xA0] = {};
+    u8 high_ram[0x80] = {};
+
+    u8 serial_data = 0;
+
+    friend class Video;
+};

applications/system/FlipperGB/gb/opcode_cycles.h

@@ -0,0 +1,61 @@
+#pragma once
+/* clang-format off */
+
+#include <array>
+
+const std::array<u8, 256> opcode_cycles = {
+    1, 3, 2, 2, 1, 1, 2, 1, 5, 2, 2, 2, 1, 1, 2, 1,
+    1, 3, 2, 2, 1, 1, 2, 1, 3, 2, 2, 2, 1, 1, 2, 1,
+    2, 3, 2, 2, 1, 1, 2, 1, 2, 2, 2, 2, 1, 1, 2, 1,
+    2, 3, 2, 2, 3, 3, 3, 1, 2, 2, 2, 2, 1, 1, 2, 1,
+    1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1,
+    1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1,
+    1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1,
+    2, 2, 2, 2, 2, 2, 1, 2, 1, 1, 1, 1, 1, 1, 2, 1,
+    1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1,
+    1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1,
+    1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1,
+    1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1,
+    2, 3, 3, 4, 3, 4, 2, 4, 2, 4, 3, 0, 3, 6, 2, 4,
+    2, 3, 3, 0, 3, 4, 2, 4, 2, 4, 3, 0, 3, 0, 2, 4,
+    3, 3, 2, 0, 0, 4, 2, 4, 4, 1, 4, 0, 0, 0, 2, 4,
+    3, 3, 2, 1, 0, 4, 2, 4, 3, 2, 4, 1, 0, 0, 2, 4
+};
+
+const std::array<u8, 256> opcode_cycles_branched = {
+    1, 3, 2, 2, 1, 1, 2, 1, 5, 2, 2, 2, 1, 1, 2, 1,
+    1, 3, 2, 2, 1, 1, 2, 1, 3, 2, 2, 2, 1, 1, 2, 1,
+    3, 3, 2, 2, 1, 1, 2, 1, 3, 2, 2, 2, 1, 1, 2, 1,
+    3, 3, 2, 2, 3, 3, 3, 1, 3, 2, 2, 2, 1, 1, 2, 1,
+    1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1,
+    1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1,
+    1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1,
+    2, 2, 2, 2, 2, 2, 1, 2, 1, 1, 1, 1, 1, 1, 2, 1,
+    1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1,
+    1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1,
+    1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1,
+    1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1,
+    5, 3, 4, 4, 6, 4, 2, 4, 5, 4, 4, 0, 6, 6, 2, 4,
+    5, 3, 4, 0, 6, 4, 2, 4, 5, 4, 4, 0, 6, 0, 2, 4,
+    3, 3, 2, 0, 0, 4, 2, 4, 4, 1, 4, 0, 0, 0, 2, 4,
+    3, 3, 2, 1, 0, 4, 2, 4, 3, 2, 4, 1, 0, 0, 2, 4
+};
+
+const std::array<u8, 256> opcode_cycles_cb = {
+    2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2,
+    2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2,
+    2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2,
+    2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2,
+    2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 3, 2,
+    2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 3, 2,
+    2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 3, 2,
+    2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 3, 2,
+    2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2,
+    2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2,
+    2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2,
+    2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2,
+    2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2,
+    2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2,
+    2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2,
+    2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2
+};

applications/system/FlipperGB/gb/opcode_mapping.cc

@@ -0,0 +1,526 @@
+#include "cpu.h"
+/* clang-format off */
+
+/**
+ * This section contains functions which map to actual opcodes which are executed
+ * by the Gameboy's processor.
+ */
+
+void CPU::opcode_00() { opcode_nop(); }
+void CPU::opcode_01() { opcode_ld(bc); }
+void CPU::opcode_02() { opcode_ld(Address(bc), a); }
+void CPU::opcode_03() { opcode_inc(bc); }
+void CPU::opcode_04() { opcode_inc(b); }
+void CPU::opcode_05() { opcode_dec(b); }
+void CPU::opcode_06() { opcode_ld(b); }
+void CPU::opcode_07() { opcode_rlca(); }
+void CPU::opcode_08() { u16 nn = get_word_from_pc(); opcode_ld(Address(nn), sp); }
+void CPU::opcode_09() { opcode_add_hl(bc); }
+void CPU::opcode_0A() { opcode_ld(a, Address(bc)); }
+void CPU::opcode_0B() { opcode_dec(bc); }
+void CPU::opcode_0C() { opcode_inc(c); }
+void CPU::opcode_0D() { opcode_dec(c); }
+void CPU::opcode_0E() { opcode_ld(c); }
+void CPU::opcode_0F() { opcode_rrca(); }
+void CPU::opcode_10() { opcode_stop(); }
+void CPU::opcode_11() { opcode_ld(de); }
+void CPU::opcode_12() { opcode_ld(Address(de), a); }
+void CPU::opcode_13() { opcode_inc(de); }
+void CPU::opcode_14() { opcode_inc(d); }
+void CPU::opcode_15() { opcode_dec(d); }
+void CPU::opcode_16() { opcode_ld(d); }
+void CPU::opcode_17() { opcode_rla(); }
+void CPU::opcode_18() { opcode_jr(); }
+void CPU::opcode_19() { opcode_add_hl(de); }
+void CPU::opcode_1A() { opcode_ld(a, Address(de)); }
+void CPU::opcode_1B() { opcode_dec(de); }
+void CPU::opcode_1C() { opcode_inc(e); }
+void CPU::opcode_1D() { opcode_dec(e); }
+void CPU::opcode_1E() { opcode_ld(e); }
+void CPU::opcode_1F() { opcode_rra(); }
+void CPU::opcode_20() { opcode_jr(Condition::NZ); }
+void CPU::opcode_21() { opcode_ld(hl); }
+void CPU::opcode_22() { opcode_ldi(Address(hl), a); }
+void CPU::opcode_23() { opcode_inc(hl); }
+void CPU::opcode_24() { opcode_inc(h); }
+void CPU::opcode_25() { opcode_dec(h); }
+void CPU::opcode_26() { opcode_ld(h); }
+void CPU::opcode_27() { opcode_daa(); }
+void CPU::opcode_28() { opcode_jr(Condition::Z); }
+void CPU::opcode_29() { opcode_add_hl(hl); }
+void CPU::opcode_2A() { opcode_ldi(a, Address(hl)); }
+void CPU::opcode_2B() { opcode_dec(hl); }
+void CPU::opcode_2C() { opcode_inc(l); }
+void CPU::opcode_2D() { opcode_dec(l); }
+void CPU::opcode_2E() { opcode_ld(l); }
+void CPU::opcode_2F() { opcode_cpl(); }
+void CPU::opcode_30() { opcode_jr(Condition::NC); }
+void CPU::opcode_31() { opcode_ld(sp); }
+void CPU::opcode_32() { opcode_ldd(Address(hl), a); }
+void CPU::opcode_33() { opcode_inc(sp); }
+void CPU::opcode_34() { opcode_inc(Address(hl)); }
+void CPU::opcode_35() { opcode_dec(Address(hl)); }
+void CPU::opcode_36() { opcode_ld(Address(hl)); }
+void CPU::opcode_37() { opcode_scf(); }
+void CPU::opcode_38() { opcode_jr(Condition::C); }
+void CPU::opcode_39() { opcode_add_hl(sp); }
+void CPU::opcode_3A() { opcode_ldd(a, Address(hl)); }
+void CPU::opcode_3B() { opcode_dec(sp); }
+void CPU::opcode_3C() { opcode_inc(a); }
+void CPU::opcode_3D() { opcode_dec(a); }
+void CPU::opcode_3E() { opcode_ld(a); }
+void CPU::opcode_3F() { opcode_ccf(); }
+void CPU::opcode_40() { opcode_ld(b, b); }
+void CPU::opcode_41() { opcode_ld(b, c); }
+void CPU::opcode_42() { opcode_ld(b, d); }
+void CPU::opcode_43() { opcode_ld(b, e); }
+void CPU::opcode_44() { opcode_ld(b, h); }
+void CPU::opcode_45() { opcode_ld(b, l); }
+void CPU::opcode_46() { opcode_ld(b, Address(hl)); }
+void CPU::opcode_47() { opcode_ld(b, a); }
+void CPU::opcode_48() { opcode_ld(c, b); }
+void CPU::opcode_49() { opcode_ld(c, c); }
+void CPU::opcode_4A() { opcode_ld(c, d); }
+void CPU::opcode_4B() { opcode_ld(c, e); }
+void CPU::opcode_4C() { opcode_ld(c, h); }
+void CPU::opcode_4D() { opcode_ld(c, l); }
+void CPU::opcode_4E() { opcode_ld(c, Address(hl)); }
+void CPU::opcode_4F() { opcode_ld(c, a); }
+void CPU::opcode_50() { opcode_ld(d, b); }
+void CPU::opcode_51() { opcode_ld(d, c); }
+void CPU::opcode_52() { opcode_ld(d, d); }
+void CPU::opcode_53() { opcode_ld(d, e); }
+void CPU::opcode_54() { opcode_ld(d, h); }
+void CPU::opcode_55() { opcode_ld(d, l); }
+void CPU::opcode_56() { opcode_ld(d, Address(hl)); }
+void CPU::opcode_57() { opcode_ld(d, a); }
+void CPU::opcode_58() { opcode_ld(e, b); }
+void CPU::opcode_59() { opcode_ld(e, c); }
+void CPU::opcode_5A() { opcode_ld(e, d); }
+void CPU::opcode_5B() { opcode_ld(e, e); }
+void CPU::opcode_5C() { opcode_ld(e, h); }
+void CPU::opcode_5D() { opcode_ld(e, l); }
+void CPU::opcode_5E() { opcode_ld(e, Address(hl)); }
+void CPU::opcode_5F() { opcode_ld(e, a); }
+void CPU::opcode_60() { opcode_ld(h, b); }
+void CPU::opcode_61() { opcode_ld(h, c); }
+void CPU::opcode_62() { opcode_ld(h, d); }
+void CPU::opcode_63() { opcode_ld(h, e); }
+void CPU::opcode_64() { opcode_ld(h, h); }
+void CPU::opcode_65() { opcode_ld(h, l); }
+void CPU::opcode_66() { opcode_ld(h, Address(hl)); }
+void CPU::opcode_67() { opcode_ld(h, a); }
+void CPU::opcode_68() { opcode_ld(l, b); }
+void CPU::opcode_69() { opcode_ld(l, c); }
+void CPU::opcode_6A() { opcode_ld(l, d); }
+void CPU::opcode_6B() { opcode_ld(l, e); }
+void CPU::opcode_6C() { opcode_ld(l, h); }
+void CPU::opcode_6D() { opcode_ld(l, l); }
+void CPU::opcode_6E() { opcode_ld(l, Address(hl)); }
+void CPU::opcode_6F() { opcode_ld(l, a); }
+void CPU::opcode_70() { opcode_ld(Address(hl), b); }
+void CPU::opcode_71() { opcode_ld(Address(hl), c); }
+void CPU::opcode_72() { opcode_ld(Address(hl), d); }
+void CPU::opcode_73() { opcode_ld(Address(hl), e); }
+void CPU::opcode_74() { opcode_ld(Address(hl), h); }
+void CPU::opcode_75() { opcode_ld(Address(hl), l); }
+void CPU::opcode_76() { opcode_halt(); }
+void CPU::opcode_77() { opcode_ld(Address(hl), a); }
+void CPU::opcode_78() { opcode_ld(a, b); }
+void CPU::opcode_79() { opcode_ld(a, c); }
+void CPU::opcode_7A() { opcode_ld(a, d); }
+void CPU::opcode_7B() { opcode_ld(a, e); }
+void CPU::opcode_7C() { opcode_ld(a, h); }
+void CPU::opcode_7D() { opcode_ld(a, l); }
+void CPU::opcode_7E() { opcode_ld(a, Address(hl)); }
+void CPU::opcode_7F() { opcode_ld(a, a); }
+void CPU::opcode_80() { opcode_add_a(b); }
+void CPU::opcode_81() { opcode_add_a(c); }
+void CPU::opcode_82() { opcode_add_a(d); }
+void CPU::opcode_83() { opcode_add_a(e); }
+void CPU::opcode_84() { opcode_add_a(h); }
+void CPU::opcode_85() { opcode_add_a(l); }
+void CPU::opcode_86() { opcode_add_a(Address(hl)); }
+void CPU::opcode_87() { opcode_add_a(a); }
+void CPU::opcode_88() { opcode_adc(b); }
+void CPU::opcode_89() { opcode_adc(c); }
+void CPU::opcode_8A() { opcode_adc(d); }
+void CPU::opcode_8B() { opcode_adc(e); }
+void CPU::opcode_8C() { opcode_adc(h); }
+void CPU::opcode_8D() { opcode_adc(l); }
+void CPU::opcode_8E() { opcode_adc(Address(hl)); }
+void CPU::opcode_8F() { opcode_adc(a); }
+void CPU::opcode_90() { opcode_sub(b); }
+void CPU::opcode_91() { opcode_sub(c); }
+void CPU::opcode_92() { opcode_sub(d); }
+void CPU::opcode_93() { opcode_sub(e); }
+void CPU::opcode_94() { opcode_sub(h); }
+void CPU::opcode_95() { opcode_sub(l); }
+void CPU::opcode_96() { opcode_sub(Address(hl)); }
+void CPU::opcode_97() { opcode_sub(a); }
+void CPU::opcode_98() { opcode_sbc(b); }
+void CPU::opcode_99() { opcode_sbc(c); }
+void CPU::opcode_9A() { opcode_sbc(d); }
+void CPU::opcode_9B() { opcode_sbc(e); }
+void CPU::opcode_9C() { opcode_sbc(h); }
+void CPU::opcode_9D() { opcode_sbc(l); }
+void CPU::opcode_9E() { opcode_sbc(Address(hl)); }
+void CPU::opcode_9F() { opcode_sbc(a); }
+void CPU::opcode_A0() { opcode_and(b); }
+void CPU::opcode_A1() { opcode_and(c); }
+void CPU::opcode_A2() { opcode_and(d); }
+void CPU::opcode_A3() { opcode_and(e); }
+void CPU::opcode_A4() { opcode_and(h); }
+void CPU::opcode_A5() { opcode_and(l); }
+void CPU::opcode_A6() { opcode_and(Address(hl)); }
+void CPU::opcode_A7() { opcode_and(a); }
+void CPU::opcode_A8() { opcode_xor(b); }
+void CPU::opcode_A9() { opcode_xor(c); }
+void CPU::opcode_AA() { opcode_xor(d); }
+void CPU::opcode_AB() { opcode_xor(e); }
+void CPU::opcode_AC() { opcode_xor(h); }
+void CPU::opcode_AD() { opcode_xor(l); }
+void CPU::opcode_AE() { opcode_xor(Address(hl)); }
+void CPU::opcode_AF() { opcode_xor(a); }
+void CPU::opcode_B0() { opcode_or(b); }
+void CPU::opcode_B1() { opcode_or(c); }
+void CPU::opcode_B2() { opcode_or(d); }
+void CPU::opcode_B3() { opcode_or(e); }
+void CPU::opcode_B4() { opcode_or(h); }
+void CPU::opcode_B5() { opcode_or(l); }
+void CPU::opcode_B6() { opcode_or(Address(hl)); }
+void CPU::opcode_B7() { opcode_or(a); }
+void CPU::opcode_B8() { opcode_cp(b); }
+void CPU::opcode_B9() { opcode_cp(c); }
+void CPU::opcode_BA() { opcode_cp(d); }
+void CPU::opcode_BB() { opcode_cp(e); }
+void CPU::opcode_BC() { opcode_cp(h); }
+void CPU::opcode_BD() { opcode_cp(l); }
+void CPU::opcode_BE() { opcode_cp(Address(hl)); }
+void CPU::opcode_BF() { opcode_cp(a); }
+void CPU::opcode_C0() { opcode_ret(Condition::NZ); }
+void CPU::opcode_C1() { opcode_pop(bc); }
+void CPU::opcode_C2() { opcode_jp(Condition::NZ); }
+void CPU::opcode_C3() { opcode_jp(); }
+void CPU::opcode_C4() { opcode_call(Condition::NZ); }
+void CPU::opcode_C5() { opcode_push(bc); }
+void CPU::opcode_C6() { opcode_add_a(); }
+void CPU::opcode_C7() { opcode_rst(rst::rst1); }
+void CPU::opcode_C8() { opcode_ret(Condition::Z); }
+void CPU::opcode_C9() { opcode_ret(); }
+void CPU::opcode_CA() { opcode_jp(Condition::Z); }
+void CPU::opcode_CB() { /* External Ops */ }
+void CPU::opcode_CC() { opcode_call(Condition::Z); }
+void CPU::opcode_CD() { opcode_call(); }
+void CPU::opcode_CE() { opcode_adc(); }
+void CPU::opcode_CF() { opcode_rst(rst::rst2); }
+void CPU::opcode_D0() { opcode_ret(Condition::NC); }
+void CPU::opcode_D1() { opcode_pop(de); }
+void CPU::opcode_D2() { opcode_jp(Condition::NC); }
+void CPU::opcode_D3() { /* Undefined */ }
+void CPU::opcode_D4() { opcode_call(Condition::NC); }
+void CPU::opcode_D5() { opcode_push(de); }
+void CPU::opcode_D6() { opcode_sub(); }
+void CPU::opcode_D7() { opcode_rst(rst::rst3); }
+void CPU::opcode_D8() { opcode_ret(Condition::C); }
+void CPU::opcode_D9() { opcode_reti(); }
+void CPU::opcode_DA() { opcode_jp(Condition::C); }
+void CPU::opcode_DB() { /* Undefined */ }
+void CPU::opcode_DC() { opcode_call(Condition::C); }
+void CPU::opcode_DD() { /* Undefined */ }
+void CPU::opcode_DE() { opcode_sbc(); }
+void CPU::opcode_DF() { opcode_rst(rst::rst4); }
+void CPU::opcode_E0() { opcode_ldh_into_data(); }
+void CPU::opcode_E1() { opcode_pop(hl); }
+void CPU::opcode_E2() { opcode_ldh_into_c(); }
+void CPU::opcode_E3() { /* Undefined */ }
+void CPU::opcode_E4() { /* Undefined */ }
+void CPU::opcode_E5() { opcode_push(hl); }
+void CPU::opcode_E6() { opcode_and(); }
+void CPU::opcode_E7() { opcode_rst(rst::rst5); }
+void CPU::opcode_E8() { opcode_add_sp(); }
+void CPU::opcode_E9() { opcode_jp(Address(hl)); }
+void CPU::opcode_EA() { opcode_ld_to_addr(a); }
+void CPU::opcode_EB() { /* Undefined */ }
+void CPU::opcode_EC() { /* Undefined */ }
+void CPU::opcode_ED() { /* Undefined */ }
+void CPU::opcode_EE() { opcode_xor(); }
+void CPU::opcode_EF() { opcode_rst(rst::rst6); }
+void CPU::opcode_F0() { opcode_ldh_into_a(); }
+void CPU::opcode_F1() { opcode_pop(af); }
+void CPU::opcode_F2() { opcode_ldh_c_into_a(); }
+void CPU::opcode_F3() { opcode_di(); }
+void CPU::opcode_F4() { /* Undefined */ }
+void CPU::opcode_F5() { opcode_push(af); }
+void CPU::opcode_F6() { opcode_or(); }
+void CPU::opcode_F7() { opcode_rst(rst::rst7); }
+void CPU::opcode_F8() { opcode_ldhl(); }
+void CPU::opcode_F9() { opcode_ld(sp, hl); }
+void CPU::opcode_FA() { opcode_ld_from_addr(a); }
+void CPU::opcode_FB() { opcode_ei(); }
+void CPU::opcode_FC() { /* Undefined */ }
+void CPU::opcode_FD() { /* Undefined */ }
+void CPU::opcode_FE() { opcode_cp(); }
+void CPU::opcode_FF() { opcode_rst(rst::rst8); }
+
+/**
+ * This section contains two-byte opcodes, which are triggered when prefixed with
+ * the CB instruction above.
+ */
+
+void CPU::opcode_CB_00() { opcode_rlc(b); }
+void CPU::opcode_CB_01() { opcode_rlc(c); }
+void CPU::opcode_CB_02() { opcode_rlc(d); }
+void CPU::opcode_CB_03() { opcode_rlc(e); }
+void CPU::opcode_CB_04() { opcode_rlc(h); }
+void CPU::opcode_CB_05() { opcode_rlc(l); }
+void CPU::opcode_CB_06() { opcode_rlc(Address(hl)); }
+void CPU::opcode_CB_07() { opcode_rlc(a); }
+void CPU::opcode_CB_08() { opcode_rrc(b); }
+void CPU::opcode_CB_09() { opcode_rrc(c); }
+void CPU::opcode_CB_0A() { opcode_rrc(d); }
+void CPU::opcode_CB_0B() { opcode_rrc(e); }
+void CPU::opcode_CB_0C() { opcode_rrc(h); }
+void CPU::opcode_CB_0D() { opcode_rrc(l); }
+void CPU::opcode_CB_0E() { opcode_rrc(Address(hl)); }
+void CPU::opcode_CB_0F() { opcode_rrc(a); }
+void CPU::opcode_CB_10() { opcode_rl(b); }
+void CPU::opcode_CB_11() { opcode_rl(c); }
+void CPU::opcode_CB_12() { opcode_rl(d); }
+void CPU::opcode_CB_13() { opcode_rl(e); }
+void CPU::opcode_CB_14() { opcode_rl(h); }
+void CPU::opcode_CB_15() { opcode_rl(l); }
+void CPU::opcode_CB_16() { opcode_rl(Address(hl)); }
+void CPU::opcode_CB_17() { opcode_rl(a); }
+void CPU::opcode_CB_18() { opcode_rr(b); }
+void CPU::opcode_CB_19() { opcode_rr(c); }
+void CPU::opcode_CB_1A() { opcode_rr(d); }
+void CPU::opcode_CB_1B() { opcode_rr(e); }
+void CPU::opcode_CB_1C() { opcode_rr(h); }
+void CPU::opcode_CB_1D() { opcode_rr(l); }
+void CPU::opcode_CB_1E() { opcode_rr(Address(hl)); }
+void CPU::opcode_CB_1F() { opcode_rr(a); }
+void CPU::opcode_CB_20() { opcode_sla(b); }
+void CPU::opcode_CB_21() { opcode_sla(c); }
+void CPU::opcode_CB_22() { opcode_sla(d); }
+void CPU::opcode_CB_23() { opcode_sla(e); }
+void CPU::opcode_CB_24() { opcode_sla(h); }
+void CPU::opcode_CB_25() { opcode_sla(l); }
+void CPU::opcode_CB_26() { opcode_sla(Address(hl)); }
+void CPU::opcode_CB_27() { opcode_sla(a); }
+void CPU::opcode_CB_28() { opcode_sra(b); }
+void CPU::opcode_CB_29() { opcode_sra(c); }
+void CPU::opcode_CB_2A() { opcode_sra(d); }
+void CPU::opcode_CB_2B() { opcode_sra(e); }
+void CPU::opcode_CB_2C() { opcode_sra(h); }
+void CPU::opcode_CB_2D() { opcode_sra(l); }
+void CPU::opcode_CB_2E() { opcode_sra(Address(hl)); }
+void CPU::opcode_CB_2F() { opcode_sra(a); }
+void CPU::opcode_CB_30() { opcode_swap(b); }
+void CPU::opcode_CB_31() { opcode_swap(c); }
+void CPU::opcode_CB_32() { opcode_swap(d); }
+void CPU::opcode_CB_33() { opcode_swap(e); }
+void CPU::opcode_CB_34() { opcode_swap(h); }
+void CPU::opcode_CB_35() { opcode_swap(l); }
+void CPU::opcode_CB_36() { opcode_swap(Address(hl)); }
+void CPU::opcode_CB_37() { opcode_swap(a); }
+void CPU::opcode_CB_38() { opcode_srl(b); }
+void CPU::opcode_CB_39() { opcode_srl(c); }
+void CPU::opcode_CB_3A() { opcode_srl(d); }
+void CPU::opcode_CB_3B() { opcode_srl(e); }
+void CPU::opcode_CB_3C() { opcode_srl(h); }
+void CPU::opcode_CB_3D() { opcode_srl(l); }
+void CPU::opcode_CB_3E() { opcode_srl(Address(hl)); }
+void CPU::opcode_CB_3F() { opcode_srl(a); }
+void CPU::opcode_CB_40() { opcode_bit(0, b); }
+void CPU::opcode_CB_41() { opcode_bit(0, c); }
+void CPU::opcode_CB_42() { opcode_bit(0, d); }
+void CPU::opcode_CB_43() { opcode_bit(0, e); }
+void CPU::opcode_CB_44() { opcode_bit(0, h); }
+void CPU::opcode_CB_45() { opcode_bit(0, l); }
+void CPU::opcode_CB_46() { opcode_bit(0, Address(hl)); }
+void CPU::opcode_CB_47() { opcode_bit(0, a); }
+void CPU::opcode_CB_48() { opcode_bit(1, b); }
+void CPU::opcode_CB_49() { opcode_bit(1, c); }
+void CPU::opcode_CB_4A() { opcode_bit(1, d); }
+void CPU::opcode_CB_4B() { opcode_bit(1, e); }
+void CPU::opcode_CB_4C() { opcode_bit(1, h); }
+void CPU::opcode_CB_4D() { opcode_bit(1, l); }
+void CPU::opcode_CB_4E() { opcode_bit(1, Address(hl)); }
+void CPU::opcode_CB_4F() { opcode_bit(1, a); }
+void CPU::opcode_CB_50() { opcode_bit(2, b); }
+void CPU::opcode_CB_51() { opcode_bit(2, c); }
+void CPU::opcode_CB_52() { opcode_bit(2, d); }
+void CPU::opcode_CB_53() { opcode_bit(2, e); }
+void CPU::opcode_CB_54() { opcode_bit(2, h); }
+void CPU::opcode_CB_55() { opcode_bit(2, l); }
+void CPU::opcode_CB_56() { opcode_bit(2, Address(hl)); }
+void CPU::opcode_CB_57() { opcode_bit(2, a); }
+void CPU::opcode_CB_58() { opcode_bit(3, b); }
+void CPU::opcode_CB_59() { opcode_bit(3, c); }
+void CPU::opcode_CB_5A() { opcode_bit(3, d); }
+void CPU::opcode_CB_5B() { opcode_bit(3, e); }
+void CPU::opcode_CB_5C() { opcode_bit(3, h); }
+void CPU::opcode_CB_5D() { opcode_bit(3, l); }
+void CPU::opcode_CB_5E() { opcode_bit(3, Address(hl)); }
+void CPU::opcode_CB_5F() { opcode_bit(3, a); }
+void CPU::opcode_CB_60() { opcode_bit(4, b); }
+void CPU::opcode_CB_61() { opcode_bit(4, c); }
+void CPU::opcode_CB_62() { opcode_bit(4, d); }
+void CPU::opcode_CB_63() { opcode_bit(4, e); }
+void CPU::opcode_CB_64() { opcode_bit(4, h); }
+void CPU::opcode_CB_65() { opcode_bit(4, l); }
+void CPU::opcode_CB_66() { opcode_bit(4, Address(hl)); }
+void CPU::opcode_CB_67() { opcode_bit(4, a); }
+void CPU::opcode_CB_68() { opcode_bit(5, b); }
+void CPU::opcode_CB_69() { opcode_bit(5, c); }
+void CPU::opcode_CB_6A() { opcode_bit(5, d); }
+void CPU::opcode_CB_6B() { opcode_bit(5, e); }
+void CPU::opcode_CB_6C() { opcode_bit(5, h); }
+void CPU::opcode_CB_6D() { opcode_bit(5, l); }
+void CPU::opcode_CB_6E() { opcode_bit(5, Address(hl)); }
+void CPU::opcode_CB_6F() { opcode_bit(5, a); }
+void CPU::opcode_CB_70() { opcode_bit(6, b); }
+void CPU::opcode_CB_71() { opcode_bit(6, c); }
+void CPU::opcode_CB_72() { opcode_bit(6, d); }
+void CPU::opcode_CB_73() { opcode_bit(6, e); }
+void CPU::opcode_CB_74() { opcode_bit(6, h); }
+void CPU::opcode_CB_75() { opcode_bit(6, l); }
+void CPU::opcode_CB_76() { opcode_bit(6, Address(hl)); }
+void CPU::opcode_CB_77() { opcode_bit(6, a); }
+void CPU::opcode_CB_78() { opcode_bit(7, b); }
+void CPU::opcode_CB_79() { opcode_bit(7, c); }
+void CPU::opcode_CB_7A() { opcode_bit(7, d); }
+void CPU::opcode_CB_7B() { opcode_bit(7, e); }
+void CPU::opcode_CB_7C() { opcode_bit(7, h); }
+void CPU::opcode_CB_7D() { opcode_bit(7, l); }
+void CPU::opcode_CB_7E() { opcode_bit(7, Address(hl)); }
+void CPU::opcode_CB_7F() { opcode_bit(7, a); }
+void CPU::opcode_CB_80() { opcode_res(0, b); }
+void CPU::opcode_CB_81() { opcode_res(0, c); }
+void CPU::opcode_CB_82() { opcode_res(0, d); }
+void CPU::opcode_CB_83() { opcode_res(0, e); }
+void CPU::opcode_CB_84() { opcode_res(0, h); }
+void CPU::opcode_CB_85() { opcode_res(0, l); }
+void CPU::opcode_CB_86() { opcode_res(0, Address(hl)); }
+void CPU::opcode_CB_87() { opcode_res(0, a); }
+void CPU::opcode_CB_88() { opcode_res(1, b); }
+void CPU::opcode_CB_89() { opcode_res(1, c); }
+void CPU::opcode_CB_8A() { opcode_res(1, d); }
+void CPU::opcode_CB_8B() { opcode_res(1, e); }
+void CPU::opcode_CB_8C() { opcode_res(1, h); }
+void CPU::opcode_CB_8D() { opcode_res(1, l); }
+void CPU::opcode_CB_8E() { opcode_res(1, Address(hl)); }
+void CPU::opcode_CB_8F() { opcode_res(1, a); }
+void CPU::opcode_CB_90() { opcode_res(2, b); }
+void CPU::opcode_CB_91() { opcode_res(2, c); }
+void CPU::opcode_CB_92() { opcode_res(2, d); }
+void CPU::opcode_CB_93() { opcode_res(2, e); }
+void CPU::opcode_CB_94() { opcode_res(2, h); }
+void CPU::opcode_CB_95() { opcode_res(2, l); }
+void CPU::opcode_CB_96() { opcode_res(2, Address(hl)); }
+void CPU::opcode_CB_97() { opcode_res(2, a); }
+void CPU::opcode_CB_98() { opcode_res(3, b); }
+void CPU::opcode_CB_99() { opcode_res(3, c); }
+void CPU::opcode_CB_9A() { opcode_res(3, d); }
+void CPU::opcode_CB_9B() { opcode_res(3, e); }
+void CPU::opcode_CB_9C() { opcode_res(3, h); }
+void CPU::opcode_CB_9D() { opcode_res(3, l); }
+void CPU::opcode_CB_9E() { opcode_res(3, Address(hl)); }
+void CPU::opcode_CB_9F() { opcode_res(3, a); }
+void CPU::opcode_CB_A0() { opcode_res(4, b); }
+void CPU::opcode_CB_A1() { opcode_res(4, c); }
+void CPU::opcode_CB_A2() { opcode_res(4, d); }
+void CPU::opcode_CB_A3() { opcode_res(4, e); }
+void CPU::opcode_CB_A4() { opcode_res(4, h); }
+void CPU::opcode_CB_A5() { opcode_res(4, l); }
+void CPU::opcode_CB_A6() { opcode_res(4, Address(hl)); }
+void CPU::opcode_CB_A7() { opcode_res(4, a); }
+void CPU::opcode_CB_A8() { opcode_res(5, b); }
+void CPU::opcode_CB_A9() { opcode_res(5, c); }
+void CPU::opcode_CB_AA() { opcode_res(5, d); }
+void CPU::opcode_CB_AB() { opcode_res(5, e); }
+void CPU::opcode_CB_AC() { opcode_res(5, h); }
+void CPU::opcode_CB_AD() { opcode_res(5, l); }
+void CPU::opcode_CB_AE() { opcode_res(5, Address(hl)); }
+void CPU::opcode_CB_AF() { opcode_res(5, a); }
+void CPU::opcode_CB_B0() { opcode_res(6, b); }
+void CPU::opcode_CB_B1() { opcode_res(6, c); }
+void CPU::opcode_CB_B2() { opcode_res(6, d); }
+void CPU::opcode_CB_B3() { opcode_res(6, e); }
+void CPU::opcode_CB_B4() { opcode_res(6, h); }
+void CPU::opcode_CB_B5() { opcode_res(6, l); }
+void CPU::opcode_CB_B6() { opcode_res(6, Address(hl)); }
+void CPU::opcode_CB_B7() { opcode_res(6, a); }
+void CPU::opcode_CB_B8() { opcode_res(7, b); }
+void CPU::opcode_CB_B9() { opcode_res(7, c); }
+void CPU::opcode_CB_BA() { opcode_res(7, d); }
+void CPU::opcode_CB_BB() { opcode_res(7, e); }
+void CPU::opcode_CB_BC() { opcode_res(7, h); }
+void CPU::opcode_CB_BD() { opcode_res(7, l); }
+void CPU::opcode_CB_BE() { opcode_res(7, Address(hl)); }
+void CPU::opcode_CB_BF() { opcode_res(7, a); }
+void CPU::opcode_CB_C0() { opcode_set(0, b); }
+void CPU::opcode_CB_C1() { opcode_set(0, c); }
+void CPU::opcode_CB_C2() { opcode_set(0, d); }
+void CPU::opcode_CB_C3() { opcode_set(0, e); }
+void CPU::opcode_CB_C4() { opcode_set(0, h); }
+void CPU::opcode_CB_C5() { opcode_set(0, l); }
+void CPU::opcode_CB_C6() { opcode_set(0, Address(hl)); }
+void CPU::opcode_CB_C7() { opcode_set(0, a); }
+void CPU::opcode_CB_C8() { opcode_set(1, b); }
+void CPU::opcode_CB_C9() { opcode_set(1, c); }
+void CPU::opcode_CB_CA() { opcode_set(1, d); }
+void CPU::opcode_CB_CB() { opcode_set(1, e); }
+void CPU::opcode_CB_CC() { opcode_set(1, h); }
+void CPU::opcode_CB_CD() { opcode_set(1, l); }
+void CPU::opcode_CB_CE() { opcode_set(1, Address(hl)); }
+void CPU::opcode_CB_CF() { opcode_set(1, a); }
+void CPU::opcode_CB_D0() { opcode_set(2, b); }
+void CPU::opcode_CB_D1() { opcode_set(2, c); }
+void CPU::opcode_CB_D2() { opcode_set(2, d); }
+void CPU::opcode_CB_D3() { opcode_set(2, e); }
+void CPU::opcode_CB_D4() { opcode_set(2, h); }
+void CPU::opcode_CB_D5() { opcode_set(2, l); }
+void CPU::opcode_CB_D6() { opcode_set(2, Address(hl)); }
+void CPU::opcode_CB_D7() { opcode_set(2, a); }
+void CPU::opcode_CB_D8() { opcode_set(3, b); }
+void CPU::opcode_CB_D9() { opcode_set(3, c); }
+void CPU::opcode_CB_DA() { opcode_set(3, d); }
+void CPU::opcode_CB_DB() { opcode_set(3, e); }
+void CPU::opcode_CB_DC() { opcode_set(3, h); }
+void CPU::opcode_CB_DD() { opcode_set(3, l); }
+void CPU::opcode_CB_DE() { opcode_set(3, Address(hl)); }
+void CPU::opcode_CB_DF() { opcode_set(3, a); }
+void CPU::opcode_CB_E0() { opcode_set(4, b); }
+void CPU::opcode_CB_E1() { opcode_set(4, c); }
+void CPU::opcode_CB_E2() { opcode_set(4, d); }
+void CPU::opcode_CB_E3() { opcode_set(4, e); }
+void CPU::opcode_CB_E4() { opcode_set(4, h); }
+void CPU::opcode_CB_E5() { opcode_set(4, l); }
+void CPU::opcode_CB_E6() { opcode_set(4, Address(hl)); }
+void CPU::opcode_CB_E7() { opcode_set(4, a); }
+void CPU::opcode_CB_E8() { opcode_set(5, b); }
+void CPU::opcode_CB_E9() { opcode_set(5, c); }
+void CPU::opcode_CB_EA() { opcode_set(5, d); }
+void CPU::opcode_CB_EB() { opcode_set(5, e); }
+void CPU::opcode_CB_EC() { opcode_set(5, h); }
+void CPU::opcode_CB_ED() { opcode_set(5, l); }
+void CPU::opcode_CB_EE() { opcode_set(5, Address(hl)); }
+void CPU::opcode_CB_EF() { opcode_set(5, a); }
+void CPU::opcode_CB_F0() { opcode_set(6, b); }
+void CPU::opcode_CB_F1() { opcode_set(6, c); }
+void CPU::opcode_CB_F2() { opcode_set(6, d); }
+void CPU::opcode_CB_F3() { opcode_set(6, e); }
+void CPU::opcode_CB_F4() { opcode_set(6, h); }
+void CPU::opcode_CB_F5() { opcode_set(6, l); }
+void CPU::opcode_CB_F6() { opcode_set(6, Address(hl)); }
+void CPU::opcode_CB_F7() { opcode_set(6, a); }
+void CPU::opcode_CB_F8() { opcode_set(7, b); }
+void CPU::opcode_CB_F9() { opcode_set(7, c); }
+void CPU::opcode_CB_FA() { opcode_set(7, d); }
+void CPU::opcode_CB_FB() { opcode_set(7, e); }
+void CPU::opcode_CB_FC() { opcode_set(7, h); }
+void CPU::opcode_CB_FD() { opcode_set(7, l); }
+void CPU::opcode_CB_FE() { opcode_set(7, Address(hl)); }
+void CPU::opcode_CB_FF() { opcode_set(7, a); }

applications/system/FlipperGB/gb/opcodes.cc

@@ -0,0 +1,897 @@
+#include "cpu.h"
+
+#include "gameboy.h"
+#include "bitwise.h"
+
+using bitwise::check_bit;
+using bitwise::clear_bit;
+using bitwise::set_bit;
+
+/* ADC */
+void CPU::_opcode_adc(u8 value) {
+    u8 reg = a.value();
+    u8 carry = f.flag_carry_value();
+
+    uint result_full = reg + value + carry;
+    u8 result = static_cast<u8>(result_full);
+
+    set_flag_zero(result == 0);
+    set_flag_subtract(false);
+    set_flag_half_carry(((reg & 0xf) + (value & 0xf) + carry) > 0xf);
+    set_flag_carry(result_full > 0xff);
+
+    a.set(result);
+}
+
+void CPU::opcode_adc() {
+    _opcode_adc(get_byte_from_pc());
+}
+
+void CPU::opcode_adc(const ByteRegister& reg) {
+    _opcode_adc(reg.value());
+}
+
+void CPU::opcode_adc(const Address&& addr) {
+    _opcode_adc(gb.mmu.read(addr));
+}
+
+
+/* ADD */
+void CPU::_opcode_add(u8 reg, u8 value) {
+    uint result = reg + value;
+
+    a.set(static_cast<u8>(result));
+
+    set_flag_zero(a.value() == 0);
+    set_flag_subtract(false);
+    set_flag_half_carry((reg & 0xf) + (value & 0xf) > 0xf);
+    set_flag_carry((result & 0x100) != 0);
+}
+
+void CPU::opcode_add_a() {
+    _opcode_add(a.value(), get_byte_from_pc());
+}
+
+void CPU::opcode_add_a(const ByteRegister& reg) {
+    _opcode_add(a.value(), reg.value());
+}
+
+void CPU::opcode_add_a(const Address& addr) {
+    _opcode_add(a.value(), gb.mmu.read(addr));
+}
+
+
+void CPU::_opcode_add_hl(u16 value) {
+    u16 reg = hl.value();
+
+    uint result = reg + value;
+
+    set_flag_subtract(false);
+    set_flag_half_carry((reg & 0xfff) + (value & 0xfff) > 0xfff);
+    set_flag_carry((result & 0x10000) != 0);
+
+    hl.set(static_cast<u16>(result));
+}
+
+void CPU::opcode_add_hl(const RegisterPair& reg_pair) {
+    _opcode_add_hl(reg_pair.value());
+}
+
+void CPU::opcode_add_hl(const WordRegister& word_reg) {
+    _opcode_add_hl(word_reg.value());
+}
+
+void CPU::opcode_add_sp() {
+    u16 reg = sp.value();
+    s8 value = get_signed_byte_from_pc();
+
+    int result = static_cast<int>(reg + value);
+
+    set_flag_zero(false);
+    set_flag_subtract(false);
+    set_flag_half_carry(((reg ^ value ^ (result & 0xFFFF)) & 0x10) == 0x10);
+    set_flag_carry(((reg ^ value ^ (result & 0xFFFF)) & 0x100) == 0x100);
+
+    sp.set(static_cast<u16>(result));
+}
+
+
+/* AND */
+void CPU::_opcode_and(u8 value) {
+    u8 reg = a.value();
+    u8 result = reg & value;
+
+    a.set(result);
+
+    set_flag_zero(a.value() == 0);
+    set_flag_half_carry(true);
+    set_flag_carry(false);
+    set_flag_subtract(false);
+}
+
+void CPU::opcode_and() {
+    _opcode_and(get_byte_from_pc());
+}
+
+void CPU::opcode_and(ByteRegister& reg) {
+    _opcode_and(reg.value());
+}
+
+void CPU::opcode_and(Address&& addr) {
+    _opcode_and(gb.mmu.read(addr));
+}
+
+
+/* BIT */
+void CPU::_opcode_bit(const u8 bit, const u8 value) {
+    set_flag_zero(!check_bit(value, bit));
+    set_flag_subtract(false);
+    set_flag_half_carry(true);
+}
+
+void CPU::opcode_bit(const u8 bit, ByteRegister& reg) {
+    _opcode_bit(bit, reg.value());
+}
+
+void CPU::opcode_bit(const u8 bit, Address&& addr) {
+    _opcode_bit(bit, gb.mmu.read(addr));
+}
+
+
+/* CALL */
+void CPU::opcode_call() {
+    u16 address = get_word_from_pc();
+    stack_push(pc);
+    pc.set(address);
+}
+
+void CPU::opcode_call(Condition condition) {
+    if (is_condition(condition)) {
+        opcode_call();
+    } else {
+        /* Consume unused word argument */
+        get_word_from_pc();
+    }
+}
+
+
+/* CCF */
+void CPU::opcode_ccf() {
+    set_flag_subtract(false);
+    set_flag_half_carry(false);
+    set_flag_carry(!f.flag_carry());
+}
+
+
+/* CP */
+void CPU::_opcode_cp(const u8 value) {
+    u8 reg = a.value();
+    u8 result = static_cast<u8>(reg - value);
+
+    set_flag_zero(result == 0);
+    set_flag_subtract(true);
+    set_flag_half_carry(((reg & 0xf) - (value & 0xf)) < 0);
+    set_flag_carry(reg < value);
+}
+
+void CPU::opcode_cp() {
+    _opcode_cp(get_byte_from_pc());
+}
+
+void CPU::opcode_cp(const ByteRegister& reg) {
+    _opcode_cp(reg.value());
+}
+
+void CPU::opcode_cp(const Address& addr) {
+    _opcode_cp(gb.mmu.read(addr));
+}
+
+
+/* CPL */
+void CPU::opcode_cpl() {
+    u8 reg = a.value();
+    u8 result = ~reg;
+    a.set(result);
+
+    set_flag_subtract(true);
+    set_flag_half_carry(true);
+}
+
+
+/* DAA */
+void CPU::opcode_daa() {
+    u8 reg = a.value();
+
+    u16 correction = f.flag_carry()
+        ? 0x60
+        : 0x00;
+
+    if (f.flag_half_carry() || (!f.flag_subtract() && ((reg & 0x0F) > 9))) {
+        correction |= 0x06;
+    }
+
+    if (f.flag_carry() || (!f.flag_subtract() && (reg > 0x99))) {
+        correction |= 0x60;
+    }
+
+    if (f.flag_subtract()) {
+        reg = static_cast<u8>(reg - correction);
+    } else {
+        reg = static_cast<u8>(reg + correction);
+    }
+
+    if (((correction << 2) & 0x100) != 0) {
+        set_flag_carry(true);
+    }
+
+    set_flag_half_carry(false);
+    set_flag_zero(reg == 0);
+
+    a.set(static_cast<u8>(reg));
+}
+
+
+/* DEC */
+void CPU::opcode_dec(ByteRegister& reg) {
+    reg.decrement();
+
+    set_flag_zero(reg.value() == 0);
+    set_flag_subtract(true);
+    set_flag_half_carry((reg.value() & 0x0F) == 0x0F);
+}
+
+void CPU::opcode_dec(RegisterPair& reg) {
+    reg.decrement();
+}
+
+void CPU::opcode_dec(WordRegister& reg) {
+    reg.decrement();
+}
+
+void CPU::opcode_dec(Address&& addr) {
+    u8 value = gb.mmu.read(addr);
+    u8 result = static_cast<u8>(value - 1);
+    gb.mmu.write(addr, result);
+
+    set_flag_zero(result == 0);
+    set_flag_subtract(true);
+    set_flag_half_carry((result & 0x0F) == 0x0F);
+}
+
+
+/* DI */
+void CPU::opcode_di() {
+    interrupts_enabled = false;
+}
+
+
+/* EI */
+void CPU::opcode_ei() {
+    interrupts_enabled = true;
+}
+
+
+/* INC */
+void CPU::opcode_inc(ByteRegister& reg) {
+    reg.increment();
+
+    set_flag_zero(reg.value() == 0);
+    set_flag_subtract(false);
+    set_flag_half_carry((reg.value() & 0x0F) == 0x00);
+}
+
+void CPU::opcode_inc(RegisterPair& reg) {
+    reg.increment();
+}
+
+void CPU::opcode_inc(WordRegister& reg) {
+    reg.increment();
+}
+
+void CPU::opcode_inc(Address&& addr) {
+    u8 value = gb.mmu.read(addr);
+    u8 result = static_cast<u8>(value + 1);
+    gb.mmu.write(addr, result);
+
+    set_flag_zero(result == 0);
+    set_flag_subtract(false);
+    set_flag_half_carry((result & 0x0F) == 0x00);
+}
+
+
+/* JP */
+void CPU::opcode_jp() {
+    u16 address = get_word_from_pc();
+    pc.set(address);
+}
+
+void CPU::opcode_jp(Condition condition) {
+    if (is_condition(condition)) {
+        opcode_jp();
+    } else {
+        /* Consume unused word argument */
+        get_word_from_pc();
+    }
+}
+
+void CPU::opcode_jp(const Address& addr) {
+    unused(addr);
+    pc.set(hl.value());
+}
+
+
+/* JR */
+void CPU::opcode_jr() {
+    s8 offset = get_signed_byte_from_pc();
+
+
+    u16 old_pc = pc.value();
+
+    u16 new_pc = static_cast<u16>(old_pc + offset);
+    pc.set(new_pc);
+}
+
+void CPU::opcode_jr(Condition condition) {
+    if (is_condition(condition)) {
+        opcode_jr();
+    } else {
+        /* Consume unused argument */
+        get_signed_byte_from_pc();
+    }
+}
+
+
+/* HALT */
+void CPU::opcode_halt() {
+    halted = true;
+}
+
+
+/* LD */
+void CPU::opcode_ld(ByteRegister& reg) {
+    u8 n = get_byte_from_pc();
+    reg.set(n);
+}
+
+void CPU::opcode_ld(ByteRegister& reg, const ByteRegister& byte_reg) {
+    reg.set(byte_reg.value());
+}
+
+void CPU::opcode_ld(ByteRegister& reg, const Address& address) {
+    reg.set(gb.mmu.read(address));
+}
+
+void CPU::opcode_ld_from_addr(ByteRegister& reg) {
+    u16 nn = get_word_from_pc();
+    reg.set(gb.mmu.read(nn));
+}
+
+void CPU::opcode_ld(RegisterPair& reg) {
+    u16 nn = get_word_from_pc();
+    reg.set(nn);
+}
+
+
+void CPU::opcode_ld(WordRegister& reg) {
+    u16 nn = get_word_from_pc();
+    reg.set(nn);
+}
+
+void CPU::opcode_ld(WordRegister& reg, const RegisterPair& reg_pair) {
+    reg.set(reg_pair.value());
+}
+
+
+void CPU::opcode_ld(const Address& address) {
+    u8 n = get_byte_from_pc();
+    gb.mmu.write(address, n);
+}
+
+void CPU::opcode_ld(const Address& address, const ByteRegister& byte_reg) {
+    gb.mmu.write(address, byte_reg.value());
+}
+
+void CPU::opcode_ld(const Address& address, const WordRegister& word_reg) {
+    gb.mmu.write(address, word_reg.low());
+    gb.mmu.write(address + 1, word_reg.high());
+}
+
+
+void CPU::opcode_ld_to_addr(const ByteRegister &reg) {
+    u16 address = get_word_from_pc();
+    gb.mmu.write(Address(address), reg.value());
+}
+
+
+/* LDD */
+void CPU::opcode_ldd(ByteRegister& reg, const Address& address) {
+    reg.set(gb.mmu.read(address));
+    hl.decrement();
+}
+
+void CPU::opcode_ldd(const Address& address, const ByteRegister& reg) {
+    gb.mmu.write(address, reg.value());
+    hl.decrement();
+}
+
+
+/* LDH */
+void CPU::opcode_ldh_into_a() {
+    u8 offset = get_byte_from_pc();
+    auto address = Address(0xFF00 + offset);
+
+    u8 value = gb.mmu.read(address);
+    a.set(value);
+}
+
+void CPU::opcode_ldh_into_data() {
+    u8 offset = get_byte_from_pc();
+    auto address = Address(0xFF00 + offset);
+
+    gb.mmu.write(address, a.value());
+}
+
+void CPU::opcode_ldh_into_c() {
+    u8 offset = c.value();
+    auto address = Address(0xFF00 + offset);
+
+    gb.mmu.write(address, a.value());
+}
+
+void CPU::opcode_ldh_c_into_a() {
+    auto address = Address(0xFF00 + c.value());
+
+    a.set(gb.mmu.read(address));
+}
+
+
+/* LDHL */
+void CPU::opcode_ldhl() {
+    u16 reg = sp.value();
+    s8 value = get_signed_byte_from_pc();
+
+    int result = static_cast<int>(reg + value);
+
+    set_flag_zero(false);
+    set_flag_subtract(false);
+    set_flag_half_carry(((reg ^ value ^ (result & 0xFFFF)) & 0x10) == 0x10);
+    set_flag_carry(((reg ^ value ^ (result & 0xFFFF)) & 0x100) == 0x100);
+
+    hl.set(static_cast<u16>(result));
+}
+
+
+/* LDI */
+void CPU::opcode_ldi(ByteRegister& reg, const Address& address) {
+    reg.set(gb.mmu.read(address));
+    hl.increment();
+}
+
+void CPU::opcode_ldi(const Address& address, const ByteRegister& reg) {
+    gb.mmu.write(address, reg.value());
+    hl.increment();
+}
+
+
+/* NOP */
+void CPU::opcode_nop() {
+    /* Do nothing */
+}
+
+
+/* OR */
+void CPU::_opcode_or(u8 value) {
+    u8 reg = a.value();
+    u8 result = reg | value;
+
+    a.set(result);
+
+    set_flag_zero(a.value() == 0);
+    set_flag_half_carry(false);
+    set_flag_carry(false);
+    set_flag_subtract(false);
+
+}
+
+void CPU::opcode_or() {
+    _opcode_or(get_byte_from_pc());
+}
+
+void CPU::opcode_or(const ByteRegister& reg) {
+    _opcode_or(reg.value());
+}
+
+void CPU::opcode_or(const Address& addr) {
+    _opcode_or(gb.mmu.read(addr));
+}
+
+
+/* POP */
+void CPU::opcode_pop(RegisterPair& reg) {
+    stack_pop(reg);
+}
+
+
+/* PUSH */
+void CPU::opcode_push(const RegisterPair& reg) {
+    stack_push(reg);
+}
+
+
+/* RES */
+void CPU::opcode_res(const u8 bit, ByteRegister& reg) {
+    u8 result = clear_bit(reg.value(), bit);
+    reg.set(result);
+}
+
+void CPU::opcode_res(const u8 bit, Address&& addr) {
+    u8 value = gb.mmu.read(addr);
+    u8 result = clear_bit(value, bit);
+    gb.mmu.write(addr, result);
+}
+
+
+/* RET */
+void CPU::opcode_ret() {
+    stack_pop(pc);
+}
+
+void CPU::opcode_ret(Condition condition) {
+    if (is_condition(condition)) {
+        opcode_ret();
+    }
+}
+
+
+/* RETI */
+void CPU::opcode_reti() {
+    opcode_ret();
+    opcode_ei();
+}
+
+
+/* RL */
+auto CPU::_opcode_rl(u8 value) -> u8 {
+    u8 carry = f.flag_carry_value();
+
+    bool will_carry = check_bit(value, 7);
+    set_flag_carry(will_carry);
+
+    u8 result = static_cast<u8>(value << 1);
+    result |= carry;
+
+    set_flag_zero(result == 0);
+
+    set_flag_subtract(false);
+    set_flag_half_carry(false);
+
+    return result;
+}
+
+void CPU::opcode_rla() {
+    opcode_rl(a);
+    set_flag_zero(false);
+}
+
+void CPU::opcode_rl(ByteRegister& reg) {
+    u8 result = _opcode_rl(reg.value());
+    reg.set(result);
+}
+
+void CPU::opcode_rl(Address&& addr) {
+    u8 result = _opcode_rl(gb.mmu.read(addr));
+    gb.mmu.write(addr, result);
+}
+
+
+/* RLC */
+auto CPU::_opcode_rlc(u8 value) -> u8 {
+    u8 carry_flag = check_bit(value, 7);
+    u8 truncated_bit = check_bit(value, 7);
+    u8 result = static_cast<u8>((value << 1) | truncated_bit);
+
+    set_flag_carry(carry_flag);
+    set_flag_zero(result == 0);
+    set_flag_half_carry(false);
+    set_flag_subtract(false);
+
+    return result;
+}
+
+void CPU::opcode_rlca() {
+    opcode_rlc(a);
+    set_flag_zero(false);
+}
+
+void CPU::opcode_rlc(ByteRegister& reg) {
+    u8 result = _opcode_rlc(reg.value());
+    reg.set(result);
+}
+
+void CPU::opcode_rlc(Address&& addr) {
+    u8 result = _opcode_rlc(gb.mmu.read(addr));
+    gb.mmu.write(addr, result);
+}
+
+
+/* RR */
+auto CPU::_opcode_rr(u8 value) -> u8 {
+    u8 carry = f.flag_carry_value();
+
+    bool will_carry = check_bit(value, 0);
+    set_flag_carry(will_carry);
+
+    u8 result = static_cast<u8>(value >> 1);
+    result |= (carry << 7);
+
+    set_flag_zero(result == 0);
+    set_flag_subtract(false);
+    set_flag_half_carry(false);
+
+    return result;
+}
+
+void CPU::opcode_rra() {
+    opcode_rr(a);
+    set_flag_zero(false);
+}
+
+void CPU::opcode_rr(ByteRegister& reg) {
+    u8 result = _opcode_rr(reg.value());
+    reg.set(result);
+}
+
+void CPU::opcode_rr(Address&& addr) {
+    u8 result = _opcode_rr(gb.mmu.read(addr));
+    gb.mmu.write(addr, result);
+}
+
+
+/* RRC */
+auto CPU::_opcode_rrc(u8 value) -> u8 {
+    u8 carry_flag = check_bit(value, 0);
+    u8 truncated_bit = check_bit(value, 0);
+    u8 result = static_cast<u8>((value >> 1) | (truncated_bit << 7));
+
+    set_flag_carry(carry_flag);
+    set_flag_zero(result == 0);
+    set_flag_half_carry(false);
+    set_flag_subtract(false);
+
+    return result;
+}
+
+void CPU::opcode_rrca() {
+    opcode_rrc(a);
+    set_flag_zero(false);
+}
+
+void CPU::opcode_rrc(ByteRegister& reg) {
+    u8 result = _opcode_rrc(reg.value());
+    reg.set(result);
+}
+
+void CPU::opcode_rrc(Address&& addr) {
+    u8 result = _opcode_rrc(gb.mmu.read(addr));
+    gb.mmu.write(addr, result);
+}
+
+
+/* RST */
+void CPU::opcode_rst(const u8 offset) {
+    stack_push(pc);
+    pc.set(offset);
+}
+
+
+/* SBC */
+void CPU::_opcode_sbc(const u8 value) {
+    u8 carry = f.flag_carry_value();
+    u8 reg = a.value();
+
+    int result_full = reg - value - carry;
+    u8 result = static_cast<u8>(result_full);
+
+    set_flag_zero(result == 0);
+    set_flag_subtract(true);
+    set_flag_carry(result_full < 0);
+    set_flag_half_carry(((reg & 0xf) - (value & 0xf) - carry) < 0);
+
+    a.set(result);
+}
+
+void CPU::opcode_sbc() {
+    _opcode_sbc(get_byte_from_pc());
+}
+
+void CPU::opcode_sbc(ByteRegister& reg) {
+    _opcode_sbc(reg.value());
+}
+
+void CPU::opcode_sbc(Address&& addr) {
+    _opcode_sbc(gb.mmu.read(addr));
+}
+
+
+/* SCF */
+void CPU::opcode_scf() {
+    set_flag_carry(true);
+    set_flag_half_carry(false);
+    set_flag_subtract(false);
+}
+
+
+/* SET */
+void CPU::opcode_set(const u8 bit, ByteRegister& reg) {
+    u8 result = set_bit(reg.value(), bit);
+    reg.set(result);
+}
+
+void CPU::opcode_set(const u8 bit, Address&& addr) {
+    u8 value = gb.mmu.read(addr);
+    u8 result = set_bit(value, bit);
+    gb.mmu.write(addr, result);
+}
+
+
+/* SLA */
+auto CPU::_opcode_sla(u8 value) -> u8 {
+    u8 carry_bit = check_bit(value, 7);
+
+    u8 result = static_cast<u8>(value << 1);
+
+    set_flag_zero(result == 0);
+    set_flag_carry(carry_bit);
+    set_flag_half_carry(false);
+    set_flag_subtract(false);
+
+    return result;
+}
+
+void CPU::opcode_sla(ByteRegister& reg) {
+    u8 result = _opcode_sla(reg.value());
+    reg.set(result);
+}
+
+void CPU::opcode_sla(Address&& addr) {
+    u8 result = _opcode_sla(gb.mmu.read(addr));
+    gb.mmu.write(addr, result);
+}
+
+
+/* SRA */
+auto CPU::_opcode_sra(u8 value) -> u8 {
+    u8 carry_bit = check_bit(value, 0);
+    u8 top_bit = check_bit(value, 7);
+
+    u8 result = static_cast<u8>(value >> 1);
+    result = bitwise::set_bit_to(result, 7, top_bit);
+
+    set_flag_zero(result == 0);
+    set_flag_carry(carry_bit);
+    set_flag_half_carry(false);
+    set_flag_subtract(false);
+
+    return result;
+}
+
+void CPU::opcode_sra(ByteRegister& reg) {
+    u8 result = _opcode_sra(reg.value());
+    reg.set(result);
+}
+
+void CPU::opcode_sra(Address&& addr) {
+    u8 result = _opcode_sra(gb.mmu.read(addr));
+    gb.mmu.write(addr, result);
+}
+
+
+/* SRL */
+auto CPU::_opcode_srl(u8 value) -> u8 {
+    bool least_bit_set = check_bit(value, 0);
+
+    u8 result = (value >> 1);
+    set_flag_carry(least_bit_set);
+    set_flag_zero(result == 0);
+    set_flag_half_carry(false);
+    set_flag_subtract(false);
+
+    return result;
+}
+
+void CPU::opcode_srl(ByteRegister& reg) {
+    u8 result = _opcode_srl(reg.value());
+    reg.set(result);
+}
+
+void CPU::opcode_srl(Address&& addr) {
+    u8 result = _opcode_srl(gb.mmu.read(addr));
+    gb.mmu.write(addr, result);
+}
+
+
+/* STOP */
+void CPU::opcode_stop() {
+    /* halted = true; */
+}
+
+
+/* SUB */
+void CPU::_opcode_sub(u8 value) {
+    u8 reg = a.value();
+    u8 result = static_cast<u8>(reg - value);
+
+    a.set(result);
+
+    set_flag_zero(a.value() == 0);
+    set_flag_subtract(true);
+    set_flag_half_carry(((reg & 0xf) - (value & 0xf)) < 0);
+    set_flag_carry(reg < value);
+}
+
+void CPU::opcode_sub() {
+    _opcode_sub(get_byte_from_pc());
+}
+
+void CPU::opcode_sub(ByteRegister& reg) {
+    _opcode_sub(reg.value());
+}
+
+void CPU::opcode_sub(Address&& addr) {
+    _opcode_sub(gb.mmu.read(addr));
+}
+
+
+/* SWAP */
+auto CPU::_opcode_swap(u8 value) -> u8 {
+    using bitwise::compose_nibbles;
+
+    u8 lower_nibble = value & 0x0F;
+    u8 upper_nibble = (value & 0xF0) >> 4;
+
+    u8 result = compose_nibbles(lower_nibble, upper_nibble);
+
+    set_flag_zero(result == 0);
+    set_flag_subtract(false);
+    set_flag_half_carry(false);
+    set_flag_carry(false);
+
+    return result;
+}
+
+void CPU::opcode_swap(ByteRegister& reg) {
+    u8 result = _opcode_swap(reg.value());
+    reg.set(result);
+}
+
+void CPU::opcode_swap(Address&& addr) {
+    u8 result = _opcode_swap(gb.mmu.read(addr));
+    gb.mmu.write(addr, result);
+}
+
+
+/* XOR */
+void CPU::_opcode_xor(u8 value) {
+    u8 reg = a.value();
+
+    u8 result = reg ^ value;
+
+    set_flag_zero(result == 0);
+    set_flag_subtract(false);
+    set_flag_half_carry(false);
+    set_flag_carry(false);
+
+    a.set(result);
+}
+
+void CPU::opcode_xor() {
+    _opcode_xor(get_byte_from_pc());
+}
+
+void CPU::opcode_xor(const ByteRegister& reg) {
+    _opcode_xor(reg.value());
+}
+
+void CPU::opcode_xor(const Address& addr) {
+    _opcode_xor(gb.mmu.read(addr));
+}

applications/system/FlipperGB/gb/register.h

@@ -0,0 +1,104 @@
+#pragma once
+
+#include "definitions.h"
+
+/* Devirtualized registers: on the original design every register access was
+ * a virtual call and every 1-byte register carried an 8-byte vtable pointer.
+ * On a 64 MHz Cortex-M4 that overhead matters, so everything here is plain
+ * inline code. The flag register masking (lower nibble always 0) is handled
+ * by FlagRegister's shadowing set() and by RegisterPair's low_mask. */
+
+class ByteRegister {
+public:
+    ByteRegister() = default;
+
+    void set(u8 new_value) { val = new_value; }
+    void reset() { val = 0; }
+    auto value() const -> u8 { return val; }
+
+    auto check_bit(u8 bit) const -> bool { return (val & (1 << bit)) != 0; }
+    void set_bit_to(u8 bit, bool set) {
+        if(set)
+            val = static_cast<u8>(val | (1 << bit));
+        else
+            val = static_cast<u8>(val & ~(1 << bit));
+    }
+
+    void increment() { val++; }
+    void decrement() { val--; }
+
+    auto operator==(u8 other) const -> bool { return val == other; }
+
+protected:
+    u8 val = 0x0;
+};
+
+class FlagRegister : public ByteRegister {
+public:
+    FlagRegister() = default;
+
+    /* lower nibble of F is always 0 */
+    void set(u8 new_value) { val = static_cast<u8>(new_value & 0xF0); }
+
+    void set_flag_zero(bool set) { set_bit_to(7, set); }
+    void set_flag_subtract(bool set) { set_bit_to(6, set); }
+    void set_flag_half_carry(bool set) { set_bit_to(5, set); }
+    void set_flag_carry(bool set) { set_bit_to(4, set); }
+
+    auto flag_zero() const -> bool { return check_bit(7); }
+    auto flag_subtract() const -> bool { return check_bit(6); }
+    auto flag_half_carry() const -> bool { return check_bit(5); }
+    auto flag_carry() const -> bool { return check_bit(4); }
+
+    auto flag_zero_value() const -> u8 { return static_cast<u8>((val >> 7) & 1); }
+    auto flag_subtract_value() const -> u8 { return static_cast<u8>((val >> 6) & 1); }
+    auto flag_half_carry_value() const -> u8 { return static_cast<u8>((val >> 5) & 1); }
+    auto flag_carry_value() const -> u8 { return static_cast<u8>((val >> 4) & 1); }
+};
+
+class WordRegister {
+public:
+    WordRegister() = default;
+
+    void set(u16 new_value) { val = new_value; }
+
+    auto value() const -> u16 { return val; }
+
+    auto low() const -> u8 { return static_cast<u8>(val); }
+    auto high() const -> u8 { return static_cast<u8>(val >> 8); }
+
+    void increment() { val++; }
+    void decrement() { val--; }
+
+private:
+    u16 val = 0x0;
+};
+
+class RegisterPair {
+public:
+    /* mask_low is 0xF0 for AF (F's lower nibble reads/writes as 0) */
+    RegisterPair(ByteRegister& high, ByteRegister& low, u8 mask_low = 0xFF)
+        : low_byte(low)
+        , high_byte(high)
+        , low_mask(mask_low) {}
+
+    void set(u16 word) {
+        low_byte.set(static_cast<u8>(word & low_mask));
+        high_byte.set(static_cast<u8>(word >> 8));
+    }
+
+    auto value() const -> u16 {
+        return static_cast<u16>((high_byte.value() << 8) | (low_byte.value() & low_mask));
+    }
+
+    auto low() const -> u8 { return static_cast<u8>(low_byte.value() & low_mask); }
+    auto high() const -> u8 { return high_byte.value(); }
+
+    void increment() { set(static_cast<u16>(value() + 1)); }
+    void decrement() { set(static_cast<u16>(value() - 1)); }
+
+private:
+    ByteRegister& low_byte;
+    ByteRegister& high_byte;
+    u8 low_mask;
+};

applications/system/FlipperGB/gb/timer.cc

@@ -0,0 +1,77 @@
+#include "timer.h"
+
+#include "definitions.h"
+#include "gameboy.h"
+#include "cpu.h"
+#include "bitwise.h"
+
+const uint CLOCKS_PER_CYCLE = 4;
+
+Timer::Timer(Gameboy& _gb) : gb(_gb) {}
+
+void Timer::tick(uint cycles) {
+    /* DIV increments at 16384 Hz = every 64 M-cycles (upstream incremented
+     * it once per M-cycle: 64x too fast, breaking games that use DIV for
+     * delays or randomness) */
+    div_clocks += cycles;
+    if(div_clocks >= 64) {
+        divider.set(static_cast<u8>(divider.value() + (div_clocks >> 6)));
+        div_clocks &= 63;
+    }
+
+    clocks += cycles * CLOCKS_PER_CYCLE;
+
+    auto timer_is_on = timer_control.check_bit(2);
+    if (timer_is_on == 0) { return; }
+
+    auto clock_limit = clocks_needed_to_increment();
+
+    if (clocks >= clock_limit) {
+        clocks = clocks % clock_limit;
+
+        u8 old_timer_counter = timer_counter.value();
+        timer_counter.increment();
+
+        if (timer_counter.value() < old_timer_counter) {
+            gb.cpu.interrupt_flag.set_bit_to(2, true);
+            timer_counter.set(timer_modulo.value());
+        }
+    }
+}
+
+auto Timer::get_divider() const -> u8 { return divider.value(); }
+
+auto Timer::get_timer() const -> u8 { return timer_counter.value(); }
+
+auto Timer::get_timer_modulo() const -> u8 { return timer_modulo.value(); }
+
+// Only the bottom three bits of this register are usable
+auto Timer::get_timer_control() const -> u8 { return timer_control.value() & 0x3; }
+
+void Timer::reset_divider() {
+    divider.set(0x0);
+}
+
+void Timer::set_timer(u8 value) {
+    timer_counter.set(value);
+}
+
+void Timer::set_timer_modulo(u8 value) {
+    timer_modulo.set(value);
+}
+
+void Timer::set_timer_control(u8 value) {
+    timer_control.set(value);
+}
+
+uint Timer::clocks_needed_to_increment() {
+    using bitwise::check_bit;
+
+    switch (get_timer_control()) {
+        case 0: return CLOCK_RATE / 4096;
+        case 1: return CLOCK_RATE / 262144;
+        case 2: return CLOCK_RATE / 65536;
+        case 3: return CLOCK_RATE / 16384;
+        default: return CLOCK_RATE / 4096; /* unreachable */
+    }
+}

applications/system/FlipperGB/gb/timer.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "definitions.h"
+#include "register.h"
+
+class Gameboy;
+
+class Timer {
+public:
+    Timer(Gameboy& inGb);
+
+    void tick(uint cycles);
+
+    auto get_divider() const -> u8;
+    auto get_timer() const -> u8;
+    auto get_timer_modulo() const -> u8;
+    auto get_timer_control() const -> u8;
+
+    void reset_divider();
+    void set_timer(u8 value);
+    void set_timer_modulo(u8 value);
+    void set_timer_control(u8 value);
+
+private:
+    uint clocks_needed_to_increment();
+
+    uint clocks = 0;
+    uint div_clocks = 0;
+
+    Gameboy& gb;
+
+    ByteRegister divider;
+    ByteRegister timer_counter;
+
+    ByteRegister timer_modulo;
+    ByteRegister timer_control;
+};

applications/system/FlipperGB/gb/video.cc

@@ -0,0 +1,353 @@
+#include "video.h"
+
+#include "gameboy.h"
+#include "cpu.h"
+#include "bitwise.h"
+
+using bitwise::check_bit;
+
+Video::Video(Gameboy& inGb)
+    : gb(inGb) {
+}
+
+void Video::tick(Cycles cycles) {
+    cycle_counter += cycles.cycles;
+
+    switch(current_mode) {
+    case VideoMode::ACCESS_OAM:
+        if(cycle_counter >= CLOCKS_PER_SCANLINE_OAM) {
+            cycle_counter = cycle_counter % CLOCKS_PER_SCANLINE_OAM;
+            lcd_status.set_bit_to(1, true);
+            lcd_status.set_bit_to(0, true);
+            current_mode = VideoMode::ACCESS_VRAM;
+        }
+        break;
+    case VideoMode::ACCESS_VRAM:
+        if(cycle_counter >= CLOCKS_PER_SCANLINE_VRAM) {
+            cycle_counter = cycle_counter % CLOCKS_PER_SCANLINE_VRAM;
+            current_mode = VideoMode::HBLANK;
+
+            bool hblank_interrupt = check_bit(lcd_status.value(), 3);
+
+            if(hblank_interrupt) {
+                gb.cpu.interrupt_flag.set_bit_to(1, true);
+            }
+
+            bool ly_coincidence_interrupt = check_bit(lcd_status.value(), 6);
+            bool ly_coincidence = ly_compare.value() == line.value();
+            if(ly_coincidence_interrupt && ly_coincidence) {
+                gb.cpu.interrupt_flag.set_bit_to(1, true);
+            }
+            lcd_status.set_bit_to(2, ly_coincidence);
+
+            lcd_status.set_bit_to(1, false);
+            lcd_status.set_bit_to(0, false);
+        }
+        break;
+    case VideoMode::HBLANK:
+        if(cycle_counter >= CLOCKS_PER_HBLANK) {
+            if(!skip_render) write_scanline(line.value());
+            line.increment();
+
+            cycle_counter = cycle_counter % CLOCKS_PER_HBLANK;
+
+            /* Line 145 (index 144) is the first line of VBLANK */
+            if(line == 144) {
+                current_mode = VideoMode::VBLANK;
+                lcd_status.set_bit_to(1, false);
+                lcd_status.set_bit_to(0, true);
+                gb.cpu.interrupt_flag.set_bit_to(0, true);
+            } else {
+                lcd_status.set_bit_to(1, true);
+                lcd_status.set_bit_to(0, false);
+                current_mode = VideoMode::ACCESS_OAM;
+            }
+        }
+        break;
+    case VideoMode::VBLANK:
+        if(cycle_counter >= CLOCKS_PER_SCANLINE) {
+            line.increment();
+
+            cycle_counter = cycle_counter % CLOCKS_PER_SCANLINE;
+
+            /* Line 155 (index 154) is the last line */
+            if(line == 154) {
+                if(!skip_render) {
+                    write_sprites();
+                    draw();
+                    buffer.reset();
+                } else {
+                    draw(); /* still notify the frontend for pacing */
+                }
+                line.reset();
+                current_mode = VideoMode::ACCESS_OAM;
+                lcd_status.set_bit_to(1, true);
+                lcd_status.set_bit_to(0, false);
+            };
+        }
+        break;
+    }
+}
+
+auto Video::display_enabled() const -> bool {
+    return check_bit(control_byte, 7);
+}
+auto Video::window_tile_map() const -> bool {
+    return check_bit(control_byte, 6);
+}
+auto Video::window_enabled() const -> bool {
+    return check_bit(control_byte, 5);
+}
+auto Video::bg_window_tile_data() const -> bool {
+    return check_bit(control_byte, 4);
+}
+auto Video::bg_tile_map_display() const -> bool {
+    return check_bit(control_byte, 3);
+}
+auto Video::sprite_size() const -> bool {
+    return check_bit(control_byte, 2);
+}
+auto Video::sprites_enabled() const -> bool {
+    return check_bit(control_byte, 1);
+}
+auto Video::bg_enabled() const -> bool {
+    return check_bit(control_byte, 0);
+}
+
+void Video::write_scanline(u8 current_line) {
+    if(!display_enabled()) {
+        return;
+    }
+
+    /* Lines the frontend never displays are not worth rendering */
+    if(row_mask && current_line < GAMEBOY_HEIGHT && !row_mask[current_line]) {
+        return;
+    }
+
+    if(bg_enabled()) {
+        draw_bg_line(current_line);
+    }
+
+    if(window_enabled()) {
+        draw_window_line(current_line);
+    }
+}
+
+void Video::write_sprites() {
+    if(!sprites_enabled()) {
+        return;
+    }
+
+    for(uint sprite_n = 0; sprite_n < 40; sprite_n++) {
+        draw_sprite(sprite_n);
+    }
+}
+
+void Video::draw_bg_line(uint current_line) {
+    /* Note: tileset two uses signed numbering to share half the tiles with
+     * tileset one */
+    bool use_tile_set_zero = bg_window_tile_data();
+    bool use_tile_map_zero = !bg_tile_map_display();
+
+    Palette palette = load_palette(bg_palette);
+
+    u16 tile_set_address = use_tile_set_zero ? TILE_SET_ZERO_ADDRESS : TILE_SET_ONE_ADDRESS;
+    u16 tile_map_address = use_tile_map_zero ? TILE_MAP_ZERO_ADDRESS : TILE_MAP_ONE_ADDRESS;
+
+    uint screen_y = current_line;
+    uint scrolled_y = (screen_y + scroll_y.value()) % BG_MAP_SIZE;
+    uint tile_y = scrolled_y / TILE_HEIGHT_PX;
+    uint tile_pixel_y = scrolled_y % TILE_HEIGHT_PX;
+    uint tile_data_line_offset = tile_pixel_y * 2;
+
+    /* Render tile-by-tile instead of refetching the tile data for every
+     * pixel like upstream did */
+    uint scroll_x_val = scroll_x.value();
+
+    uint screen_x = 0;
+    while(screen_x < GAMEBOY_WIDTH) {
+        uint scrolled_x = (screen_x + scroll_x_val) % BG_MAP_SIZE;
+        uint tile_x = scrolled_x / TILE_WIDTH_PX;
+        uint tile_pixel_x = scrolled_x % TILE_WIDTH_PX;
+
+        uint tile_index = tile_y * TILES_PER_LINE + tile_x;
+        u8 tile_id = video_ram[tile_map_address - 0x8000 + tile_index];
+
+        uint tile_data_mem_offset = use_tile_set_zero ?
+                                        tile_id * TILE_BYTES :
+                                        static_cast<uint>(
+                                            (static_cast<s8>(tile_id) + 128)) *
+                                            TILE_BYTES;
+
+        uint line_addr = (tile_set_address - 0x8000) + tile_data_mem_offset +
+                         tile_data_line_offset;
+
+        u8 pixels_1 = video_ram[line_addr];
+        u8 pixels_2 = video_ram[line_addr + 1];
+
+        /* Draw the remainder of this tile's row */
+        for(uint px = tile_pixel_x; px < TILE_WIDTH_PX && screen_x < GAMEBOY_WIDTH;
+            px++, screen_x++) {
+            u8 pixel_color = get_pixel_from_line(pixels_1, pixels_2, static_cast<u8>(px));
+            buffer.set_pixel(screen_x, screen_y, get_shade_from_palette(pixel_color, palette));
+        }
+    }
+}
+
+void Video::draw_window_line(uint current_line) {
+    bool use_tile_set_zero = bg_window_tile_data();
+    bool use_tile_map_zero = !window_tile_map();
+
+    Palette palette = load_palette(bg_palette);
+
+    u16 tile_set_address = use_tile_set_zero ? TILE_SET_ZERO_ADDRESS : TILE_SET_ONE_ADDRESS;
+    u16 tile_map_address = use_tile_map_zero ? TILE_MAP_ZERO_ADDRESS : TILE_MAP_ONE_ADDRESS;
+
+    uint screen_y = current_line;
+    uint scrolled_y = screen_y - window_y.value();
+
+    if(scrolled_y >= GAMEBOY_HEIGHT) {
+        return;
+    }
+
+    uint tile_y = scrolled_y / TILE_HEIGHT_PX;
+    uint tile_pixel_y = scrolled_y % TILE_HEIGHT_PX;
+    uint tile_data_line_offset = tile_pixel_y * 2;
+
+    for(uint screen_x = 0; screen_x < GAMEBOY_WIDTH; screen_x++) {
+        uint scrolled_x = screen_x + window_x.value() - 7;
+
+        uint tile_x = scrolled_x / TILE_WIDTH_PX;
+        uint tile_pixel_x = scrolled_x % TILE_WIDTH_PX;
+
+        uint tile_index = tile_y * TILES_PER_LINE + tile_x;
+        if(tile_index >= 32 * 32) continue;
+
+        u8 tile_id = video_ram[tile_map_address - 0x8000 + tile_index];
+
+        uint tile_data_mem_offset = use_tile_set_zero ?
+                                        tile_id * TILE_BYTES :
+                                        static_cast<uint>(
+                                            (static_cast<s8>(tile_id) + 128)) *
+                                            TILE_BYTES;
+
+        uint line_addr = (tile_set_address - 0x8000) + tile_data_mem_offset +
+                         tile_data_line_offset;
+
+        u8 pixels_1 = video_ram[line_addr];
+        u8 pixels_2 = video_ram[line_addr + 1];
+
+        u8 pixel_color = get_pixel_from_line(pixels_1, pixels_2, static_cast<u8>(tile_pixel_x));
+        buffer.set_pixel(screen_x, screen_y, get_shade_from_palette(pixel_color, palette));
+    }
+}
+
+void Video::draw_sprite(const uint sprite_n) {
+    /* Each sprite is represented by 4 bytes */
+    u16 oam_start = static_cast<u16>(sprite_n * SPRITE_BYTES);
+
+    u8 sprite_y = gb.mmu.oam_ram[oam_start];
+    u8 sprite_x = gb.mmu.oam_ram[oam_start + 1];
+
+    /* Offscreen sprites are not drawn */
+    if(sprite_y == 0 || sprite_y >= 160) {
+        return;
+    }
+    if(sprite_x == 0 || sprite_x >= 168) {
+        return;
+    }
+
+    uint sprite_height = sprite_size() ? 16 : 8;
+
+    u8 pattern_n = gb.mmu.oam_ram[oam_start + 2];
+    u8 sprite_attrs = gb.mmu.oam_ram[oam_start + 3];
+
+    /* Bits 0-3 are used only for CGB */
+    bool use_palette_1 = check_bit(sprite_attrs, 4);
+    bool flip_x = check_bit(sprite_attrs, 5);
+    bool flip_y = check_bit(sprite_attrs, 6);
+    bool obj_behind_bg = check_bit(sprite_attrs, 7);
+
+    Palette palette = use_palette_1 ? load_palette(sprite_palette_1) :
+                                      load_palette(sprite_palette_0);
+
+    uint tile_offset = pattern_n * TILE_BYTES;
+
+    int start_y = sprite_y - 16;
+    int start_x = sprite_x - 8;
+
+    for(uint y = 0; y < sprite_height; y++) {
+        int screen_y = start_y + static_cast<int>(y);
+        if(screen_y < 0 || screen_y >= static_cast<int>(GAMEBOY_HEIGHT)) continue;
+        if(row_mask && !row_mask[screen_y]) continue;
+
+        uint src_y = !flip_y ? y : sprite_height - y - 1;
+
+        uint line_addr = tile_offset + src_y * 2; /* relative to tile set zero */
+        u8 pixels_1 = video_ram[line_addr];
+        u8 pixels_2 = video_ram[line_addr + 1];
+
+        for(uint x = 0; x < TILE_WIDTH_PX; x++) {
+            int screen_x = start_x + static_cast<int>(x);
+            if(screen_x < 0 || screen_x >= static_cast<int>(GAMEBOY_WIDTH)) continue;
+
+            uint src_x = !flip_x ? x : TILE_WIDTH_PX - x - 1;
+
+            u8 gb_color = get_pixel_from_line(pixels_1, pixels_2, static_cast<u8>(src_x));
+
+            /* Color 0 is transparent */
+            if(gb_color == 0) {
+                continue;
+            }
+
+            Shade existing_pixel = buffer.get_pixel(
+                static_cast<uint>(screen_x), static_cast<uint>(screen_y));
+
+            /* Note: same behaviour as upstream - compares the final shade
+             * rather than the logical color 0 */
+            if(obj_behind_bg && existing_pixel != SHADE_WHITE) {
+                continue;
+            }
+
+            buffer.set_pixel(
+                static_cast<uint>(screen_x),
+                static_cast<uint>(screen_y),
+                get_shade_from_palette(gb_color, palette));
+        }
+    }
+}
+
+auto Video::get_pixel_from_line(u8 byte1, u8 byte2, u8 pixel_index) -> u8 {
+    using bitwise::bit_value;
+
+    return static_cast<u8>(
+        (bit_value(byte2, 7 - pixel_index) << 1) | bit_value(byte1, 7 - pixel_index));
+}
+
+auto Video::load_palette(const ByteRegister& palette_register) -> Palette {
+    u8 v = palette_register.value();
+
+    Palette palette;
+    palette.color0 = static_cast<Shade>(v & 0x3);
+    palette.color1 = static_cast<Shade>((v >> 2) & 0x3);
+    palette.color2 = static_cast<Shade>((v >> 4) & 0x3);
+    palette.color3 = static_cast<Shade>((v >> 6) & 0x3);
+    return palette;
+}
+
+auto Video::get_shade_from_palette(u8 color, const Palette& palette) -> Shade {
+    switch(color) {
+    case 0:
+        return palette.color0;
+    case 1:
+        return palette.color1;
+    case 2:
+        return palette.color2;
+    default:
+        return palette.color3;
+    }
+}
+
+void Video::draw() {
+    if(vblank_callback) vblank_callback(vblank_ctx);
+}

applications/system/FlipperGB/gb/video.h

@@ -0,0 +1,139 @@
+#pragma once
+
+#include "framebuffer.h"
+#include "address.h"
+#include "register.h"
+#include "definitions.h"
+
+class Gameboy;
+
+using vblank_callback_t = void (*)(void* ctx);
+
+enum class VideoMode {
+    ACCESS_OAM,
+    ACCESS_VRAM,
+    HBLANK,
+    VBLANK,
+};
+
+class Video {
+public:
+    Video(Gameboy& inGb);
+
+    void tick(Cycles cycles);
+
+    void register_vblank_callback(vblank_callback_t cb, void* ctx) {
+        vblank_callback = cb;
+        vblank_ctx = ctx;
+    }
+
+    auto vram_read(u16 offset) const -> u8 { return video_ram[offset]; }
+    void vram_write(u16 offset, u8 value) { video_ram[offset] = value; }
+
+    /* When true, scanline/sprite rendering work is skipped (frame skip);
+     * timing, interrupts and register behaviour are unaffected. */
+    bool skip_render = false;
+
+    /* Optional per-scanline render mask (GAMEBOY_HEIGHT entries, 0 = the
+     * frontend never displays this line so its pixels are not rendered).
+     * Purely a display optimization: timing/interrupts are unaffected.
+     * nullptr (default) renders every line. On the Flipper only 64 of the
+     * 144 lines survive the downscale, so ~55% of PPU work is skipped. */
+    const u8* row_mask = nullptr;
+
+    void set_row_mask(const u8* mask) {
+        row_mask = mask;
+        buffer.set_row_map(mask); /* compact storage to the visible rows */
+    }
+
+    auto get_framebuffer() const -> const FrameBuffer& { return buffer; }
+
+    u8 control_byte = 0;
+
+    ByteRegister lcd_control;
+    ByteRegister lcd_status;
+
+    ByteRegister scroll_y;
+    ByteRegister scroll_x;
+
+    ByteRegister line; /* LY */
+    ByteRegister ly_compare;
+
+    ByteRegister window_y;
+    ByteRegister window_x; /* Note: x - 7 */
+
+    ByteRegister bg_palette;
+    ByteRegister sprite_palette_0; /* OBP0 */
+    ByteRegister sprite_palette_1; /* OBP1 */
+
+    ByteRegister dma_transfer; /* DMA */
+
+private:
+    void write_scanline(u8 current_line);
+    void write_sprites();
+    void draw();
+    void draw_bg_line(uint current_line);
+    void draw_window_line(uint current_line);
+    void draw_sprite(uint sprite_n);
+    static auto get_pixel_from_line(u8 byte1, u8 byte2, u8 pixel_index) -> u8;
+
+    static auto is_on_screen(int x, int y) -> bool {
+        return x >= 0 && y >= 0 && x < static_cast<int>(GAMEBOY_WIDTH) &&
+               y < static_cast<int>(GAMEBOY_HEIGHT);
+    }
+
+    auto display_enabled() const -> bool;
+    auto window_tile_map() const -> bool;
+    auto window_enabled() const -> bool;
+    auto bg_window_tile_data() const -> bool;
+    auto bg_tile_map_display() const -> bool;
+    auto sprite_size() const -> bool;
+    auto sprites_enabled() const -> bool;
+    auto bg_enabled() const -> bool;
+
+    static auto load_palette(const ByteRegister& palette_register) -> Palette;
+    static auto get_shade_from_palette(u8 color, const Palette& palette) -> Shade;
+
+    Gameboy& gb;
+
+    FrameBuffer buffer;
+
+    u8 video_ram[0x2000] = {}; /* DMG: 8 KB (was 16 KB upstream) */
+
+    VideoMode current_mode = VideoMode::ACCESS_OAM;
+    uint cycle_counter = 0;
+
+    vblank_callback_t vblank_callback = nullptr;
+    void* vblank_ctx = nullptr;
+};
+
+const uint TILES_PER_LINE = 32;
+const uint TILE_HEIGHT_PX = 8;
+const uint TILE_WIDTH_PX = 8;
+const uint TILE_BYTES = 2 * 8;
+const uint SPRITE_BYTES = 4;
+const uint BG_MAP_SIZE = 256;
+
+const u16 TILE_SET_ZERO_ADDRESS = 0x8000;
+const u16 TILE_SET_ONE_ADDRESS = 0x8800;
+const u16 TILE_MAP_ZERO_ADDRESS = 0x9800;
+const u16 TILE_MAP_ONE_ADDRESS = 0x9C00;
+
+/* All in machine cycles (M-cycles), matching the CPU cycle tables.
+ *
+ * IMPORTANT: upstream had these in T-cycles (204/80/172, 456 per scanline)
+ * while the opcode tables count M-cycles (NOP = 1). The PPU counted M-cycles
+ * against T-cycle constants, so every emulated frame burned 70224 M-cycles
+ * of CPU emulation instead of the hardware-correct 17556: literally 4x the
+ * work per frame (and 4x the timer interrupts per frame). A desktop CPU
+ * hides that; on a 64 MHz Cortex-M4 it was the difference between slideshow
+ * and playable. Real hardware: scanline = 456 T-cycles = 114 M-cycles. */
+const uint CLOCKS_PER_HBLANK = 51; /* Mode 0: 204 T-cycles */
+const uint CLOCKS_PER_SCANLINE_OAM = 20; /* Mode 2: 80 T-cycles */
+const uint CLOCKS_PER_SCANLINE_VRAM = 43; /* Mode 3: 172 T-cycles */
+const uint CLOCKS_PER_SCANLINE =
+    (CLOCKS_PER_SCANLINE_OAM + CLOCKS_PER_SCANLINE_VRAM + CLOCKS_PER_HBLANK);
+
+const uint CLOCKS_PER_VBLANK = 1140; /* Mode 1: 4560 T-cycles */
+const uint SCANLINES_PER_FRAME = 144;
+const uint CLOCKS_PER_FRAME = (CLOCKS_PER_SCANLINE * SCANLINES_PER_FRAME) + CLOCKS_PER_VBLANK;

applications/system/FlipperGB/hosttest/main.cpp

@@ -0,0 +1,188 @@
+/* Host test harness: runs a ROM headless on the PC and captures the serial
+ * output (Blargg's test ROMs print their results through the serial port).
+ * Usage: hosttest <rom.gb> [max_frames] [--dump-frame N]
+ */
+
+#include "../gb/gameboy.h"
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+static u8* g_rom = nullptr;
+static long g_rom_size = 0;
+
+static char g_serial[4096];
+static unsigned g_serial_len = 0;
+
+extern "C" void gb_fatal(const char* msg) {
+    fprintf(stderr, "FATAL: %s\n", msg);
+    exit(2);
+}
+
+static void serial_hook(u8 byte) {
+    if(g_serial_len < sizeof(g_serial) - 1) {
+        g_serial[g_serial_len++] = static_cast<char>(byte);
+        g_serial[g_serial_len] = 0;
+        fputc(byte, stdout);
+        fflush(stdout);
+    }
+}
+
+static const u8* bank_provider(void* /*ctx*/, uint bank) {
+    long offset = static_cast<long>(bank) * 0x4000;
+    if(offset + 0x4000 > g_rom_size) offset = 0;
+    return g_rom + offset;
+}
+
+static FrameBuffer g_last_frame;
+
+static void frame_hook(void* ctx) {
+    g_last_frame = static_cast<Gameboy*>(ctx)->get_framebuffer();
+}
+
+/* Same dominant-voice heuristic the Flipper frontend uses for the piezo */
+static bool pick_voice(Gameboy* gb, ApuVoice* out, int* out_ch) {
+    ApuVoice v;
+    bool have = false;
+    for(uint n = 0; n < 2; n++) {
+        gb->apu.get_voice(n, &v);
+        if(!v.active) continue;
+        if(!have || v.volume > out->volume ||
+           (v.volume == out->volume && v.order > out->order)) {
+            *out = v;
+            *out_ch = (int)n;
+            have = true;
+        }
+    }
+    if(!have) {
+        gb->apu.get_voice(2, &v);
+        if(v.active) {
+            *out = v;
+            *out_ch = 2;
+            have = true;
+        }
+    }
+    if(!have) {
+        gb->apu.get_voice(3, &v);
+        if(v.active) {
+            *out = v;
+            *out_ch = 3;
+            have = true;
+        }
+    }
+    return have;
+}
+
+static void dump_frame_ascii(const FrameBuffer& fb) {
+    const char* shades = " .*#";
+    /* downsample x2 for terminal readability */
+    for(uint y = 0; y < GAMEBOY_HEIGHT; y += 2) {
+        for(uint x = 0; x < GAMEBOY_WIDTH; x += 2) {
+            printf("%c", shades[fb.get_pixel(x, y)]);
+        }
+        printf("\n");
+    }
+}
+
+int main(int argc, char** argv) {
+    if(argc < 2) {
+        fprintf(
+            stderr,
+            "usage: %s <rom.gb> [max_frames] [--dump-frame] [--rowmask] [--dump-audio]\n",
+            argv[0]);
+        return 1;
+    }
+
+    long max_frames = argc > 2 ? atol(argv[2]) : 2000;
+    bool dump = false;
+    bool rowmask = false;
+    bool dump_audio = false;
+    for(int i = 1; i < argc; i++) {
+        if(!strcmp(argv[i], "--dump-frame")) dump = true;
+        if(!strcmp(argv[i], "--rowmask")) rowmask = true;
+        if(!strcmp(argv[i], "--dump-audio")) dump_audio = true;
+    }
+
+    /* Same 144 -> 64 line subsampling the Flipper frontend uses */
+    static u8 mask[GAMEBOY_HEIGHT];
+    for(uint y = 0; y < 64; y++)
+        mask[(y * GAMEBOY_HEIGHT) / 64] = 1;
+
+    FILE* f = fopen(argv[1], "rb");
+    if(!f) {
+        fprintf(stderr, "cannot open %s\n", argv[1]);
+        return 1;
+    }
+    fseek(f, 0, SEEK_END);
+    g_rom_size = ftell(f);
+    fseek(f, 0, SEEK_SET);
+    g_rom = static_cast<u8*>(malloc(static_cast<size_t>(g_rom_size)));
+    if(fread(g_rom, 1, static_cast<size_t>(g_rom_size), f) != static_cast<size_t>(g_rom_size)) {
+        fprintf(stderr, "short read\n");
+        return 1;
+    }
+    fclose(f);
+
+    gb_serial_hook = serial_hook;
+
+    MBCType mbc = Cartridge::parse_mbc(g_rom[0x147]);
+    if(mbc == MBCType::Unsupported) {
+        fprintf(stderr, "unsupported mapper 0x%02X\n", g_rom[0x147]);
+        return 1;
+    }
+    uint banks = Cartridge::rom_bank_count_from_header(g_rom[0x148]);
+    u32 ram_size = Cartridge::ram_size_from_header(g_rom[0x149], mbc);
+    u8* cart_ram = ram_size ? static_cast<u8*>(calloc(1, ram_size)) : nullptr;
+
+    fprintf(
+        stderr,
+        "rom: %ld bytes, mapper=%d, banks=%u, cart_ram=%u\n",
+        g_rom_size,
+        static_cast<int>(mbc),
+        banks,
+        ram_size);
+
+    auto* gb = new Gameboy(g_rom, banks, mbc, cart_ram, ram_size, bank_provider, nullptr);
+    gb->set_frame_callback(frame_hook, gb);
+    if(rowmask) gb->set_row_mask(mask);
+
+    u32 last_freq = 0;
+    int last_ch = -1;
+    u8 last_vol = 0;
+
+    for(long frame = 0; frame < max_frames; frame++) {
+        gb->run_to_vblank();
+
+        if(dump_audio) {
+            ApuVoice v;
+            int ch = -1;
+            bool have = pick_voice(gb, &v, &ch);
+            u32 f = have ? v.freq_hz : 0;
+            u8 vol = have ? v.volume : 0;
+            if(f != last_freq || ch != last_ch || vol != last_vol) {
+                if(have)
+                    printf("f=%05ld ch%d %5u Hz vol=%2u\n", frame, ch, f, vol);
+                else
+                    printf("f=%05ld silence\n", frame);
+                last_freq = f;
+                last_ch = ch;
+                last_vol = vol;
+            }
+        }
+
+        if(strstr(g_serial, "Passed") || strstr(g_serial, "Failed")) {
+            /* let it print the tail */
+            for(int i = 0; i < 30; i++)
+                gb->run_to_vblank();
+            break;
+        }
+    }
+
+    if(dump) dump_frame_ascii(g_last_frame);
+
+    printf("\n");
+    if(strstr(g_serial, "Passed")) return 0;
+    if(strstr(g_serial, "Failed")) return 3;
+    return 4; /* no verdict */
+}

applications/system/FlipperGB/main.cpp

@@ -0,0 +1,942 @@
+/* FlipGB - Game Boy (DMG) emulator frontend for Flipper Zero.
+ *
+ * Frontend responsibilities:
+ *  - ROM picker (system file browser), ROM header parsing
+ *  - ROM bank streaming from SD with an LRU cache (whole ROM loaded to RAM
+ *    when it fits)
+ *  - 160x144 2bpp -> 128x64 1bpp ordered-dither downscale
+ *  - input mapping (OK=A, Back=B, Up+Down together = emulator menu)
+ *  - emulator menu: Start/Select injection, frameskip, save SRAM, exit
+ *  - battery save (.sav) persistence next to the ROM
+ */
+
+#include <furi.h>
+#include <furi_hal.h>
+#include <gui/gui.h>
+#include <input/input.h>
+#include <dialogs/dialogs.h>
+#include <storage/storage.h>
+
+#include <stdlib.h>
+#include <string.h>
+#include <new>
+
+#include "gb/gameboy.h"
+
+#define SCREEN_W 128
+#define SCREEN_H 64
+#define BUFFER_SIZE (SCREEN_W * SCREEN_H / 8)
+
+#define GB_FRAME_US 16742 /* 59.73 Hz */
+#define BANK_SIZE 0x4000u
+/* Heap kept free for the GUI/system while playing. 10 KB is enough for the
+ * direct-draw takeover + input subscription + background services; the old
+ * 24 KB reserve was more than one whole ROM bank of wasted headroom and
+ * pushed big cartridges (1 MB MBC3 + 32 KB SRAM) into "Not enough RAM". */
+#define HEAP_RESERVE (10u * 1024u)
+#define ALLOC_MARGIN 1024u /* never take the very last heap block */
+
+/* On the Flipper malloc() does NOT return NULL on failure: it crashes the
+ * whole firmware with "out of memory". Every allocation whose size depends
+ * on the ROM must go through this wrapper, which checks the largest free
+ * heap block first (total free heap is not enough: fragmentation can make
+ * a big contiguous allocation impossible even with plenty of free bytes). */
+static void* safe_malloc(size_t size) {
+    if(memmgr_heap_get_max_free_block() < size + ALLOC_MARGIN) return NULL;
+    return malloc(size);
+}
+
+/* ------------------------------------------------------------------ state */
+
+/* GB button bits used between the input callback and the main loop */
+enum {
+    KBIT_UP = 1 << 0,
+    KBIT_DOWN = 1 << 1,
+    KBIT_LEFT = 1 << 2,
+    KBIT_RIGHT = 1 << 3,
+    KBIT_A = 1 << 4,
+    KBIT_B = 1 << 5,
+};
+
+/* ROM bank cache.
+ *
+ * Every switchable bank lives in its own 16 KB heap block: there is no
+ * "whole ROM in one contiguous malloc" fast path any more, because a large
+ * contiguous allocation is exactly what fails (and used to crash the
+ * firmware) on a fragmented heap. Instead:
+ *
+ *  - as many 16 KB slots as the heap safely affords are allocated up front;
+ *  - if every switchable bank got a slot, the ROM is fully resident: bank
+ *    lookup is a direct O(1) index and the SD file is closed;
+ *  - otherwise the slots form an LRU cache streaming banks from SD.
+ */
+typedef struct {
+    File* file; /* NULL once the ROM is fully resident */
+    u8* bank0;
+    u8** slots; /* num_slots pointers to 16 KB blocks */
+    u16* slot_bank; /* which bank each slot holds (0 = empty) */
+    u32* slot_use; /* LRU stamps (streaming mode only) */
+    u32 use_counter;
+    u16 num_slots;
+    u16 banks;
+    bool fully_loaded; /* slots[i] permanently holds bank i+1 */
+} RomCache;
+
+typedef struct {
+    uint8_t screen[BUFFER_SIZE]; /* 1bpp page-format, bit set = light */
+
+    Gui* gui;
+    Canvas* canvas;
+    FuriMutex* fb_mutex;
+
+    volatile uint8_t keys; /* KBIT_* currently pressed */
+    volatile bool menu_requested;
+    volatile bool menu_active;
+    volatile bool exit_requested;
+
+    Gameboy* gb;
+    RomCache rom;
+    u8* cart_ram;
+    u32 cart_ram_size;
+    bool has_battery;
+
+    /* sound (single-tone piezo fed with the dominant APU voice) */
+    bool sound_enabled;
+    bool speaker_acquired;
+    uint32_t tone_freq; /* currently playing tone, 0 = silent */
+    uint8_t tone_vol; /* 0..15, scaled by master volume */
+
+    /* menu */
+    int menu_cursor;
+    uint8_t menu_last_keys;
+    int frameskip_setting; /* -1 = auto, 0..4 fixed */
+    int inject_start_frames;
+    int inject_select_frames;
+    char rom_title[17];
+    char status_msg[32];
+
+    /* pacing */
+    uint32_t emu_ms_ema; /* x16 fixed point */
+    int auto_skip;
+    int skip_phase;
+} AppState;
+
+static AppState* g_app = NULL;
+
+static volatile uint32_t s_input_cb_inflight = 0;
+static volatile uint32_t s_fb_cb_inflight = 0;
+
+static inline void wait_inflight_zero(volatile uint32_t* counter) {
+    while(__atomic_load_n(counter, __ATOMIC_ACQUIRE) != 0) {
+        furi_delay_ms(1);
+    }
+}
+
+extern "C" [[noreturn]] void gb_fatal(const char* msg) {
+    furi_crash(msg);
+}
+
+/* ------------------------------------------------------- rom bank provider */
+
+static const u8* rom_bank_provider(void* ctx, uint bank) {
+    RomCache* rc = (RomCache*)ctx;
+
+    if(bank == 0) return rc->bank0;
+
+    if(rc->fully_loaded) {
+        return rc->slots[bank - 1]; /* O(1), the whole ROM is resident */
+    }
+
+    /* cache lookup */
+    u16 lru = 0;
+    u32 lru_use = 0xFFFFFFFFu;
+    for(u16 i = 0; i < rc->num_slots; i++) {
+        if(rc->slot_bank[i] == bank) {
+            rc->slot_use[i] = ++rc->use_counter;
+            return rc->slots[i];
+        }
+        if(rc->slot_use[i] < lru_use) {
+            lru_use = rc->slot_use[i];
+            lru = i;
+        }
+    }
+
+    /* miss: stream the bank from SD into the LRU slot */
+    storage_file_seek(rc->file, (u32)bank * BANK_SIZE, true);
+    size_t got = storage_file_read(rc->file, rc->slots[lru], BANK_SIZE);
+    if(got < BANK_SIZE) {
+        /* short read (SD hiccup / truncated ROM): open-bus instead of
+         * stale data from whatever bank lived here before */
+        memset(rc->slots[lru] + got, 0xFF, BANK_SIZE - got);
+    }
+    rc->slot_bank[lru] = (u16)bank;
+    rc->slot_use[lru] = ++rc->use_counter;
+    return rc->slots[lru];
+}
+
+/* -------------------------------------------------------------- rendering */
+
+/* Destination -> source coordinate maps (128 <- 160, 64 <- 144) */
+static uint8_t s_xmap[SCREEN_W];
+static uint8_t s_ymap[SCREEN_H];
+
+/* Scanlines that actually survive the 144 -> 64 downscale. Handed to the
+ * emulator core so the PPU skips the other 80 lines entirely (~55% less
+ * rendering work per frame). */
+static u8 s_rowmask[GAMEBOY_HEIGHT];
+
+/* light/dark decision per (y-parity, x-parity, shade): 2x2 ordered dither.
+ * white -> lit, light gray -> 3/4 lit, dark gray -> 1/4 lit, black -> off */
+static uint8_t s_dither[2][2][4];
+
+static void init_scale_maps(void) {
+    for(int x = 0; x < SCREEN_W; x++)
+        s_xmap[x] = (uint8_t)((x * (int)GAMEBOY_WIDTH) / SCREEN_W);
+    for(int y = 0; y < SCREEN_H; y++)
+        s_ymap[y] = (uint8_t)((y * (int)GAMEBOY_HEIGHT) / SCREEN_H);
+
+    memset(s_rowmask, 0, sizeof(s_rowmask));
+    for(int y = 0; y < SCREEN_H; y++)
+        s_rowmask[s_ymap[y]] = 1;
+
+    for(int py = 0; py < 2; py++) {
+        for(int px = 0; px < 2; px++) {
+            s_dither[py][px][0] = 1;
+            s_dither[py][px][1] = (px == 1 && py == 1) ? 0 : 1;
+            s_dither[py][px][2] = (px == 0 && py == 0) ? 1 : 0;
+            s_dither[py][px][3] = 0;
+        }
+    }
+}
+
+/* Called by the core on every vblank, before the framebuffer is cleared.
+ * Converts 4 shades -> 1 bit with a 2x2 ordered dither. */
+static void frame_callback(void* ctx) {
+    AppState* app = (AppState*)ctx;
+    const u8* raw = app->gb->get_framebuffer().raw(); /* packed 2bpp */
+
+    furi_mutex_acquire(app->fb_mutex, FuriWaitForever);
+
+    uint8_t* dst = app->screen;
+    for(int y = 0; y < SCREEN_H; y++) {
+        /* storage is compacted to the 64 displayed rows in ascending order
+         * (GB_FB_ROWS=64 + row mask), so displayed row y == storage slot y */
+        uint base = (uint)y * GAMEBOY_WIDTH;
+        uint8_t bit = (uint8_t)(1u << (y & 7));
+        uint8_t nbit = (uint8_t)~bit;
+        uint8_t* row = dst + (y >> 3) * SCREEN_W;
+        const uint8_t(*dither)[4] = s_dither[y & 1];
+
+        for(int x = 0; x < SCREEN_W; x++) {
+            uint i = base + s_xmap[x];
+            uint s = (raw[i >> 2] >> ((i & 3) << 1)) & 0x3;
+            if(dither[x & 1][s])
+                row[x] |= bit;
+            else
+                row[x] &= nbit;
+        }
+    }
+
+    furi_mutex_release(app->fb_mutex);
+}
+
+static void framebuffer_commit_callback(
+    uint8_t* data,
+    size_t size,
+    CanvasOrientation orientation,
+    void* context) {
+    __atomic_fetch_add(&s_fb_cb_inflight, 1, __ATOMIC_RELAXED);
+
+    AppState* app = (AppState*)context;
+    (void)orientation;
+
+    if(!app || !data || size < BUFFER_SIZE || app->menu_active) {
+        /* in menu mode the canvas content (drawn with canvas_*) passes
+         * through untouched */
+        __atomic_fetch_sub(&s_fb_cb_inflight, 1, __ATOMIC_RELAXED);
+        return;
+    }
+
+    if(furi_mutex_acquire(app->fb_mutex, 0) != FuriStatusOk) {
+        __atomic_fetch_sub(&s_fb_cb_inflight, 1, __ATOMIC_RELAXED);
+        return;
+    }
+
+    /* screen buffer: bit=1 means light; display buffer: bit=1 means dark */
+    const uint8_t* src = app->screen;
+    for(size_t i = 0; i < BUFFER_SIZE; i++) {
+        data[i] = (uint8_t)(src[i] ^ 0xFF);
+    }
+
+    furi_mutex_release(app->fb_mutex);
+    __atomic_fetch_sub(&s_fb_cb_inflight, 1, __ATOMIC_RELAXED);
+}
+
+/* ------------------------------------------------------------------ input */
+
+static void input_events_callback(const void* value, void* ctx) {
+    if(!value || !ctx) return;
+
+    __atomic_fetch_add(&s_input_cb_inflight, 1, __ATOMIC_RELAXED);
+
+    AppState* app = (AppState*)ctx;
+    const InputEvent* event = (const InputEvent*)value;
+
+    uint8_t bit = 0;
+    switch(event->key) {
+    case InputKeyUp:
+        bit = KBIT_UP;
+        break;
+    case InputKeyDown:
+        bit = KBIT_DOWN;
+        break;
+    case InputKeyLeft:
+        bit = KBIT_LEFT;
+        break;
+    case InputKeyRight:
+        bit = KBIT_RIGHT;
+        break;
+    case InputKeyOk:
+        bit = KBIT_A;
+        break;
+    case InputKeyBack:
+        bit = KBIT_B;
+        break;
+    default:
+        break;
+    }
+
+    if(bit) {
+        if((event->type == InputTypePress) || (event->type == InputTypeRepeat)) {
+            uint8_t keys =
+                (uint8_t)__atomic_or_fetch((uint8_t*)&app->keys, bit, __ATOMIC_RELAXED);
+            /* Up+Down together: physically impossible on a real GB d-pad,
+             * so it is our reserved menu gesture */
+            if((keys & (KBIT_UP | KBIT_DOWN)) == (KBIT_UP | KBIT_DOWN)) {
+                app->menu_requested = true;
+            }
+        } else if(event->type == InputTypeRelease) {
+            (void)__atomic_fetch_and((uint8_t*)&app->keys, (uint8_t)~bit, __ATOMIC_RELAXED);
+        }
+    }
+
+    __atomic_fetch_sub(&s_input_cb_inflight, 1, __ATOMIC_RELAXED);
+}
+
+/* Apply the current key snapshot to the emulated joypad (edge based) */
+static void apply_input(AppState* app, uint8_t* last_applied) {
+    uint8_t now = app->menu_active ? 0 : app->keys;
+    uint8_t changed = (uint8_t)(now ^ *last_applied);
+    if(!changed && !app->inject_start_frames && !app->inject_select_frames) return;
+
+    struct {
+        uint8_t bit;
+        GbButton btn;
+    } map[] = {
+        {KBIT_UP, GbButton::Up},
+        {KBIT_DOWN, GbButton::Down},
+        {KBIT_LEFT, GbButton::Left},
+        {KBIT_RIGHT, GbButton::Right},
+        {KBIT_A, GbButton::A},
+        {KBIT_B, GbButton::B},
+    };
+
+    for(auto& m : map) {
+        if(!(changed & m.bit)) continue;
+        if(now & m.bit)
+            app->gb->button_pressed(m.btn);
+        else
+            app->gb->button_released(m.btn);
+    }
+
+    /* menu-injected Start/Select presses (held for a few frames) */
+    if(app->inject_start_frames > 0) {
+        app->inject_start_frames--;
+        if(app->inject_start_frames == 0)
+            app->gb->button_released(GbButton::Start);
+    }
+    if(app->inject_select_frames > 0) {
+        app->inject_select_frames--;
+        if(app->inject_select_frames == 0)
+            app->gb->button_released(GbButton::Select);
+    }
+
+    *last_applied = now;
+}
+
+/* ------------------------------------------------------------------ sound */
+
+/* The Flipper piezo plays one frequency at one volume at a time, so the
+ * 4 APU channels are reduced to the "dominant voice":
+ *   1. the louder of the two pulse channels (they carry the melody in
+ *      almost every GB soundtrack); newer trigger wins ties (lead line)
+ *   2. otherwise the wave channel (bass/secondary melody)
+ *   3. otherwise noise (percussion), mapped to a short low buzz
+ * Updated once per emulated frame (~60 Hz), like a tracker row. */
+static void sound_update(AppState* app, bool force_silent) {
+    if(!app->speaker_acquired) return;
+
+    ApuVoice best = {false, 0, 0, 0};
+    bool have = false;
+
+    if(!force_silent && app->sound_enabled && !app->menu_active) {
+        ApuVoice v;
+        /* pulse 1 / pulse 2 */
+        for(uint n = 0; n < 2; n++) {
+            app->gb->apu.get_voice(n, &v);
+            if(!v.active) continue;
+            if(!have || v.volume > best.volume ||
+               (v.volume == best.volume && v.order > best.order)) {
+                best = v;
+                have = true;
+            }
+        }
+        /* wave */
+        if(!have) {
+            app->gb->apu.get_voice(2, &v);
+            if(v.active) {
+                best = v;
+                have = true;
+            }
+        }
+        /* noise: LFSR clock -> percussive buzz in the piezo's low range */
+        if(!have) {
+            app->gb->apu.get_voice(3, &v);
+            if(v.active) {
+                uint32_t f = v.freq_hz >> 5;
+                if(f < 80) f = 80;
+                if(f > 400) f = 400;
+                v.freq_hz = f;
+                best = v;
+                have = true;
+            }
+        }
+    }
+
+    if(have) {
+        uint32_t f = best.freq_hz;
+        if(f < 40 || f > 12000) {
+            have = false; /* outside anything the piezo can render */
+        } else {
+            uint8_t master = app->gb->apu.master_volume(); /* 0..7 */
+            uint8_t vol = (uint8_t)((best.volume * (master + 1)) >> 3); /* 0..15 */
+            if(vol == 0) {
+                have = false;
+            } else if(f != app->tone_freq || vol != app->tone_vol) {
+                furi_hal_speaker_start((float)f, (float)vol / 15.0f);
+                app->tone_freq = f;
+                app->tone_vol = vol;
+            }
+        }
+    }
+
+    if(!have && app->tone_freq) {
+        furi_hal_speaker_stop();
+        app->tone_freq = 0;
+        app->tone_vol = 0;
+    }
+}
+
+/* ------------------------------------------------------------------- save */
+
+static void save_path_for_rom(FuriString* rom_path, FuriString* out) {
+    /* parentheses bypass the C11 _Generic macro (not usable from C++) */
+    (furi_string_set)(out, rom_path);
+    furi_string_cat_str(out, ".sav");
+}
+
+static bool save_sram(AppState* app, Storage* storage, FuriString* sav_path) {
+    if(!app->cart_ram || !app->cart_ram_size || !app->has_battery) return false;
+
+    File* f = storage_file_alloc(storage);
+    bool ok = false;
+    if(storage_file_open(f, furi_string_get_cstr(sav_path), FSAM_WRITE, FSOM_CREATE_ALWAYS)) {
+        ok = storage_file_write(f, app->cart_ram, app->cart_ram_size) == app->cart_ram_size;
+        storage_file_close(f);
+    }
+    storage_file_free(f);
+    return ok;
+}
+
+static void load_sram(AppState* app, Storage* storage, FuriString* sav_path) {
+    if(!app->cart_ram || !app->cart_ram_size) return;
+
+    File* f = storage_file_alloc(storage);
+    if(storage_file_open(f, furi_string_get_cstr(sav_path), FSAM_READ, FSOM_OPEN_EXISTING)) {
+        storage_file_read(f, app->cart_ram, app->cart_ram_size);
+        storage_file_close(f);
+    }
+    storage_file_free(f);
+}
+
+/* ------------------------------------------------------------------- menu */
+
+#define MENU_ITEMS 7
+
+static void menu_draw(AppState* app) {
+    Canvas* c = app->canvas;
+    canvas_reset(c);
+    canvas_clear(c);
+
+    canvas_set_font(c, FontPrimary);
+    canvas_draw_str(c, 2, 10, app->rom_title[0] ? app->rom_title : "FlipGB");
+    canvas_draw_line(c, 0, 12, 127, 12);
+
+    static const char* labels[MENU_ITEMS] = {
+        "Continue",
+        "Press START",
+        "Press SELECT",
+        "Frameskip",
+        "Sound",
+        "Save SRAM",
+        "Exit",
+    };
+
+    canvas_set_font(c, FontSecondary);
+
+    for(int i = 0; i < MENU_ITEMS; i++) {
+        /* 7 px pitch keeps all 7 items on the 64 px screen */
+        int y = 20 + i * 7;
+        if(i == app->menu_cursor) {
+            canvas_draw_str(c, 2, y, ">");
+        }
+        canvas_draw_str(c, 10, y, labels[i]);
+
+        if(i == 3) {
+            char buf[12];
+            if(app->frameskip_setting < 0)
+                snprintf(buf, sizeof(buf), "auto(%d)", app->auto_skip);
+            else
+                snprintf(buf, sizeof(buf), "%d", app->frameskip_setting);
+            canvas_draw_str(c, 72, y, buf);
+        }
+        if(i == 4) {
+            canvas_draw_str(
+                c, 72, y, !app->speaker_acquired ? "n/a" : (app->sound_enabled ? "on" : "off"));
+        }
+    }
+
+    if(app->status_msg[0]) {
+        canvas_draw_str(c, 70, 10, app->status_msg);
+    } else {
+        /* free heap indicator: helps spotting memory pressure on device */
+        char rambuf[16];
+        snprintf(rambuf, sizeof(rambuf), "%uk free", (unsigned)(memmgr_get_free_heap() / 1024u));
+        canvas_draw_str_aligned(c, 126, 10, AlignRight, AlignBottom, rambuf);
+    }
+
+    canvas_commit(c);
+}
+
+/* returns true while the menu stays open */
+static bool menu_tick(AppState* app, Storage* storage, FuriString* sav_path) {
+    uint8_t keys = app->keys;
+    uint8_t pressed = (uint8_t)(keys & ~app->menu_last_keys);
+    app->menu_last_keys = keys;
+
+    if(pressed & KBIT_UP) {
+        app->menu_cursor = (app->menu_cursor + MENU_ITEMS - 1) % MENU_ITEMS;
+        app->status_msg[0] = 0;
+    }
+    if(pressed & KBIT_DOWN) {
+        app->menu_cursor = (app->menu_cursor + 1) % MENU_ITEMS;
+        app->status_msg[0] = 0;
+    }
+
+    if(pressed & (KBIT_LEFT | KBIT_RIGHT)) {
+        if(app->menu_cursor == 3) {
+            /* cycle: auto, 0, 1, 2, 3, 4 */
+            int v = app->frameskip_setting;
+            if(pressed & KBIT_RIGHT)
+                v = (v >= 4) ? -1 : v + 1;
+            else
+                v = (v <= -1) ? 4 : v - 1;
+            app->frameskip_setting = v;
+        }
+        if(app->menu_cursor == 4 && app->speaker_acquired) {
+            app->sound_enabled = !app->sound_enabled;
+        }
+    }
+
+    if(pressed & KBIT_B) return false; /* Back closes the menu */
+
+    if(pressed & KBIT_A) {
+        switch(app->menu_cursor) {
+        case 0:
+            return false;
+        case 1:
+            app->gb->button_pressed(GbButton::Start);
+            app->inject_start_frames = 8;
+            return false;
+        case 2:
+            app->gb->button_pressed(GbButton::Select);
+            app->inject_select_frames = 8;
+            return false;
+        case 3:
+            break;
+        case 4:
+            if(app->speaker_acquired) app->sound_enabled = !app->sound_enabled;
+            break;
+        case 5:
+            if(app->has_battery) {
+                bool ok = save_sram(app, storage, sav_path);
+                snprintf(app->status_msg, sizeof(app->status_msg), ok ? "saved!" : "error");
+            } else {
+                snprintf(app->status_msg, sizeof(app->status_msg), "no battery");
+            }
+            break;
+        case 6:
+            app->exit_requested = true;
+            return false;
+        }
+    }
+
+    menu_draw(app);
+    return true;
+}
+
+/* -------------------------------------------------------------- rom setup */
+
+typedef enum {
+    RomLoadOk,
+    RomLoadIoError,
+    RomLoadCgbOnly,
+    RomLoadBadMapper,
+    RomLoadNoMem,
+} RomLoadResult;
+
+static RomLoadResult
+    rom_load(AppState* app, Storage* storage, const char* path, MBCType* out_mbc) {
+    RomCache* rc = &app->rom;
+
+    rc->file = storage_file_alloc(storage);
+    if(!storage_file_open(rc->file, path, FSAM_READ, FSOM_OPEN_EXISTING)) {
+        return RomLoadIoError;
+    }
+
+    /* bank 0 stays resident and contains the header */
+    rc->bank0 = (u8*)safe_malloc(BANK_SIZE);
+    if(!rc->bank0) return RomLoadNoMem;
+    memset(rc->bank0, 0xFF, BANK_SIZE);
+    if(storage_file_read(rc->file, rc->bank0, BANK_SIZE) < 0x150) {
+        return RomLoadIoError;
+    }
+
+    /* header */
+    u8 cgb_flag = rc->bank0[0x143];
+    if(cgb_flag == 0xC0) return RomLoadCgbOnly;
+
+    MBCType mbc = Cartridge::parse_mbc(rc->bank0[0x147]);
+    if(mbc == MBCType::Unsupported) return RomLoadBadMapper;
+    *out_mbc = mbc;
+
+    memcpy(app->rom_title, &rc->bank0[0x134], 16);
+    app->rom_title[16] = 0;
+    for(int i = 0; i < 16; i++) {
+        char ch = app->rom_title[i];
+        if(ch != 0 && (ch < 0x20 || ch > 0x7E)) app->rom_title[i] = 0;
+    }
+
+    rc->banks = (u16)Cartridge::rom_bank_count_from_header(rc->bank0[0x148]);
+    app->has_battery = Cartridge::has_battery(rc->bank0[0x147]);
+
+    /* cartridge RAM */
+    app->cart_ram_size = Cartridge::ram_size_from_header(rc->bank0[0x149], mbc);
+    if(app->cart_ram_size) {
+        app->cart_ram = (u8*)safe_malloc(app->cart_ram_size);
+        if(!app->cart_ram) return RomLoadNoMem;
+        memset(app->cart_ram, 0, app->cart_ram_size);
+    }
+
+    /* Allocate as many 16 KB bank slots as the heap safely affords.
+     *
+     * IMPORTANT: the emulator core (Gameboy: 8K VRAM + 8K WRAM + packed
+     * framebuffer + CPU state, ~22 KB) plus the GUI takeover (mutex, canvas,
+     * input subscription) are allocated AFTER the ROM cache, so room for
+     * them is reserved up front. Each slot is its own allocation: no huge
+     * contiguous block is ever requested, which makes the loader immune to
+     * heap fragmentation (the old single-malloc full-ROM path could crash
+     * the firmware even when the total free heap looked sufficient). */
+    u32 switchable = (u32)(rc->banks - 1);
+    const size_t reserve = HEAP_RESERVE + sizeof(Gameboy) + 1024 /* alloc slack */;
+
+    /* slot bookkeeping arrays (a few bytes per slot) */
+    size_t free_heap = memmgr_get_free_heap();
+    u32 max_slots = (u32)(free_heap / BANK_SIZE) + 1;
+    if(max_slots > switchable) max_slots = switchable;
+    if(max_slots < 1) max_slots = 1;
+
+    rc->slots = (u8**)safe_malloc(max_slots * sizeof(u8*));
+    rc->slot_bank = (u16*)safe_malloc(max_slots * sizeof(u16));
+    rc->slot_use = (u32*)safe_malloc(max_slots * sizeof(u32));
+    if(!rc->slots || !rc->slot_bank || !rc->slot_use) return RomLoadNoMem;
+
+    rc->num_slots = 0;
+    while((u32)rc->num_slots < max_slots) {
+        if(memmgr_get_free_heap() < reserve + BANK_SIZE + ALLOC_MARGIN) break;
+        u8* slot = (u8*)safe_malloc(BANK_SIZE);
+        if(!slot) break;
+        rc->slots[rc->num_slots] = slot;
+        rc->slot_bank[rc->num_slots] = 0; /* bank 0 never lives in a slot */
+        rc->slot_use[rc->num_slots] = 0;
+        rc->num_slots++;
+    }
+
+    /* not even one 16 KB slot fits: fail gracefully with the
+     * "Not enough RAM" dialog instead of crashing inside malloc() */
+    if(rc->num_slots == 0) return RomLoadNoMem;
+
+    if((u32)rc->num_slots >= switchable) {
+        /* every switchable bank fits: preload the whole ROM and close the
+         * SD file (O(1) bank switching, zero stutter, frees the handle) */
+        storage_file_seek(rc->file, BANK_SIZE, true);
+        for(u32 i = 0; i < switchable; i++) {
+            size_t got = storage_file_read(rc->file, rc->slots[i], BANK_SIZE);
+            if(got < BANK_SIZE) memset(rc->slots[i] + got, 0xFF, BANK_SIZE - got);
+            rc->slot_bank[i] = (u16)(i + 1);
+        }
+        rc->fully_loaded = true;
+        storage_file_close(rc->file);
+        storage_file_free(rc->file);
+        rc->file = NULL;
+    }
+
+    return RomLoadOk;
+}
+
+static void rom_free(AppState* app) {
+    RomCache* rc = &app->rom;
+    for(u16 i = 0; i < rc->num_slots; i++)
+        if(rc->slots[i]) free(rc->slots[i]);
+    if(rc->slots) free(rc->slots);
+    if(rc->slot_bank) free(rc->slot_bank);
+    if(rc->slot_use) free(rc->slot_use);
+    if(rc->bank0) free(rc->bank0);
+    if(rc->file) {
+        storage_file_close(rc->file);
+        storage_file_free(rc->file);
+    }
+    memset(rc, 0, sizeof(*rc));
+}
+
+/* ------------------------------------------------------------------- main */
+
+extern "C" int32_t flipgb_app(void* p) {
+    UNUSED(p);
+
+    AppState* app = (AppState*)malloc(sizeof(AppState));
+    if(!app) return -1;
+    memset(app, 0, sizeof(AppState));
+    app->frameskip_setting = -1; /* auto */
+    g_app = app;
+
+    init_scale_maps();
+
+    Storage* storage = (Storage*)furi_record_open(RECORD_STORAGE);
+    DialogsApp* dialogs = (DialogsApp*)furi_record_open(RECORD_DIALOGS);
+
+    FuriString* rom_path = furi_string_alloc_set_str("/ext");
+    FuriString* sav_path = furi_string_alloc();
+
+    Gui* gui = NULL;
+    Canvas* canvas = NULL;
+    FuriPubSub* input_events = NULL;
+    FuriPubSubSubscription* input_sub = NULL;
+    bool fb_cb_added = false;
+
+    do {
+        /* --- pick a ROM with the stock file browser (normal GUI mode) --- */
+        DialogsFileBrowserOptions browser_options;
+        dialog_file_browser_set_basic_options(&browser_options, ".gb", NULL);
+        browser_options.base_path = "/ext";
+        browser_options.hide_ext = false;
+
+        if(!dialog_file_browser_show(dialogs, rom_path, rom_path, &browser_options)) {
+            break; /* cancelled */
+        }
+
+        MBCType mbc = MBCType::None;
+        RomLoadResult res = rom_load(app, storage, furi_string_get_cstr(rom_path), &mbc);
+
+        if(res != RomLoadOk) {
+            DialogMessage* msg = dialog_message_alloc();
+            const char* text = "ROM load failed";
+            if(res == RomLoadCgbOnly) text = "Game Boy Color only\nROM: not supported";
+            if(res == RomLoadBadMapper) text = "Unsupported mapper";
+            if(res == RomLoadNoMem) text = "Not enough RAM";
+            dialog_message_set_text(msg, text, 64, 30, AlignCenter, AlignCenter);
+            dialog_message_set_buttons(msg, NULL, "OK", NULL);
+            dialog_message_show(dialogs, msg);
+            dialog_message_free(msg);
+            break;
+        }
+
+        save_path_for_rom(rom_path, sav_path);
+        load_sram(app, storage, sav_path);
+
+        /* --- construct the emulator --- */
+        app->fb_mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+        if(!app->fb_mutex) break;
+
+        /* rom_load reserved room for this, but double-check anyway: on the
+         * Flipper an unchecked new/malloc crashes the firmware on OOM */
+        void* gb_mem = safe_malloc(sizeof(Gameboy));
+        if(!gb_mem) {
+            DialogMessage* msg = dialog_message_alloc();
+            dialog_message_set_text(msg, "Not enough RAM", 64, 30, AlignCenter, AlignCenter);
+            dialog_message_set_buttons(msg, NULL, "OK", NULL);
+            dialog_message_show(dialogs, msg);
+            dialog_message_free(msg);
+            break;
+        }
+        app->gb = new(gb_mem) Gameboy(
+            app->rom.bank0,
+            app->rom.banks,
+            mbc,
+            app->cart_ram,
+            app->cart_ram_size,
+            rom_bank_provider,
+            &app->rom);
+        app->gb->set_frame_callback(frame_callback, app);
+        app->gb->set_row_mask(s_rowmask);
+
+        /* --- sound: piezo plays the dominant APU voice --- */
+        app->speaker_acquired = furi_hal_speaker_acquire(50);
+        app->sound_enabled = app->speaker_acquired;
+
+        /* --- take over the display --- */
+        gui = (Gui*)furi_record_open(RECORD_GUI);
+        if(!gui) break;
+        app->gui = gui;
+
+        gui_add_framebuffer_callback(gui, framebuffer_commit_callback, app);
+        fb_cb_added = true;
+
+        canvas = gui_direct_draw_acquire(gui);
+        if(!canvas) break;
+        app->canvas = canvas;
+
+        input_events = (FuriPubSub*)furi_record_open(RECORD_INPUT_EVENTS);
+        if(!input_events) break;
+        input_sub = furi_pubsub_subscribe(input_events, input_events_callback, app);
+        if(!input_sub) break;
+
+        /* --- main loop --- */
+        uint8_t last_applied_keys = 0;
+        uint32_t frame_deadline_us = 0;
+        uint32_t last_now_ms = furi_get_tick();
+        app->emu_ms_ema = 16 << 4;
+
+        while(!app->exit_requested) {
+            /* ------ menu mode ------ */
+            if(app->menu_requested) {
+                app->menu_requested = false;
+                app->menu_active = true;
+                app->menu_cursor = 0;
+                app->menu_last_keys = app->keys; /* no spurious edges from held keys */
+                app->status_msg[0] = 0;
+                /* lift all buttons for the game, mute while paused */
+                apply_input(app, &last_applied_keys);
+                sound_update(app, true);
+                menu_draw(app);
+
+                while(app->menu_active && !app->exit_requested) {
+                    if(!menu_tick(app, storage, sav_path)) {
+                        app->menu_active = false;
+                    }
+                    furi_delay_ms(33);
+                }
+                frame_deadline_us = 0;
+                last_now_ms = furi_get_tick();
+                continue;
+            }
+
+            /* ------ decide frameskip ------ */
+            int skip_n = app->frameskip_setting >= 0 ? app->frameskip_setting : app->auto_skip;
+            bool render_this = app->skip_phase == 0;
+            app->skip_phase = (app->skip_phase + 1) % (skip_n + 1);
+
+            /* ------ run one emulated frame ------ */
+            apply_input(app, &last_applied_keys);
+            app->gb->set_skip_render(!render_this);
+
+            uint32_t t0 = furi_get_tick();
+            app->gb->run_to_vblank();
+            uint32_t emu_ms = furi_get_tick() - t0;
+
+            /* refresh the piezo with this frame's dominant APU voice */
+            sound_update(app, false);
+
+            /* EMA of the cost of one emulated frame (x16 fixed point) */
+            app->emu_ms_ema += ((emu_ms << 4) - app->emu_ms_ema) / 8;
+            uint32_t ema_ms = app->emu_ms_ema >> 4;
+            app->auto_skip = ema_ms <= 17 ? 0 : (int)((ema_ms - 1) / 17);
+            if(app->auto_skip > 4) app->auto_skip = 4;
+
+            if(render_this && !app->menu_active) {
+                canvas_commit(canvas);
+            }
+
+            /* ------ pacing: aim for 59.73 Hz wall time ------ */
+            uint32_t now = furi_get_tick();
+            uint32_t elapsed_us = (now - last_now_ms) * 1000u;
+            last_now_ms = now;
+
+            if(frame_deadline_us > elapsed_us) {
+                frame_deadline_us -= elapsed_us;
+            } else {
+                frame_deadline_us = 0;
+            }
+            frame_deadline_us += GB_FRAME_US;
+
+            /* cap the backlog so a long stall doesn't fast-forward */
+            if(frame_deadline_us > 4 * GB_FRAME_US) frame_deadline_us = 4 * GB_FRAME_US;
+
+            if(frame_deadline_us > GB_FRAME_US + 2000) {
+                uint32_t sleep_ms = (frame_deadline_us - GB_FRAME_US) / 1000u;
+                furi_delay_ms(sleep_ms);
+            } else if(emu_ms == 0) {
+                furi_delay_ms(1);
+            }
+        }
+
+        /* auto-save battery RAM on exit */
+        if(app->has_battery) save_sram(app, storage, sav_path);
+    } while(false);
+
+    /* --- teardown --- */
+    if(app->speaker_acquired) {
+        furi_hal_speaker_stop();
+        furi_hal_speaker_release();
+        app->speaker_acquired = false;
+    }
+    if(input_sub && input_events) furi_pubsub_unsubscribe(input_events, input_sub);
+    wait_inflight_zero(&s_input_cb_inflight);
+    if(input_events) furi_record_close(RECORD_INPUT_EVENTS);
+
+    if(fb_cb_added) gui_remove_framebuffer_callback(gui, framebuffer_commit_callback, app);
+    wait_inflight_zero(&s_fb_cb_inflight);
+
+    if(gui) {
+        if(canvas) gui_direct_draw_release(gui);
+        furi_record_close(RECORD_GUI);
+    }
+
+    if(app->gb) {
+        app->gb->~Gameboy(); /* placement-new counterpart */
+        free(app->gb);
+    }
+    rom_free(app);
+    if(app->cart_ram) free(app->cart_ram);
+    if(app->fb_mutex) furi_mutex_free(app->fb_mutex);
+
+    furi_string_free(rom_path);
+    furi_string_free(sav_path);
+    furi_record_close(RECORD_DIALOGS);
+    furi_record_close(RECORD_STORAGE);
+
+    free(app);
+    g_app = NULL;
+
+    return 0;
+}

applications/system/Garage Door Remote/.clang-format

@@ -1,246 +0,0 @@
----
-Language:        Cpp
-AccessModifierOffset: -4
-AlignAfterOpenBracket: AlwaysBreak
-AlignArrayOfStructures: None
-AlignConsecutiveAssignments:
-  Enabled:         false
-  AcrossEmptyLines: false
-  AcrossComments:  false
-  AlignCompound:   false
-  AlignFunctionPointers: false
-  PadOperators:    true
-AlignConsecutiveBitFields:
-  Enabled:         true
-  AcrossEmptyLines: true
-  AcrossComments:  true
-  AlignCompound:   false
-  AlignFunctionPointers: false
-  PadOperators:    true
-AlignConsecutiveDeclarations:
-  Enabled:         false
-  AcrossEmptyLines: false
-  AcrossComments:  false
-  AlignCompound:   false
-  AlignFunctionPointers: false
-  PadOperators:    true
-AlignConsecutiveMacros:
-  Enabled:         true
-  AcrossEmptyLines: false
-  AcrossComments:  true
-  AlignCompound:   true
-  AlignFunctionPointers: false
-  PadOperators:    true
-AlignConsecutiveShortCaseStatements:
-  Enabled:         false
-  AcrossEmptyLines: false
-  AcrossComments:  false
-  AlignCaseColons: false
-AlignEscapedNewlines: Left
-AlignOperands:   Align
-AlignTrailingComments:
-  Kind:            Never
-  OverEmptyLines:  0
-AllowAllArgumentsOnNextLine: true
-AllowAllParametersOfDeclarationOnNextLine: false
-AllowBreakBeforeNoexceptSpecifier: Never
-AllowShortBlocksOnASingleLine: Never
-AllowShortCaseLabelsOnASingleLine: false
-AllowShortCompoundRequirementOnASingleLine: true
-AllowShortEnumsOnASingleLine: false
-AllowShortFunctionsOnASingleLine: None
-AllowShortIfStatementsOnASingleLine: WithoutElse
-AllowShortLambdasOnASingleLine: All
-AllowShortLoopsOnASingleLine: false
-AlwaysBreakAfterDefinitionReturnType: None
-AlwaysBreakAfterReturnType: None
-AlwaysBreakBeforeMultilineStrings: false
-AlwaysBreakTemplateDeclarations: Yes
-AttributeMacros:
-  - __capability
-BinPackArguments: false
-BinPackParameters: false
-BitFieldColonSpacing: Both
-BraceWrapping:
-  AfterCaseLabel:  false
-  AfterClass:      false
-  AfterControlStatement: Never
-  AfterEnum:       false
-  AfterExternBlock: false
-  AfterFunction:   false
-  AfterNamespace:  false
-  AfterObjCDeclaration: false
-  AfterStruct:     false
-  AfterUnion:      false
-  BeforeCatch:     false
-  BeforeElse:      false
-  BeforeLambdaBody: false
-  BeforeWhile:     false
-  IndentBraces:    false
-  SplitEmptyFunction: true
-  SplitEmptyRecord: true
-  SplitEmptyNamespace: true
-BreakAdjacentStringLiterals: true
-BreakAfterAttributes: Leave
-BreakAfterJavaFieldAnnotations: false
-BreakArrays:     true
-BreakBeforeBinaryOperators: None
-BreakBeforeConceptDeclarations: Always
-BreakBeforeBraces: Attach
-BreakBeforeInlineASMColon: OnlyMultiline
-BreakBeforeTernaryOperators: false
-BreakConstructorInitializers: BeforeComma
-BreakInheritanceList: BeforeColon
-BreakStringLiterals: false
-ColumnLimit:     99
-CommentPragmas:  '^ IWYU pragma:'
-CompactNamespaces: false
-ConstructorInitializerIndentWidth: 4
-ContinuationIndentWidth: 4
-Cpp11BracedListStyle: true
-DerivePointerAlignment: false
-DisableFormat:   false
-EmptyLineAfterAccessModifier: Never
-EmptyLineBeforeAccessModifier: LogicalBlock
-ExperimentalAutoDetectBinPacking: false
-FixNamespaceComments: false
-ForEachMacros:
-  - foreach
-  - Q_FOREACH
-  - BOOST_FOREACH
-  - M_EACH
-IfMacros:
-  - KJ_IF_MAYBE
-IncludeBlocks:   Preserve
-IncludeCategories:
-  - Regex:           '.*'
-    Priority:        1
-    SortPriority:    0
-    CaseSensitive:   false
-  - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
-    Priority:        3
-    SortPriority:    0
-    CaseSensitive:   false
-  - Regex:           '.*'
-    Priority:        1
-    SortPriority:    0
-    CaseSensitive:   false
-IncludeIsMainRegex: '(Test)?$'
-IncludeIsMainSourceRegex: ''
-IndentAccessModifiers: false
-IndentCaseBlocks: false
-IndentCaseLabels: false
-IndentExternBlock: AfterExternBlock
-IndentGotoLabels: true
-IndentPPDirectives: None
-IndentRequiresClause: false
-IndentWidth:     4
-IndentWrappedFunctionNames: true
-InsertBraces:    false
-InsertNewlineAtEOF: true
-InsertTrailingCommas: None
-IntegerLiteralSeparator:
-  Binary:          0
-  BinaryMinDigits: 0
-  Decimal:         0
-  DecimalMinDigits: 0
-  Hex:             0
-  HexMinDigits:    0
-JavaScriptQuotes: Leave
-JavaScriptWrapImports: true
-KeepEmptyLinesAtTheStartOfBlocks: false
-KeepEmptyLinesAtEOF: false
-LambdaBodyIndentation: Signature
-LineEnding:      DeriveLF
-MacroBlockBegin: ''
-MacroBlockEnd:   ''
-MaxEmptyLinesToKeep: 1
-NamespaceIndentation: None
-ObjCBinPackProtocolList: Auto
-ObjCBlockIndentWidth: 4
-ObjCBreakBeforeNestedBlockParam: true
-ObjCSpaceAfterProperty: true
-ObjCSpaceBeforeProtocolList: true
-PackConstructorInitializers: BinPack
-PenaltyBreakAssignment: 10
-PenaltyBreakBeforeFirstCallParameter: 30
-PenaltyBreakComment: 10
-PenaltyBreakFirstLessLess: 0
-PenaltyBreakOpenParenthesis: 0
-PenaltyBreakScopeResolution: 500
-PenaltyBreakString: 10
-PenaltyBreakTemplateDeclaration: 10
-PenaltyExcessCharacter: 100
-PenaltyIndentedWhitespace: 0
-PenaltyReturnTypeOnItsOwnLine: 60
-PointerAlignment: Left
-PPIndentWidth:   -1
-QualifierAlignment: Leave
-ReferenceAlignment: Pointer
-ReflowComments:  false
-RemoveBracesLLVM: false
-RemoveParentheses: Leave
-RemoveSemicolon: true
-RequiresClausePosition: OwnLine
-RequiresExpressionIndentation: OuterScope
-SeparateDefinitionBlocks: Leave
-ShortNamespaceLines: 1
-SkipMacroDefinitionBody: false
-SortIncludes:    Never
-SortJavaStaticImport: Before
-SortUsingDeclarations: Never
-SpaceAfterCStyleCast: false
-SpaceAfterLogicalNot: false
-SpaceAfterTemplateKeyword: true
-SpaceAroundPointerQualifiers: Default
-SpaceBeforeAssignmentOperators: true
-SpaceBeforeCaseColon: false
-SpaceBeforeCpp11BracedList: false
-SpaceBeforeCtorInitializerColon: true
-SpaceBeforeInheritanceColon: true
-SpaceBeforeJsonColon: false
-SpaceBeforeParens: Never
-SpaceBeforeParensOptions:
-  AfterControlStatements: false
-  AfterForeachMacros: false
-  AfterFunctionDefinitionName: false
-  AfterFunctionDeclarationName: false
-  AfterIfMacros:   false
-  AfterOverloadedOperator: false
-  AfterPlacementOperator: true
-  AfterRequiresInClause: false
-  AfterRequiresInExpression: false
-  BeforeNonEmptyParentheses: false
-SpaceBeforeRangeBasedForLoopColon: true
-SpaceBeforeSquareBrackets: false
-SpaceInEmptyBlock: false
-SpacesBeforeTrailingComments: 1
-SpacesInAngles:  Never
-SpacesInContainerLiterals: false
-SpacesInLineCommentPrefix:
-  Minimum:         1
-  Maximum:         -1
-SpacesInParens:  Never
-SpacesInParensOptions:
-  InCStyleCasts:   false
-  InConditionalStatements: false
-  InEmptyParentheses: false
-  Other:           false
-SpacesInSquareBrackets: false
-Standard:        c++20
-StatementAttributeLikeMacros:
-  - Q_EMIT
-StatementMacros:
-  - Q_UNUSED
-  - QT_REQUIRE_VERSION
-TabWidth:        4
-UseTab:          Never
-VerilogBreakBetweenInstancePorts: true
-WhitespaceSensitiveMacros:
-  - STRINGIZE
-  - PP_STRINGIZE
-  - BOOST_PP_STRINGIZE
-  - NS_SWIFT_NAME
-  - CF_SWIFT_NAME
-...
-

applications/system/Garage Door Remote/LICENSE

@@ -1,674 +0,0 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-the GNU General Public License is intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.  We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors.  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights.  Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received.  You must make sure that they, too, receive
-or can get the source code.  And you must show them these terms so they
-know their rights.
-
-  Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-
-  For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software.  For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Use with the GNU Affero General Public License.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-    <program>  Copyright (C) <year>  <name of author>
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-<https://www.gnu.org/licenses/>.
-
-  The GNU General Public License does not permit incorporating your program
-into proprietary programs.  If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.  But first, please read
-<https://www.gnu.org/licenses/why-not-lgpl.html>.

applications/system/Garage Door Remote/README.md

@@ -1,130 +0,0 @@
-# **ProtoPirate**
-
-### _for Flipper Zero_
-
-## **⚠️ Warning: Important Security & Project Update**
-Read message by following link below:
-
-https://protopirate.net/ProtoPirate
-
-Main repo is located at: https://protopirate.net/ProtoPirate/ProtoPirate 
-
-All others are read only mirrors!
-
-
-ProtoPirate is an experimental rolling-code analysis toolkit developed by members of **The Pirates' Plunder**.
-
-The app currently supports decoding for multiple automotive key-fob families (Kia, Ford, Subaru, Suzuki, VW, and more), with the goal of being a drop-in Flipper app (.fap) that is free, open source, and can be used on any Flipper Zero firmware. 
-
-App is intended for educational and security purposes only, and has no signal transmission enabled by default. This prevents users from accidentally desyncing their keyfobs, making it safe for non-specialists.
-
-## **Supported Protocols**
-
-Protocols are split into **AM** and **FM** registries. The active registry is chosen from the receiver selected preset.
-
-### **AM protocols**
-
-
-| Protocol                 | Decoder | Encoder | Signal Encoding | Modulation | Encryption                     | CRC          | Frequency       |
-| ------------------------ | ------- | ------- | --------------- | ---------- | ------------------------------ | ------------ | --------------- |
-| Chrysler V0              | ✅       | ✅       | PWM             | AM650      | Rolling Code                   | Checksum     | 315.00 / 433.92 |
-| Fiat V0                  | ✅       | ✅       | Manchester      | AM650      | Rolling Code (static emu only) | ❌            | 315.00 / 433.92 |
-| Fiat V1                  | ✅       | ❌       | Manchester      | AM650      | Rolling Code                   | CRC8         | 315.00 / 433.92 |
-| Ford V0                  | ✅       | ✅       | Manchester      | AM650      | Rolling Code                   | ✅ + Checksum | 315.00 / 433.92 |
-| Honda V1                 | ✅       | ✅       | Manchester      | AM650      | Rolling Code                   | CRC4         | 315.00 / 433.92 |
-| Kia V1                   | ✅       | ✅       | Manchester      | AM650      | Rolling Code                   | CRC4         | 315.00 / 433.92 |
-| Porsche Touareg          | ✅       | ❌       | PWM             | AM650      | Rolling Code                   | ❌            | 315.00 / 433.92 |
-| PSA (Peugeot/Citroen)    | ✅       | ✅       | Manchester      | AM650      | XTEA/XOR                       | CRC8         | 315.00 / 433.92 |
-| StarLine                 | ✅       | ✅       | PWM             | AM650      | KeeLoq                         | ❌            | 315.00 / 433.92 |
-| Subaru                   | ✅       | ✅       | PPM             | AM650      | Rolling Code                   | ❌            | 315.00 / 433.92 |
-| VAG (VW/Audi/Seat/Skoda) | ✅       | ✅       | Manchester      | AM650      | AUT64/XTEA                     | ❌            | 434.42          |
-
-
-### **FM protocols**
-
-
-| Protocol                      | Decoder | Encoder | Signal Encoding | Modulation | Encryption                   | CRC        | Frequency       |
-| ----------------------------- | ------- | ------- | --------------- | ---------- | ---------------------------- | ---------- | --------------- |
-| Ford V1                       | ✅       | ✅       | Manchester      | F4         | Rolling Code                 | CRC16      | 315.00 / 433.92 |
-| Ford V2                       | ✅       | ✅       | Manchester      | F4         | Rolling Code (simple replay) | ❌          | 434.25          |
-| Ford V3                       | ✅       | ❌       | Manchester      | F4         | Rolling Code                 | ❌          | 434.25          |
-| Honda Static                  | ✅       | ✅       | PWM             | Honda1     | Static Code                  | Checksum   | 315.00 / 433.92 |
-| Kia V0 / Suzuki V0 / Honda V0 | ✅       | ✅       | PWM             | FM476      | Rolling Code                 | CRC8       | 315.00 / 433.92 |
-| Kia V2                        | ✅       | ✅       | Manchester      | FM476      | Rolling Code                 | CRC4       | 315.00 / 433.92 |
-| Kia V3 / V4                   | ✅       | ✅       | PWM             | FM476      | KeeLoq                       | CRC4 (BF)  | 315.00 / 433.92 |
-| Kia V5                        | ✅       | ✅       | PWM             | FM476      | Rolling Code                 | ✅          | 315.00 / 433.92 |
-| Kia V6                        | ✅       | ✅       | Manchester      | FM476      | AES128                       | CRC8       | 315.00 / 433.92 |
-| Kia V7                        | ✅       | ✅       | Manchester      | FM476      | Rolling Code                 | CRC8       | 315.00 / 433.92 |
-| Land Rover V0                 | ✅       | ✅       | PWM             | F4         | Rolling Code                 | Check+Tail | 315.00 / 433.92 |
-| Mazda V0                      | ✅       | ✅       | Manchester      | FM (F2?)   | Rolling Code                 | Checksum   | 315.00 / 433.92 |
-| Mitsubishi V0                 | ✅       | ❌       | PWM             | FM476      | Rolling Code                 | ❌          | 315.00 / 433.92 |
-| PSA (Peugeot/Citroen)         | ✅       | ✅       | Manchester      | FM (F3?)   | XTEA/XOR                     | CRC8       | 315.00 / 433.92 |
-| Scher-Khan                    | ✅       | ❌       | PWM             | FM         | Magic Code                   | ❌          | 315.00 / 433.92 |
-
-
-*More Coming Soon*
-
-## **Features**
-
-### 📡 Protocol Receiver
-
-Real-time signal capture and decoding with animated radar display. Supports frequency hopping.
-
-### 📂 Sub Decode
-
-Load and analyze existing `.sub` files from your SD card. Browse `/ext/subghz/` to decode previously captured signals.
-
-### ⏱️ Timing Tuner
-
-Tool for protocol developers to compare real fob signal timing against protocol definitions.
-
-- **Protocol Definition**: Expected short/long pulse durations and tolerance
-- **Received Signal**: Measured timing from real fob (avg, min, max, sample count)
-- **Analysis**: Difference from expected, jitter measurements
-- **Conclusion**: Whether timing matches or needs adjustment with specific recommendations
-
-## **Credits**
-
-The following contributors are recognized for helping us keep open sourced projects and the freeware community alive.
-
-### **App Development**
-
-- RocketGod
-- MMX
-- Leeroy
-- gullradriel
-- Skorp - Thanks, I sneaked a lot from Weather App!
-- Vadim's Radio Driver
-
-### **Protocol Magic**
-
-- L0rdDiakon
-- YougZ
-- RocketGod
-- MMX
-- DoobTheGoober
-- Skorp
-- Slackware
-- Trikk
-- Wootini
-- Li0ard
-- Leeroy
-- Ash
-
-### **Reverse Engineering Support**
-
-- DoobTheGoober
-- MMX
-- NeedNotApply
-- RocketGod
-- Slackware
-- Trikk
-- Li0ard
-
-## **Community & Support**
-
-Join **The Pirates' Plunder** on Discord for development updates, testing, protocol research, community support, and a bunch of badasses doing fun shit:
-
-➡️ **[https://discord.gg/thepirates](https://discord.gg/thepirates)**
-
-<img alt="rocketgod_logo_transparent" src="https://github.com/user-attachments/assets/ad15b106-152c-4a60-a9e2-4d40dfa8f3c6" />

applications/system/Garage Door Remote/application.fam

@@ -3,42 +3,42 @@ App(
     name="Garage Door Remote",
     apptype=FlipperAppType.EXTERNAL,
     targets=["f7"],
-    entry_point="protopirate_app",
+    entry_point="gdr_app",
     requires=["gui"],
-    stack_size=4 * 1024,
+    stack_size=8 * 1024,
     fap_description="Capture and emulate garage and gate remote signals from Sub-GHz",
     fap_version="2.6",
-    fap_icon="images/protopirate_10px.png",
+    fap_icon="images/gdr_10x10.png",
     fap_category="Sub-GHz",
     fap_icon_assets="images",
     fap_file_assets="keystore",
     sources=[
-        "protopirate_app.c",
-        "protopirate_app_i.c",
-        "protopirate_history.c",
-        "helpers/protopirate_psa_bf_host.c",
-        "helpers/protopirate_settings.c",
-        "helpers/protopirate_storage.c",
+        "gdr_app.c",
+        "gdr_app_i.c",
+        "gdr_history.c",
+        "helpers/gdr_psa_bf_host.c",
+        "helpers/gdr_settings.c",
+        "helpers/gdr_storage.c",
         "helpers/radio_device_loader.c",
         "helpers/raw_file_reader.c",
-        "scenes/protopirate_scene.c",
-        "scenes/protopirate_scene_about.c",
-        "scenes/protopirate_scene_dual_receiver.c",
-        "scenes/protopirate_scene_dual_receiver_config.c",
-        "scenes/protopirate_scene_emulate.c",
-        "scenes/protopirate_scene_need_saving.c",
-        "scenes/protopirate_scene_receiver.c",
-        "scenes/protopirate_scene_receiver_config.c",
-        "scenes/protopirate_scene_receiver_info.c",
-        "scenes/protopirate_scene_saved.c",
-        "scenes/protopirate_scene_saved_info.c",
-        "scenes/protopirate_scene_shield_receiver.c",
-        "scenes/protopirate_scene_shield_receiver_config.c",
-        "scenes/protopirate_scene_start.c",
-        "scenes/protopirate_scene_sub_decode.c",
-        "scenes/protopirate_scene_timing_tuner.c",
-        "views/protopirate_dual_receiver.c",
-        "views/protopirate_receiver.c",
+        "scenes/gdr_scene.c",
+        "scenes/gdr_scene_about.c",
+        "scenes/gdr_scene_dual_receiver.c",
+        "scenes/gdr_scene_dual_receiver_config.c",
+        "scenes/gdr_scene_emulate.c",
+        "scenes/gdr_scene_need_saving.c",
+        "scenes/gdr_scene_receiver.c",
+        "scenes/gdr_scene_receiver_config.c",
+        "scenes/gdr_scene_receiver_info.c",
+        "scenes/gdr_scene_saved.c",
+        "scenes/gdr_scene_saved_info.c",
+        "scenes/gdr_scene_shield_receiver.c",
+        "scenes/gdr_scene_shield_receiver_config.c",
+        "scenes/gdr_scene_start.c",
+        "scenes/gdr_scene_sub_decode.c",
+        "scenes/gdr_scene_timing_tuner.c",
+        "views/gdr_dual_receiver.c",
+        "views/gdr_receiver.c",
         "protocols/protocol_items.c",
         "protocols/protocols_common.c",
         "protocols/keys.c",
@@ -46,12 +46,12 @@ App(
 )
 
 App(
-    appid="protopirate_am_plugin",
+    appid="gdr_am_plugin",
     apptype=FlipperAppType.PLUGIN,
-    entry_point="protopirate_am_plugin_ep",
+    entry_point="gdr_am_plugin_ep",
     requires=["garage_door_remote"],
     sources=[
-        "protocols/plugins/protopirate_am_plugin.c",
+        "protocols/plugins/gdr_am_plugin.c",
         "protocols/protocols_common.c",
         "protocols/keys.c",
         "protocols/alutech_at_4n.c",
@@ -79,12 +79,12 @@ App(
 )
 
 App(
-    appid="protopirate_fm_plugin",
+    appid="gdr_fm_plugin",
     apptype=FlipperAppType.PLUGIN,
-    entry_point="protopirate_fm_plugin_ep",
+    entry_point="gdr_fm_plugin_ep",
     requires=["garage_door_remote"],
     sources=[
-        "protocols/plugins/protopirate_fm_plugin.c",
+        "protocols/plugins/gdr_fm_plugin.c",
         "protocols/protocols_common.c",
         "protocols/keys.c",
         "protocols/ansonic.c",
@@ -93,38 +93,12 @@ App(
 )
 
 App(
-    appid="protopirate_emulate_plugin",
+    appid="gdr_emulate_plugin",
     apptype=FlipperAppType.PLUGIN,
-    entry_point="protopirate_emulate_plugin_ep",
+    entry_point="gdr_emulate_plugin_ep",
     requires=["garage_door_remote"],
     sources=[
-        "scenes/plugins/protopirate_emulate_plugin.c",
-    ],
-    fal_embedded=True,
-)
-
-
-App(
-    appid="protopirate_fm_plugin",
-    apptype=FlipperAppType.PLUGIN,
-    entry_point="protopirate_fm_plugin_ep",
-    requires=["garage_door_remote"],
-    sources=[
-        "protocols/plugins/protopirate_fm_plugin.c",
-        "protocols/protocols_common.c",
-        "protocols/keys.c",
-        "protocols/ansonic.c",
-    ],
-    fal_embedded=True,
-)
-
-App(
-    appid="protopirate_emulate_plugin",
-    apptype=FlipperAppType.PLUGIN,
-    entry_point="protopirate_emulate_plugin_ep",
-    requires=["garage_door_remote"],
-    sources=[
-        "scenes/plugins/protopirate_emulate_plugin.c",
+        "scenes/plugins/gdr_emulate_plugin.c",
     ],
     fal_embedded=True,
 )

applications/system/Garage Door Remote/gdr_app.c

@@ -1,20 +1,20 @@
-// protopirate_app.c
-#include "protopirate_app_i.h"
+// gdr_app.c
+#include "gdr_app_i.h"
 
 #include <furi.h>
 #include <furi_hal.h>
 #include "protocols/protocol_items.h"
 #include "protocols/protocols_common.h"
-#include "helpers/protopirate_settings.h"
-#include "helpers/protopirate_storage.h"
-#include "helpers/protopirate_psa_bf_host.h"
+#include "helpers/gdr_settings.h"
+#include "helpers/gdr_storage.h"
+#include "helpers/gdr_psa_bf_host.h"
 #include "protocols/keys.h"
 #include <string.h>
 
-#define TAG "ProtoPirateApp"
+#define TAG "GDRApp"
 
 #if defined(ENABLE_DUAL_RX_SCENE) || defined(ENABLE_SHIELD_RX_SCENE)
-static bool protopirate_setting_has_frequency(SubGhzSetting* setting, uint32_t frequency) {
+static bool gdr_setting_has_frequency(SubGhzSetting* setting, uint32_t frequency) {
     size_t count = subghz_setting_get_frequency_count(setting);
     for(size_t i = 0; i < count; i++) {
         if(subghz_setting_get_frequency(setting, i) == frequency) {
@@ -26,27 +26,27 @@ static bool protopirate_setting_has_frequency(SubGhzSetting* setting, uint32_t f
 #endif
 
 #ifdef ENABLE_DUAL_RX_SCENE
-static ProtoPirateProtocolRegistryFilter protopirate_setting_preset_filter(
+static GDRProtocolRegistryFilter gdr_setting_preset_filter(
     SubGhzSetting* setting,
     uint8_t index) {
-    return protopirate_get_protocol_registry_filter_for_preset(
+    return gdr_get_protocol_registry_filter_for_preset(
         subghz_setting_get_preset_data(setting, index),
         subghz_setting_get_preset_data_size(setting, index));
 }
 
-static uint8_t protopirate_find_preset_by_name_or_filter(
+static uint8_t gdr_find_preset_by_name_or_filter(
     SubGhzSetting* setting,
     const char* preferred_name,
-    ProtoPirateProtocolRegistryFilter filter) {
+    GDRProtocolRegistryFilter filter) {
     size_t count = subghz_setting_get_preset_count(setting);
     for(size_t i = 0; i < count; i++) {
         if(strcmp(subghz_setting_get_preset_name(setting, i), preferred_name) == 0 &&
-           protopirate_setting_preset_filter(setting, (uint8_t)i) == filter) {
+           gdr_setting_preset_filter(setting, (uint8_t)i) == filter) {
             return (uint8_t)i;
         }
     }
     for(size_t i = 0; i < count; i++) {
-        if(protopirate_setting_preset_filter(setting, (uint8_t)i) == filter) {
+        if(gdr_setting_preset_filter(setting, (uint8_t)i) == filter) {
             return (uint8_t)i;
         }
     }
@@ -54,7 +54,7 @@ static uint8_t protopirate_find_preset_by_name_or_filter(
 }
 
 static uint8_t
-    protopirate_find_preset_by_name(SubGhzSetting* setting, const char* preset_name) {
+    gdr_find_preset_by_name(SubGhzSetting* setting, const char* preset_name) {
     if(!preset_name || preset_name[0] == '\0') {
         return UINT8_MAX;
     }
@@ -69,25 +69,25 @@ static uint8_t
 }
 #endif
 
-static bool protopirate_app_custom_event_callback(void* context, uint32_t event) {
+static bool gdr_app_custom_event_callback(void* context, uint32_t event) {
     furi_check(context);
-    ProtoPirateApp* app = context;
+    GDRApp* app = context;
     return scene_manager_handle_custom_event(app->scene_manager, event);
 }
 
-static bool protopirate_app_back_event_callback(void* context) {
+static bool gdr_app_back_event_callback(void* context) {
     furi_check(context);
-    ProtoPirateApp* app = context;
+    GDRApp* app = context;
     return scene_manager_handle_back_event(app->scene_manager);
 }
 
-static void protopirate_app_tick_event_callback(void* context) {
+static void gdr_app_tick_event_callback(void* context) {
     furi_check(context);
-    ProtoPirateApp* app = context;
+    GDRApp* app = context;
     scene_manager_handle_tick_event(app->scene_manager);
 }
 
-bool protopirate_ensure_variable_item_list(ProtoPirateApp* app) {
+bool gdr_ensure_variable_item_list(GDRApp* app) {
     furi_check(app);
     if(app->variable_item_list) {
         return true;
@@ -100,12 +100,12 @@ bool protopirate_ensure_variable_item_list(ProtoPirateApp* app) {
 
     view_dispatcher_add_view(
         app->view_dispatcher,
-        ProtoPirateViewVariableItemList,
+        GDRViewVariableItemList,
         variable_item_list_get_view(app->variable_item_list));
     return true;
 }
 
-bool protopirate_ensure_widget(ProtoPirateApp* app) {
+bool gdr_ensure_widget(GDRApp* app) {
     furi_check(app);
     if(app->widget) {
         return true;
@@ -117,11 +117,11 @@ bool protopirate_ensure_widget(ProtoPirateApp* app) {
     }
 
     view_dispatcher_add_view(
-        app->view_dispatcher, ProtoPirateViewWidget, widget_get_view(app->widget));
+        app->view_dispatcher, GDRViewWidget, widget_get_view(app->widget));
     return true;
 }
 
-bool protopirate_ensure_text_input(ProtoPirateApp* app) {
+bool gdr_ensure_text_input(GDRApp* app) {
     furi_check(app);
     if(app->text_input) {
         return true;
@@ -133,11 +133,11 @@ bool protopirate_ensure_text_input(ProtoPirateApp* app) {
     }
 
     view_dispatcher_add_view(
-        app->view_dispatcher, ProtoPirateViewTextInput, text_input_get_view(app->text_input));
+        app->view_dispatcher, GDRViewTextInput, text_input_get_view(app->text_input));
     return true;
 }
 
-bool protopirate_ensure_view_about(ProtoPirateApp* app) {
+bool gdr_ensure_view_about(GDRApp* app) {
     furi_check(app);
     if(app->view_about) {
         return true;
@@ -148,49 +148,49 @@ bool protopirate_ensure_view_about(ProtoPirateApp* app) {
         return false;
     }
 
-    view_dispatcher_add_view(app->view_dispatcher, ProtoPirateViewAbout, app->view_about);
+    view_dispatcher_add_view(app->view_dispatcher, GDRViewAbout, app->view_about);
     return true;
 }
 
-bool protopirate_ensure_receiver_view(ProtoPirateApp* app) {
+bool gdr_ensure_receiver_view(GDRApp* app) {
     furi_check(app);
-    if(app->protopirate_receiver) {
+    if(app->gdr_receiver) {
         return true;
     }
 
-    app->protopirate_receiver = protopirate_view_receiver_alloc(app->auto_save);
-    if(!app->protopirate_receiver) {
+    app->gdr_receiver = gdr_view_receiver_alloc(app->auto_save);
+    if(!app->gdr_receiver) {
         return false;
     }
 
     view_dispatcher_add_view(
         app->view_dispatcher,
-        ProtoPirateViewReceiver,
-        protopirate_view_receiver_get_view(app->protopirate_receiver));
+        GDRViewReceiver,
+        gdr_view_receiver_get_view(app->gdr_receiver));
     return true;
 }
 
 #ifdef ENABLE_DUAL_RX_SCENE
-bool protopirate_ensure_dual_receiver_view(ProtoPirateApp* app) {
+bool gdr_ensure_dual_receiver_view(GDRApp* app) {
     furi_check(app);
     if(app->dual_receiver) {
         return true;
     }
 
-    app->dual_receiver = protopirate_view_dual_receiver_alloc();
+    app->dual_receiver = gdr_view_dual_receiver_alloc();
     if(!app->dual_receiver) {
         return false;
     }
 
     view_dispatcher_add_view(
         app->view_dispatcher,
-        ProtoPirateViewDualReceiver,
-        protopirate_view_dual_receiver_get_view(app->dual_receiver));
+        GDRViewDualReceiver,
+        gdr_view_dual_receiver_get_view(app->dual_receiver));
     return true;
 }
 #endif
 
-static void protopirate_radio_init_cleanup(ProtoPirateApp* app, bool devices_initialized) {
+static void gdr_radio_init_cleanup(GDRApp* app, bool devices_initialized) {
     furi_check(app);
     furi_check(app->txrx);
 
@@ -228,21 +228,21 @@ static void protopirate_radio_init_cleanup(ProtoPirateApp* app, bool devices_ini
 
     app->txrx->protocol_registry = NULL;
     app->txrx->protocol_plugin = NULL;
-    app->txrx->protocol_registry_filter = ProtoPirateProtocolRegistryFilterAM;
-    app->txrx->txrx_state = ProtoPirateTxRxStateIDLE;
+    app->txrx->protocol_registry_filter = GDRProtocolRegistryFilterAM;
+    app->txrx->txrx_state = GDRTxRxStateIDLE;
     app->radio_initialized = false;
 }
 
-ProtoPirateApp* protopirate_app_alloc() {
-    protopirate_storage_purge_temp_history_at_startup();
-    ProtoPirateApp* app = malloc(sizeof(ProtoPirateApp));
+GDRApp* gdr_app_alloc() {
+    gdr_storage_purge_temp_history_at_startup();
+    GDRApp* app = malloc(sizeof(GDRApp));
     if(!app) {
-        FURI_LOG_E(TAG, "Failed to allocate ProtoPirateApp app !");
+        FURI_LOG_E(TAG, "Failed to allocate GDRApp app !");
         return NULL;
     }
-    memset(app, 0, sizeof(ProtoPirateApp));
+    memset(app, 0, sizeof(GDRApp));
 
-    FURI_LOG_I(TAG, "Allocating ProtoPirate Decoder App");
+    FURI_LOG_I(TAG, "Allocating GDR Decoder App");
 
     // GUI
     app->gui = furi_record_open(RECORD_GUI);
@@ -252,15 +252,15 @@ ProtoPirateApp* protopirate_app_alloc() {
 #if defined(FW_ORIGIN_RM)
     view_dispatcher_enable_queue(app->view_dispatcher);
 #endif
-    app->scene_manager = scene_manager_alloc(&protopirate_scene_handlers, app);
+    app->scene_manager = scene_manager_alloc(&gdr_scene_handlers, app);
 
     view_dispatcher_set_event_callback_context(app->view_dispatcher, app);
     view_dispatcher_set_custom_event_callback(
-        app->view_dispatcher, protopirate_app_custom_event_callback);
+        app->view_dispatcher, gdr_app_custom_event_callback);
     view_dispatcher_set_navigation_event_callback(
-        app->view_dispatcher, protopirate_app_back_event_callback);
+        app->view_dispatcher, gdr_app_back_event_callback);
     view_dispatcher_set_tick_event_callback(
-        app->view_dispatcher, protopirate_app_tick_event_callback, 100);
+        app->view_dispatcher, gdr_app_tick_event_callback, 100);
 
     view_dispatcher_attach_to_gui(app->view_dispatcher, app->gui, ViewDispatcherTypeFullscreen);
 
@@ -273,7 +273,7 @@ ProtoPirateApp* protopirate_app_alloc() {
     // SubMenu
     app->submenu = submenu_alloc();
     view_dispatcher_add_view(
-        app->view_dispatcher, ProtoPirateViewSubmenu, submenu_get_view(app->submenu));
+        app->view_dispatcher, GDRViewSubmenu, submenu_get_view(app->submenu));
 
     app->save_protocol = NULL;
     app->save_from_saved_info = false;
@@ -283,11 +283,11 @@ ProtoPirateApp* protopirate_app_alloc() {
 
     // File Browser path
     app->file_path = furi_string_alloc();
-    furi_string_set(app->file_path, PROTOPIRATE_APP_FOLDER);
+    furi_string_set(app->file_path, GDR_APP_FOLDER);
 
     // Load saved settings
-    ProtoPirateSettings settings;
-    protopirate_settings_load(&settings);
+    GDRSettings settings;
+    gdr_settings_load(&settings);
 
     // Apply auto-save setting
     app->auto_save = settings.auto_save;
@@ -327,18 +327,18 @@ ProtoPirateApp* protopirate_app_alloc() {
     }
 
     // Initialize TxRx structure with minimal setup
-    app->lock = ProtoPirateLockOff;
-    app->txrx = malloc(sizeof(ProtoPirateTxRx));
+    app->lock = GDRLockOff;
+    app->txrx = malloc(sizeof(GDRTxRx));
     furi_check(app->txrx);
-    memset(app->txrx, 0, sizeof(ProtoPirateTxRx));
+    memset(app->txrx, 0, sizeof(GDRTxRx));
 
     app->txrx->preset = malloc(sizeof(SubGhzRadioPreset));
     furi_check(app->txrx->preset);
     app->txrx->preset->name = furi_string_alloc();
     furi_check(app->txrx->preset->name);
-    app->txrx->txrx_state = ProtoPirateTxRxStateIDLE;
-    app->txrx->rx_key_state = ProtoPirateRxKeyStateIDLE;
-    app->txrx->protocol_registry_filter = ProtoPirateProtocolRegistryFilterAM;
+    app->txrx->txrx_state = GDRTxRxStateIDLE;
+    app->txrx->rx_key_state = GDRRxKeyStateIDLE;
+    app->txrx->protocol_registry_filter = GDRProtocolRegistryFilterAM;
 
     // Get preset name and data
     const char* preset_name = subghz_setting_get_preset_name(app->setting, preset_index);
@@ -353,22 +353,22 @@ ProtoPirateApp* protopirate_app_alloc() {
         settings.auto_save,
         settings.hopping_enabled);
 
-    protopirate_preset_init(app, preset_name, frequency, preset_data, preset_data_size);
+    gdr_preset_init(app, preset_name, frequency, preset_data, preset_data_size);
 
 #ifdef ENABLE_DUAL_RX_SCENE
 
     uint32_t default_frequency = subghz_setting_get_default_frequency(app->setting);
-    app->dual_freq_a = protopirate_setting_has_frequency(app->setting, settings.dual_freq_a) ?
+    app->dual_freq_a = gdr_setting_has_frequency(app->setting, settings.dual_freq_a) ?
                            settings.dual_freq_a :
                            default_frequency;
-    app->dual_freq_b = protopirate_setting_has_frequency(app->setting, settings.dual_freq_b) ?
+    app->dual_freq_b = gdr_setting_has_frequency(app->setting, settings.dual_freq_b) ?
                            settings.dual_freq_b :
                            default_frequency;
     uint8_t preset_count = (uint8_t)subghz_setting_get_preset_count(app->setting);
     uint8_t named_preset_a =
-        protopirate_find_preset_by_name(app->setting, settings.dual_preset_name_a);
+        gdr_find_preset_by_name(app->setting, settings.dual_preset_name_a);
     uint8_t named_preset_b =
-        protopirate_find_preset_by_name(app->setting, settings.dual_preset_name_b);
+        gdr_find_preset_by_name(app->setting, settings.dual_preset_name_b);
     app->dual_preset_a =
         named_preset_a != UINT8_MAX ? named_preset_a : settings.dual_preset_a;
     app->dual_preset_b =
@@ -377,15 +377,15 @@ ProtoPirateApp* protopirate_app_alloc() {
         app->dual_preset_a = UINT8_MAX;
         app->dual_preset_b = UINT8_MAX;
     } else if(app->dual_preset_a >= preset_count) {
-        app->dual_preset_a = protopirate_find_preset_by_name_or_filter(
-            app->setting, "AM650", ProtoPirateProtocolRegistryFilterAM);
+        app->dual_preset_a = gdr_find_preset_by_name_or_filter(
+            app->setting, "AM650", GDRProtocolRegistryFilterAM);
         if(app->dual_preset_a == UINT8_MAX) {
             app->dual_preset_a = 0;
         }
     }
     if(app->dual_preset_b >= preset_count) {
-        app->dual_preset_b = protopirate_find_preset_by_name_or_filter(
-            app->setting, "FM476", ProtoPirateProtocolRegistryFilterFM);
+        app->dual_preset_b = gdr_find_preset_by_name_or_filter(
+            app->setting, "FM476", GDRProtocolRegistryFilterFM);
         if(app->dual_preset_b == UINT8_MAX) {
             app->dual_preset_b = 0;
         }
@@ -395,7 +395,7 @@ ProtoPirateApp* protopirate_app_alloc() {
 #ifdef ENABLE_SHIELD_RX_SCENE
     {
         uint32_t default_frequency = subghz_setting_get_default_frequency(app->setting);
-        app->shield_freq = protopirate_setting_has_frequency(app->setting, settings.shield_freq) ?
+        app->shield_freq = gdr_setting_has_frequency(app->setting, settings.shield_freq) ?
                                settings.shield_freq :
                                default_frequency;
         app->shield_preset_index = settings.shield_preset_index;
@@ -414,8 +414,8 @@ ProtoPirateApp* protopirate_app_alloc() {
 #endif
 
     // Apply hopping state from settings
-    app->txrx->hopper_state = settings.hopping_enabled ? ProtoPirateHopperStateRunning :
-                                                         ProtoPirateHopperStateOFF;
+    app->txrx->hopper_state = settings.hopping_enabled ? GDRHopperStateRunning :
+                                                         GDRHopperStateOFF;
     app->txrx->hopper_idx_frequency = 0;
     app->txrx->hopper_timeout = 0;
     app->txrx->idx_menu_chosen = 0;
@@ -425,11 +425,11 @@ ProtoPirateApp* protopirate_app_alloc() {
     return app;
 }
 
-bool protopirate_radio_init(ProtoPirateApp* app) {
+bool gdr_radio_init(GDRApp* app) {
     furi_check(app);
     furi_check(app->txrx);
 
-    FURI_LOG_I(TAG, "=== protopirate_radio_init called ===");
+    FURI_LOG_I(TAG, "=== gdr_radio_init called ===");
     FURI_LOG_D(TAG, "State: radio_initialized=%d", app->radio_initialized);
 
     if(app->radio_initialized) {
@@ -445,7 +445,7 @@ bool protopirate_radio_init(ProtoPirateApp* app) {
             "Radio marked initialized but resources missing (env=%p device=%p), repairing",
             app->txrx->environment,
             app->txrx->radio_device);
-        protopirate_radio_deinit(app);
+        gdr_radio_deinit(app);
     }
 
     // Fresh radio init - nothing was initialized before
@@ -455,24 +455,24 @@ bool protopirate_radio_init(ProtoPirateApp* app) {
     app->txrx->environment = subghz_environment_alloc();
     if(!app->txrx->environment) {
         FURI_LOG_E(TAG, "Failed to allocate environment!");
-        protopirate_radio_init_cleanup(app, false);
+        gdr_radio_init_cleanup(app, false);
         return false;
     }
 
     app->txrx->protocol_registry = NULL;
 
-    if(!protopirate_refresh_protocol_registry(app, false)) {
+    if(!gdr_refresh_protocol_registry(app, false)) {
         FURI_LOG_E(TAG, "Failed to configure protocol registry");
-        protopirate_radio_init_cleanup(app, false);
+        gdr_radio_init_cleanup(app, false);
         return false;
     }
 
     // Load keystores
-    subghz_environment_load_keystore(app->txrx->environment, PROTOPIRATE_KEYSTORE_DIR_NAME);
+    subghz_environment_load_keystore(app->txrx->environment, GDR_KEYSTORE_DIR_NAME);
 
-    // Load ProtoPirate specific keys
-    protopirate_keys_load(app->txrx->environment);
-    FURI_LOG_I(TAG, "Loaded ProtoPirate secure keys");
+    // Load GDR specific keys
+    gdr_keys_load(app->txrx->environment);
+    FURI_LOG_I(TAG, "Loaded GDR secure keys");
 
     // Initialize SubGhz devices
     subghz_devices_init();
@@ -489,7 +489,7 @@ bool protopirate_radio_init(ProtoPirateApp* app) {
 
     if(!app->txrx->radio_device) {
         FURI_LOG_E(TAG, "Failed to initialize any radio device!");
-        protopirate_radio_init_cleanup(app, true);
+        gdr_radio_init_cleanup(app, true);
         return false;
     }
 #ifndef REMOVE_LOGS
@@ -512,8 +512,8 @@ bool protopirate_radio_init(ProtoPirateApp* app) {
 }
 
 // Deinitialize radio subsystem
-void protopirate_radio_deinit(ProtoPirateApp* app) {
-    FURI_LOG_I(TAG, "=== protopirate_radio_deinit called ===");
+void gdr_radio_deinit(GDRApp* app) {
+    FURI_LOG_I(TAG, "=== gdr_radio_deinit called ===");
     FURI_LOG_D(TAG, "State: radio_initialized=%d", app->radio_initialized);
     FURI_LOG_D(
         TAG,
@@ -535,7 +535,7 @@ void protopirate_radio_deinit(ProtoPirateApp* app) {
     bool devices_initialized = app->radio_initialized || (app->txrx->radio_device != NULL);
 
     // Make sure we're not receiving
-    if(app->txrx->worker && app->txrx->txrx_state == ProtoPirateTxRxStateRx) {
+    if(app->txrx->worker && app->txrx->txrx_state == GDRTxRxStateRx) {
         FURI_LOG_D(TAG, "Stopping active RX, state=%d", app->txrx->txrx_state);
         subghz_worker_stop(app->txrx->worker);
         if(app->txrx->radio_device) {
@@ -590,9 +590,9 @@ void protopirate_radio_deinit(ProtoPirateApp* app) {
     if(app->txrx->history) {
         FURI_LOG_D(TAG, "Freeing history %p", app->txrx->history);
         if(app->selected_capture.history == app->txrx->history) {
-            protopirate_selected_capture_clear(app);
+            gdr_selected_capture_clear(app);
         }
-        protopirate_history_free(app->txrx->history);
+        gdr_history_free(app->txrx->history);
         app->txrx->history = NULL;
     } else {
         FURI_LOG_D(TAG, "History was NULL, skipping free");
@@ -606,25 +606,25 @@ void protopirate_radio_deinit(ProtoPirateApp* app) {
         FURI_LOG_D(TAG, "Worker was NULL, skipping free");
     }
 
-    app->txrx->txrx_state = ProtoPirateTxRxStateIDLE;
+    app->txrx->txrx_state = GDRTxRxStateIDLE;
     app->radio_initialized = false;
 
     FURI_LOG_D(TAG, "Final state: radio_initialized=%d", app->radio_initialized);
 }
 
-void protopirate_app_free(ProtoPirateApp* app) {
+void gdr_app_free(GDRApp* app) {
     furi_check(app);
 
-    FURI_LOG_I(TAG, "=== protopirate_app_free called ===");
+    FURI_LOG_I(TAG, "=== gdr_app_free called ===");
     FURI_LOG_D(TAG, "State: radio_initialized=%d", app->radio_initialized);
 
     // Save settings before exiting
-    ProtoPirateSettings settings;
-    protopirate_settings_load(&settings);
+    GDRSettings settings;
+    gdr_settings_load(&settings);
     settings.frequency = app->txrx->preset->frequency;
     settings.auto_save = app->auto_save;
     settings.tx_power = app->tx_power;
-    settings.hopping_enabled = (app->txrx->hopper_state != ProtoPirateHopperStateOFF);
+    settings.hopping_enabled = (app->txrx->hopper_state != GDRHopperStateOFF);
     settings.emulate_feature_enabled = app->emulate_feature_enabled;
 #ifdef ENABLE_DUAL_RX_SCENE
     settings.dual_freq_a = app->dual_freq_a;
@@ -675,11 +675,11 @@ void protopirate_app_free(ProtoPirateApp* app) {
         settings.hopping_enabled,
         settings.emulate_feature_enabled);
 
-    protopirate_settings_save(&settings);
+    gdr_settings_save(&settings);
 
     // Deinitialize whichever is active - NULL checks inside handle all cases
     FURI_LOG_D(TAG, "Calling radio_deinit");
-    protopirate_radio_deinit(app);
+    gdr_radio_deinit(app);
 
     if(app->loaded_file_path) {
         FURI_LOG_D(TAG, "Freeing loaded_file_path");
@@ -690,21 +690,21 @@ void protopirate_app_free(ProtoPirateApp* app) {
     // Submenu
     if(app->submenu) {
         FURI_LOG_D(TAG, "Removing submenu view");
-        view_dispatcher_remove_view(app->view_dispatcher, ProtoPirateViewSubmenu);
+        view_dispatcher_remove_view(app->view_dispatcher, GDRViewSubmenu);
         submenu_free(app->submenu);
     }
 
     // Variable Item List
     if(app->variable_item_list) {
         FURI_LOG_D(TAG, "Removing variable_item_list view");
-        view_dispatcher_remove_view(app->view_dispatcher, ProtoPirateViewVariableItemList);
+        view_dispatcher_remove_view(app->view_dispatcher, GDRViewVariableItemList);
         variable_item_list_free(app->variable_item_list);
     }
 
     // About View
     if(app->view_about) {
         FURI_LOG_D(TAG, "Removing about view");
-        view_dispatcher_remove_view(app->view_dispatcher, ProtoPirateViewAbout);
+        view_dispatcher_remove_view(app->view_dispatcher, GDRViewAbout);
         view_free(app->view_about);
     }
 
@@ -717,14 +717,14 @@ void protopirate_app_free(ProtoPirateApp* app) {
     // Widget
     if(app->widget) {
         FURI_LOG_D(TAG, "Removing widget view");
-        view_dispatcher_remove_view(app->view_dispatcher, ProtoPirateViewWidget);
+        view_dispatcher_remove_view(app->view_dispatcher, GDRViewWidget);
         widget_free(app->widget);
     }
 
     // Text Input
     if(app->text_input) {
         FURI_LOG_D(TAG, "Removing text_input view");
-        view_dispatcher_remove_view(app->view_dispatcher, ProtoPirateViewTextInput);
+        view_dispatcher_remove_view(app->view_dispatcher, GDRViewTextInput);
         text_input_free(app->text_input);
     }
     if(app->save_protocol) {
@@ -733,21 +733,21 @@ void protopirate_app_free(ProtoPirateApp* app) {
     }
 
     // Receiver
-    if(app->protopirate_receiver) {
+    if(app->gdr_receiver) {
         FURI_LOG_D(TAG, "Removing receiver view");
-        view_dispatcher_remove_view(app->view_dispatcher, ProtoPirateViewReceiver);
-        protopirate_view_receiver_free(app->protopirate_receiver);
+        view_dispatcher_remove_view(app->view_dispatcher, GDRViewReceiver);
+        gdr_view_receiver_free(app->gdr_receiver);
     }
 
 #ifdef ENABLE_DUAL_RX_SCENE
 
     bool dual_devices_initialized = app->dual_chain_a || app->dual_chain_b;
     if(app->dual_chain_a) {
-        protopirate_rx_chain_free(app->dual_chain_a);
+        gdr_rx_chain_free(app->dual_chain_a);
         app->dual_chain_a = NULL;
     }
     if(app->dual_chain_b) {
-        protopirate_rx_chain_free(app->dual_chain_b);
+        gdr_rx_chain_free(app->dual_chain_b);
         app->dual_chain_b = NULL;
     }
     if(dual_devices_initialized) {
@@ -755,15 +755,15 @@ void protopirate_app_free(ProtoPirateApp* app) {
     }
     if(app->dual_receiver) {
         FURI_LOG_D(TAG, "Removing dual receiver view");
-        view_dispatcher_remove_view(app->view_dispatcher, ProtoPirateViewDualReceiver);
-        protopirate_view_dual_receiver_free(app->dual_receiver);
+        view_dispatcher_remove_view(app->view_dispatcher, GDRViewDualReceiver);
+        gdr_view_dual_receiver_free(app->dual_receiver);
         app->dual_receiver = NULL;
     }
     if(app->dual_history) {
         if(app->selected_capture.history == app->dual_history) {
-            protopirate_selected_capture_clear(app);
+            gdr_selected_capture_clear(app);
         }
-        protopirate_history_free(app->dual_history);
+        gdr_history_free(app->dual_history);
         app->dual_history = NULL;
     }
     if(app->dual_history_mutex) {
@@ -775,11 +775,11 @@ void protopirate_app_free(ProtoPirateApp* app) {
 #ifdef ENABLE_SHIELD_RX_SCENE
     bool shield_devices_initialized = app->shield_rx_chain || app->shield_tx_chain;
     if(app->shield_rx_chain) {
-        protopirate_rx_chain_free(app->shield_rx_chain);
+        gdr_rx_chain_free(app->shield_rx_chain);
         app->shield_rx_chain = NULL;
     }
     if(app->shield_tx_chain) {
-        protopirate_tx_chain_free(app->shield_tx_chain);
+        gdr_tx_chain_free(app->shield_tx_chain);
         app->shield_tx_chain = NULL;
     }
     if(shield_devices_initialized) {
@@ -787,9 +787,9 @@ void protopirate_app_free(ProtoPirateApp* app) {
     }
     if(app->shield_history) {
         if(app->selected_capture.history == app->shield_history) {
-            protopirate_selected_capture_clear(app);
+            gdr_selected_capture_clear(app);
         }
-        protopirate_history_free(app->shield_history);
+        gdr_history_free(app->shield_history);
         app->shield_history = NULL;
     }
     if(app->shield_history_mutex) {
@@ -798,7 +798,7 @@ void protopirate_app_free(ProtoPirateApp* app) {
     }
 #endif
 
-    protopirate_psa_bf_context_release(app);
+    gdr_psa_bf_context_release(app);
 
     // Setting
     FURI_LOG_D(TAG, "Freeing subghz_setting");
@@ -812,7 +812,7 @@ void protopirate_app_free(ProtoPirateApp* app) {
     free(app->txrx);
 
 #ifdef ENABLE_EMULATE_FEATURE
-    protopirate_emulate_context_release(app);
+    gdr_emulate_context_release(app);
 #endif
 
     pp_shared_upload_release();
@@ -840,38 +840,38 @@ void protopirate_app_free(ProtoPirateApp* app) {
     free(app);
 }
 
-int32_t protopirate_app(char* p) {
+int32_t gdr_app(char* p) {
     furi_hal_power_suppress_charge_enter();
 
-    ProtoPirateApp* protopirate_app = protopirate_app_alloc();
-    if(!protopirate_app) {
-        // logging is already done in protopirate_app_alloc()
+    GDRApp* gdr_app = gdr_app_alloc();
+    if(!gdr_app) {
+        // logging is already done in gdr_app_alloc()
         furi_hal_power_suppress_charge_exit();
         return -1;
     }
 
     // Handle Command line PSF that may have been passed to us
     bool load_saved = (p && strlen(p));
-    if(load_saved) protopirate_app->loaded_file_path = furi_string_alloc_set(p);
+    if(load_saved) gdr_app->loaded_file_path = furi_string_alloc_set(p);
     scene_manager_next_scene(
-        protopirate_app->scene_manager,
-        (load_saved) ? ProtoPirateSceneSavedInfo : ProtoPirateSceneStart);
+        gdr_app->scene_manager,
+        (load_saved) ? GDRSceneSavedInfo : GDRSceneStart);
 
     //We now jump straight to emulate scene from Browser. If the user wanted the key to look at, just click back.
     if(load_saved) {
-        if(protopirate_app->emulate_feature_enabled) {
+        if(gdr_app->emulate_feature_enabled) {
             view_dispatcher_send_custom_event(
-                protopirate_app->view_dispatcher, ProtoPirateCustomEventSavedInfoEmulate);
-            notification_message(protopirate_app->notifications, &sequence_success);
+                gdr_app->view_dispatcher, GDRCustomEventSavedInfoEmulate);
+            notification_message(gdr_app->notifications, &sequence_success);
         } else {
             view_dispatcher_send_custom_event(
-                protopirate_app->view_dispatcher, ProtoPirateCustomEventReceiverInfoSave);
+                gdr_app->view_dispatcher, GDRCustomEventReceiverInfoSave);
         }
     }
 
-    view_dispatcher_run(protopirate_app->view_dispatcher);
+    view_dispatcher_run(gdr_app->view_dispatcher);
 
-    protopirate_app_free(protopirate_app);
+    gdr_app_free(gdr_app);
 
     furi_hal_power_suppress_charge_exit();
 

applications/system/Garage Door Remote/gdr_app_i.c

@@ -1,17 +1,17 @@
-// protopirate_app_i.c
-#include "protopirate_app_i.h"
+// gdr_app_i.c
+#include "gdr_app_i.h"
 #include "protocols/protocol_items.h"
 #include <loader/firmware_api/firmware_api.h>
 #include <stdio.h>
 
-#define TAG "ProtoPirateTxRx"
+#define TAG "GDRTxRx"
 
-void protopirate_selected_capture_set(
-    ProtoPirateApp* app,
-    ProtoPirateHistory* history,
+void gdr_selected_capture_set(
+    GDRApp* app,
+    GDRHistory* history,
     FuriMutex* mutex,
     uint16_t index,
-    ProtoPirateCaptureOwner owner) {
+    GDRCaptureOwner owner) {
     furi_check(app);
     app->selected_capture.history = history;
     app->selected_capture.mutex = mutex;
@@ -19,75 +19,75 @@ void protopirate_selected_capture_set(
     app->selected_capture.owner = owner;
 }
 
-void protopirate_selected_capture_clear(ProtoPirateApp* app) {
+void gdr_selected_capture_clear(GDRApp* app) {
     furi_check(app);
     memset(&app->selected_capture, 0, sizeof(app->selected_capture));
 }
 
-bool protopirate_selected_capture_is_valid(ProtoPirateApp* app) {
+bool gdr_selected_capture_is_valid(GDRApp* app) {
     furi_check(app);
-    ProtoPirateSelectedCapture* selected = &app->selected_capture;
-    if(!selected->history || selected->owner == ProtoPirateCaptureOwnerNone) {
+    GDRSelectedCapture* selected = &app->selected_capture;
+    if(!selected->history || selected->owner == GDRCaptureOwnerNone) {
         return false;
     }
     if(selected->mutex) {
         furi_mutex_acquire(selected->mutex, FuriWaitForever);
     }
-    bool valid = selected->index < protopirate_history_get_item(selected->history);
+    bool valid = selected->index < gdr_history_get_item(selected->history);
     if(selected->mutex) {
         furi_mutex_release(selected->mutex);
     }
     return valid;
 }
 
-ProtoPirateHistory* protopirate_selected_capture_get_history(ProtoPirateApp* app) {
-    return protopirate_selected_capture_is_valid(app) ? app->selected_capture.history : NULL;
+GDRHistory* gdr_selected_capture_get_history(GDRApp* app) {
+    return gdr_selected_capture_is_valid(app) ? app->selected_capture.history : NULL;
 }
 
-uint16_t protopirate_selected_capture_get_index(ProtoPirateApp* app) {
+uint16_t gdr_selected_capture_get_index(GDRApp* app) {
     furi_check(app);
     return app->selected_capture.index;
 }
 
-ProtoPirateHistorySource protopirate_selected_capture_get_source(ProtoPirateApp* app) {
-    ProtoPirateHistory* history = protopirate_selected_capture_get_history(app);
+GDRHistorySource gdr_selected_capture_get_source(GDRApp* app) {
+    GDRHistory* history = gdr_selected_capture_get_history(app);
     if(!history) {
-        return ProtoPirateHistorySourceUnknown;
+        return GDRHistorySourceUnknown;
     }
-    return protopirate_history_get_source(history, app->selected_capture.index);
+    return gdr_history_get_source(history, app->selected_capture.index);
 }
 
-FlipperFormat* protopirate_selected_capture_get_raw_data(ProtoPirateApp* app) {
-    ProtoPirateHistory* history = protopirate_selected_capture_get_history(app);
+FlipperFormat* gdr_selected_capture_get_raw_data(GDRApp* app) {
+    GDRHistory* history = gdr_selected_capture_get_history(app);
     if(!history) {
         return NULL;
     }
-    return protopirate_history_get_raw_data(history, app->selected_capture.index);
+    return gdr_history_get_raw_data(history, app->selected_capture.index);
 }
 
-bool protopirate_selected_capture_get_path(ProtoPirateApp* app, FuriString* out_path) {
+bool gdr_selected_capture_get_path(GDRApp* app, FuriString* out_path) {
     furi_check(out_path);
-    ProtoPirateHistory* history = protopirate_selected_capture_get_history(app);
+    GDRHistory* history = gdr_selected_capture_get_history(app);
     if(!history) {
         return false;
     }
-    return protopirate_history_get_capture_path(history, app->selected_capture.index, out_path);
+    return gdr_history_get_capture_path(history, app->selected_capture.index, out_path);
 }
 
-void protopirate_selected_capture_release_scratch(ProtoPirateApp* app) {
+void gdr_selected_capture_release_scratch(GDRApp* app) {
     furi_check(app);
     if(app->selected_capture.history) {
-        protopirate_history_release_scratch(app->selected_capture.history);
+        gdr_history_release_scratch(app->selected_capture.history);
     }
 }
 
-static const char* protopirate_get_registry_plugin_path(ProtoPirateProtocolRegistryFilter filter) {
-    return (filter == ProtoPirateProtocolRegistryFilterFM) ?
-               APP_ASSETS_PATH("plugins/protopirate_fm_plugin.fal") :
-               APP_ASSETS_PATH("plugins/protopirate_am_plugin.fal");
+static const char* gdr_get_registry_plugin_path(GDRProtocolRegistryFilter filter) {
+    return (filter == GDRProtocolRegistryFilterFM) ?
+               APP_ASSETS_PATH("plugins/gdr_fm_plugin.fal") :
+               APP_ASSETS_PATH("plugins/gdr_am_plugin.fal");
 }
 
-static void protopirate_unload_protocol_plugin(ProtoPirateTxRx* txrx) {
+static void gdr_unload_protocol_plugin(GDRTxRx* txrx) {
     furi_check(txrx);
 
     txrx->protocol_plugin = NULL;
@@ -104,12 +104,12 @@ static void protopirate_unload_protocol_plugin(ProtoPirateTxRx* txrx) {
     }
 }
 
-static void protopirate_teardown_receiver_stack_for_registry_switch(ProtoPirateApp* app) {
+static void gdr_teardown_receiver_stack_for_registry_switch(GDRApp* app) {
     furi_check(app);
     furi_check(app->txrx);
 
-    if(app->txrx->txrx_state == ProtoPirateTxRxStateRx) {
-        protopirate_rx_end(app);
+    if(app->txrx->txrx_state == GDRTxRxStateRx) {
+        gdr_rx_end(app);
     }
 
     if(app->txrx->receiver) {
@@ -126,15 +126,15 @@ static void protopirate_teardown_receiver_stack_for_registry_switch(ProtoPirateA
         app->txrx->worker = NULL;
     }
 
-    if(app->txrx->radio_device && app->txrx->txrx_state != ProtoPirateTxRxStateTx) {
+    if(app->txrx->radio_device && app->txrx->txrx_state != GDRTxRxStateTx) {
         subghz_devices_idle(app->txrx->radio_device);
-        app->txrx->txrx_state = ProtoPirateTxRxStateIDLE;
+        app->txrx->txrx_state = GDRTxRxStateIDLE;
     }
 }
 
-static bool protopirate_ensure_protocol_registry_plugin(
-    ProtoPirateApp* app,
-    ProtoPirateProtocolRegistryFilter filter,
+static bool gdr_ensure_protocol_registry_plugin(
+    GDRApp* app,
+    GDRProtocolRegistryFilter filter,
     const SubGhzProtocolRegistry** registry) {
     furi_check(app);
     furi_check(app->txrx);
@@ -155,7 +155,7 @@ static bool protopirate_ensure_protocol_registry_plugin(
 
     if(app->txrx->protocol_plugin || app->txrx->protocol_plugin_manager ||
        app->txrx->plugin_resolver) {
-        protopirate_unload_protocol_plugin(app->txrx);
+        gdr_unload_protocol_plugin(app->txrx);
     }
 
     CompositeApiResolver* resolver = composite_api_resolver_alloc();
@@ -166,8 +166,8 @@ static bool protopirate_ensure_protocol_registry_plugin(
     composite_api_resolver_add(resolver, firmware_api_interface);
 
     PluginManager* manager = plugin_manager_alloc(
-        PROTOPIRATE_PROTOCOL_PLUGIN_APP_ID,
-        PROTOPIRATE_PROTOCOL_PLUGIN_API_VERSION,
+        GDR_PROTOCOL_PLUGIN_APP_ID,
+        GDR_PROTOCOL_PLUGIN_API_VERSION,
         composite_api_resolver_get(resolver));
     if(!manager) {
         FURI_LOG_E(TAG, "Failed to allocate protocol plugin manager");
@@ -175,7 +175,7 @@ static bool protopirate_ensure_protocol_registry_plugin(
         return false;
     }
 
-    const char* plugin_path = protopirate_get_registry_plugin_path(filter);
+    const char* plugin_path = gdr_get_registry_plugin_path(filter);
     PluginManagerError error = plugin_manager_load_single(manager, plugin_path);
     if(error != PluginManagerErrorNone) {
         FURI_LOG_E(TAG, "Failed to load protocol plugin %s: %d", plugin_path, (int)error);
@@ -184,7 +184,7 @@ static bool protopirate_ensure_protocol_registry_plugin(
         return false;
     }
 
-    const ProtoPirateProtocolPlugin* plugin = plugin_manager_get_ep(manager, 0U);
+    const GDRProtocolPlugin* plugin = plugin_manager_get_ep(manager, 0U);
     if(!plugin || !plugin->registry) {
         FURI_LOG_E(TAG, "Protocol plugin entry point is invalid");
         plugin_manager_free(manager);
@@ -208,7 +208,7 @@ static bool protopirate_ensure_protocol_registry_plugin(
     return true;
 }
 
-bool protopirate_refresh_protocol_registry(ProtoPirateApp* app, bool ensure_receiver_ready) {
+bool gdr_refresh_protocol_registry(GDRApp* app, bool ensure_receiver_ready) {
     furi_check(app);
     furi_check(app->txrx);
 
@@ -216,23 +216,23 @@ bool protopirate_refresh_protocol_registry(ProtoPirateApp* app, bool ensure_rece
         return true;
     }
 
-    ProtoPirateProtocolRegistryFilter filter = protopirate_get_protocol_registry_filter_for_preset(
+    GDRProtocolRegistryFilter filter = gdr_get_protocol_registry_filter_for_preset(
         app->txrx->preset->data, app->txrx->preset->data_size);
     bool filter_changed = !app->txrx->protocol_plugin ||
                           (app->txrx->protocol_registry_filter != filter);
 
     if(filter_changed) {
-        protopirate_teardown_receiver_stack_for_registry_switch(app);
+        gdr_teardown_receiver_stack_for_registry_switch(app);
     } else if(ensure_receiver_ready && !app->txrx->receiver) {
-        protopirate_teardown_receiver_stack_for_registry_switch(app);
+        gdr_teardown_receiver_stack_for_registry_switch(app);
     }
 
     const SubGhzProtocolRegistry* registry = NULL;
-    if(!protopirate_ensure_protocol_registry_plugin(app, filter, &registry) || !registry) {
+    if(!gdr_ensure_protocol_registry_plugin(app, filter, &registry) || !registry) {
         FURI_LOG_E(
             TAG,
             "Failed to resolve %s protocol registry plugin",
-            protopirate_get_protocol_registry_filter_name(filter));
+            gdr_get_protocol_registry_filter_name(filter));
         return false;
     }
 
@@ -241,7 +241,7 @@ bool protopirate_refresh_protocol_registry(ProtoPirateApp* app, bool ensure_rece
         FURI_LOG_I(
             TAG,
             "Using %s protocol registry (%zu protocols)",
-            protopirate_get_protocol_registry_filter_name(filter),
+            gdr_get_protocol_registry_filter_name(filter),
             registry->size);
         subghz_environment_set_protocol_registry(app->txrx->environment, registry);
         app->txrx->protocol_registry = registry;
@@ -260,7 +260,7 @@ bool protopirate_refresh_protocol_registry(ProtoPirateApp* app, bool ensure_rece
         FURI_LOG_E(
             TAG,
             "Failed to allocate receiver for %s registry",
-            protopirate_get_protocol_registry_filter_name(filter));
+            gdr_get_protocol_registry_filter_name(filter));
         return false;
     }
 
@@ -268,8 +268,8 @@ bool protopirate_refresh_protocol_registry(ProtoPirateApp* app, bool ensure_rece
     return true;
 }
 
-bool protopirate_apply_protocol_registry_for_preset_data(
-    ProtoPirateApp* app,
+bool gdr_apply_protocol_registry_for_preset_data(
+    GDRApp* app,
     const uint8_t* preset_data,
     size_t preset_data_size) {
     furi_check(app);
@@ -279,22 +279,22 @@ bool protopirate_apply_protocol_registry_for_preset_data(
         return false;
     }
 
-    ProtoPirateProtocolRegistryFilter filter =
-        protopirate_get_protocol_registry_filter_for_preset(preset_data, preset_data_size);
+    GDRProtocolRegistryFilter filter =
+        gdr_get_protocol_registry_filter_for_preset(preset_data, preset_data_size);
 
     bool filter_changed = !app->txrx->protocol_plugin ||
                           (app->txrx->protocol_registry_filter != filter);
 
     if(filter_changed) {
-        protopirate_teardown_receiver_stack_for_registry_switch(app);
+        gdr_teardown_receiver_stack_for_registry_switch(app);
     }
 
     const SubGhzProtocolRegistry* registry = NULL;
-    if(!protopirate_ensure_protocol_registry_plugin(app, filter, &registry) || !registry) {
+    if(!gdr_ensure_protocol_registry_plugin(app, filter, &registry) || !registry) {
         FURI_LOG_E(
             TAG,
             "Failed to resolve %s registry plugin for preset apply",
-            protopirate_get_protocol_registry_filter_name(filter));
+            gdr_get_protocol_registry_filter_name(filter));
         return false;
     }
 
@@ -305,29 +305,29 @@ bool protopirate_apply_protocol_registry_for_preset_data(
     FURI_LOG_I(
         TAG,
         "Switching active protocol registry to %s (%zu protocols)",
-        protopirate_get_protocol_registry_filter_name(filter),
+        gdr_get_protocol_registry_filter_name(filter),
         registry->size);
     subghz_environment_set_protocol_registry(app->txrx->environment, registry);
     app->txrx->protocol_registry = registry;
     return true;
 }
 
-void protopirate_preset_init(
+void gdr_preset_init(
     void* context,
     const char* preset_name,
     uint32_t frequency,
     uint8_t* preset_data,
     size_t preset_data_size) {
     furi_check(context);
-    ProtoPirateApp* app = context;
+    GDRApp* app = context;
     furi_string_set(app->txrx->preset->name, preset_name);
     app->txrx->preset->frequency = frequency;
     app->txrx->preset->data = preset_data;
     app->txrx->preset->data_size = preset_data_size;
 }
 
-void protopirate_get_frequency_modulation_str(
-    ProtoPirateApp* app,
+void gdr_get_frequency_modulation_str(
+    GDRApp* app,
     char* frequency,
     size_t frequency_size,
     char* modulation,
@@ -346,15 +346,15 @@ void protopirate_get_frequency_modulation_str(
     }
 }
 
-void protopirate_get_frequency_modulation(
-    ProtoPirateApp* app,
+void gdr_get_frequency_modulation(
+    GDRApp* app,
     FuriString* frequency,
     FuriString* modulation) {
     furi_check(app);
 
     char frequency_buf[16] = {0};
     char modulation_buf[8] = {0};
-    protopirate_get_frequency_modulation_str(
+    gdr_get_frequency_modulation_str(
         app, frequency_buf, sizeof(frequency_buf), modulation_buf, sizeof(modulation_buf));
 
     if(frequency != NULL) {
@@ -365,20 +365,20 @@ void protopirate_get_frequency_modulation(
     }
 }
 
-void protopirate_begin(ProtoPirateApp* app, uint8_t* preset_data) {
+void gdr_begin(GDRApp* app, uint8_t* preset_data) {
     furi_check(app);
     if(!app->txrx->radio_device) {
         FURI_LOG_W(TAG, "begin requested without radio device");
-        app->txrx->txrx_state = ProtoPirateTxRxStateIDLE;
+        app->txrx->txrx_state = GDRTxRxStateIDLE;
         return;
     }
     subghz_devices_reset(app->txrx->radio_device);
     subghz_devices_idle(app->txrx->radio_device);
     subghz_devices_load_preset(app->txrx->radio_device, FuriHalSubGhzPresetCustom, preset_data);
-    app->txrx->txrx_state = ProtoPirateTxRxStateIDLE;
+    app->txrx->txrx_state = GDRTxRxStateIDLE;
 }
 
-uint32_t protopirate_rx(ProtoPirateApp* app, uint32_t frequency) {
+uint32_t gdr_rx(GDRApp* app, uint32_t frequency) {
     furi_check(app);
     furi_check(app->txrx);
     if(!app->radio_initialized || !app->txrx->radio_device || !app->txrx->worker) {
@@ -388,15 +388,15 @@ uint32_t protopirate_rx(ProtoPirateApp* app, uint32_t frequency) {
             app->radio_initialized,
             app->txrx->radio_device,
             app->txrx->worker);
-        app->txrx->txrx_state = ProtoPirateTxRxStateIDLE;
+        app->txrx->txrx_state = GDRTxRxStateIDLE;
         return 0;
     }
 
     if(!subghz_devices_is_frequency_valid(app->txrx->radio_device, frequency)) {
-        furi_crash("ProtoPirate: Incorrect RX frequency.");
+        furi_crash("GDR: Incorrect RX frequency.");
     }
-    if(app->txrx->txrx_state == ProtoPirateTxRxStateRx ||
-       app->txrx->txrx_state == ProtoPirateTxRxStateSleep) {
+    if(app->txrx->txrx_state == GDRTxRxStateRx ||
+       app->txrx->txrx_state == GDRTxRxStateSleep) {
         FURI_LOG_W(TAG, "RX start ignored in state %d", app->txrx->txrx_state);
         return app->txrx->preset ? app->txrx->preset->frequency : 0;
     }
@@ -410,24 +410,24 @@ uint32_t protopirate_rx(ProtoPirateApp* app, uint32_t frequency) {
         app->txrx->radio_device, subghz_worker_rx_callback, app->txrx->worker);
 
     subghz_worker_start(app->txrx->worker);
-    app->txrx->txrx_state = ProtoPirateTxRxStateRx;
+    app->txrx->txrx_state = GDRTxRxStateRx;
     return value;
 }
 
-void protopirate_idle(ProtoPirateApp* app) {
+void gdr_idle(GDRApp* app) {
     furi_check(app);
-    furi_check(app->txrx->txrx_state != ProtoPirateTxRxStateSleep);
+    furi_check(app->txrx->txrx_state != GDRTxRxStateSleep);
     if(app->txrx->radio_device) {
         subghz_devices_idle(app->txrx->radio_device);
     } else {
         FURI_LOG_W(TAG, "idle requested without radio device");
     }
-    app->txrx->txrx_state = ProtoPirateTxRxStateIDLE;
+    app->txrx->txrx_state = GDRTxRxStateIDLE;
 }
 
-void protopirate_rx_end(ProtoPirateApp* app) {
+void gdr_rx_end(GDRApp* app) {
     furi_check(app);
-    if(!app->txrx || app->txrx->txrx_state != ProtoPirateTxRxStateRx) {
+    if(!app->txrx || app->txrx->txrx_state != GDRTxRxStateRx) {
         return;
     }
 
@@ -440,33 +440,33 @@ void protopirate_rx_end(ProtoPirateApp* app) {
         subghz_devices_idle(app->txrx->radio_device);
     }
 
-    app->txrx->txrx_state = ProtoPirateTxRxStateIDLE;
+    app->txrx->txrx_state = GDRTxRxStateIDLE;
 }
 
-void protopirate_sleep(ProtoPirateApp* app) {
+void gdr_sleep(GDRApp* app) {
     furi_check(app);
     subghz_devices_sleep(app->txrx->radio_device);
-    app->txrx->txrx_state = ProtoPirateTxRxStateSleep;
+    app->txrx->txrx_state = GDRTxRxStateSleep;
 }
 
-void protopirate_release_shared_radio_state(ProtoPirateApp* app) {
+void gdr_release_shared_radio_state(GDRApp* app) {
     furi_check(app);
     furi_check(app->txrx);
 
-    if(app->protopirate_receiver) {
-        protopirate_view_receiver_reset_menu(app->protopirate_receiver);
+    if(app->gdr_receiver) {
+        gdr_view_receiver_reset_menu(app->gdr_receiver);
     }
 
-    protopirate_radio_deinit(app);
+    gdr_radio_deinit(app);
 }
 
-void protopirate_rx_stack_suspend_for_tx(ProtoPirateApp* app) {
+void gdr_rx_stack_suspend_for_tx(GDRApp* app) {
     if(!app || !app->radio_initialized) {
         return;
     }
 
-    if(app->txrx->txrx_state == ProtoPirateTxRxStateRx) {
-        protopirate_rx_end(app);
+    if(app->txrx->txrx_state == GDRTxRxStateRx) {
+        gdr_rx_end(app);
     }
 
     if(app->txrx->worker && subghz_worker_is_running(app->txrx->worker)) {
@@ -477,30 +477,30 @@ void protopirate_rx_stack_suspend_for_tx(ProtoPirateApp* app) {
         subghz_receiver_set_rx_callback(app->txrx->receiver, NULL, NULL);
     }
 
-    if(app->txrx->radio_device && app->txrx->txrx_state != ProtoPirateTxRxStateTx) {
+    if(app->txrx->radio_device && app->txrx->txrx_state != GDRTxRxStateTx) {
         subghz_devices_idle(app->txrx->radio_device);
-        app->txrx->txrx_state = ProtoPirateTxRxStateIDLE;
+        app->txrx->txrx_state = GDRTxRxStateIDLE;
     }
 }
 
-void protopirate_rx_stack_resume_after_tx(ProtoPirateApp* app) {
+void gdr_rx_stack_resume_after_tx(GDRApp* app) {
     if(!app || !app->radio_initialized || !app->txrx->environment) {
         return;
     }
 
-    if(!protopirate_refresh_protocol_registry(app, true)) {
+    if(!gdr_refresh_protocol_registry(app, true)) {
         FURI_LOG_E(TAG, "rx_stack_resume: failed to restore RX stack");
     }
 }
 
-void protopirate_hopper_update(ProtoPirateApp* app) {
+void gdr_hopper_update(GDRApp* app) {
     furi_check(app);
 
     switch(app->txrx->hopper_state) {
-    case ProtoPirateHopperStateOFF:
-    case ProtoPirateHopperStatePause:
+    case GDRHopperStateOFF:
+    case GDRHopperStatePause:
         return;
-    case ProtoPirateHopperStateRSSITimeOut:
+    case GDRHopperStateRSSITimeOut:
         if(app->txrx->hopper_timeout != 0) {
             app->txrx->hopper_timeout--;
             return;
@@ -510,21 +510,21 @@ void protopirate_hopper_update(ProtoPirateApp* app) {
         break;
     }
     float rssi = -127.0f;
-    if(app->txrx->hopper_state != ProtoPirateHopperStateRSSITimeOut) {
+    if(app->txrx->hopper_state != GDRHopperStateRSSITimeOut) {
         rssi = subghz_devices_get_rssi(app->txrx->radio_device);
 
         if(rssi > -90.0f) {
             app->txrx->hopper_timeout = 10;
-            app->txrx->hopper_state = ProtoPirateHopperStateRSSITimeOut;
+            app->txrx->hopper_state = GDRHopperStateRSSITimeOut;
             return;
         }
     } else {
-        app->txrx->hopper_state = ProtoPirateHopperStateRunning;
+        app->txrx->hopper_state = GDRHopperStateRunning;
     }
 
     const size_t hopper_count = subghz_setting_get_hopper_frequency_count(app->setting);
     if(hopper_count == 0) {
-        app->txrx->hopper_state = ProtoPirateHopperStateOFF;
+        app->txrx->hopper_state = GDRHopperStateOFF;
         app->txrx->hopper_idx_frequency = 0;
         return;
     }
@@ -534,36 +534,36 @@ void protopirate_hopper_update(ProtoPirateApp* app) {
         app->txrx->hopper_idx_frequency = 0;
     }
 
-    if(app->txrx->txrx_state == ProtoPirateTxRxStateRx) {
-        protopirate_rx_end(app);
+    if(app->txrx->txrx_state == GDRTxRxStateRx) {
+        gdr_rx_end(app);
     }
-    if(app->txrx->txrx_state == ProtoPirateTxRxStateIDLE && app->txrx->receiver) {
+    if(app->txrx->txrx_state == GDRTxRxStateIDLE && app->txrx->receiver) {
         subghz_receiver_reset(app->txrx->receiver);
         app->txrx->preset->frequency =
             subghz_setting_get_hopper_frequency(app->setting, app->txrx->hopper_idx_frequency);
-        protopirate_rx(app, app->txrx->preset->frequency);
+        gdr_rx(app, app->txrx->preset->frequency);
     }
 }
 
-void protopirate_tx(ProtoPirateApp* app, uint32_t frequency) {
+void gdr_tx(GDRApp* app, uint32_t frequency) {
     furi_check(app);
     if(!subghz_devices_is_frequency_valid(app->txrx->radio_device, frequency)) {
         return;
     }
 
-    furi_check(app->txrx->txrx_state == ProtoPirateTxRxStateIDLE);
+    furi_check(app->txrx->txrx_state == GDRTxRxStateIDLE);
 
     subghz_devices_idle(app->txrx->radio_device);
     subghz_devices_set_frequency(app->txrx->radio_device, frequency);
     subghz_devices_set_tx(app->txrx->radio_device);
 
-    app->txrx->txrx_state = ProtoPirateTxRxStateTx;
+    app->txrx->txrx_state = GDRTxRxStateTx;
 }
 
-void protopirate_tx_stop(ProtoPirateApp* app) {
+void gdr_tx_stop(GDRApp* app) {
     furi_check(app);
-    furi_check(app->txrx->txrx_state == ProtoPirateTxRxStateTx);
+    furi_check(app->txrx->txrx_state == GDRTxRxStateTx);
 
     subghz_devices_idle(app->txrx->radio_device);
-    app->txrx->txrx_state = ProtoPirateTxRxStateIDLE;
+    app->txrx->txrx_state = GDRTxRxStateIDLE;
 }

applications/system/Garage Door Remote/gdr_app_i.h

@@ -0,0 +1,237 @@
+// gdr_app_i.h
+#pragma once
+
+#include <stddef.h>
+#include "helpers/gdr_types.h"
+#include "helpers/gdr_settings.h"
+#include "scenes/gdr_scene.h"
+#include "views/gdr_receiver.h"
+#include "gdr_history.h"
+#include "helpers/radio_device_loader.h"
+#ifdef ENABLE_DUAL_RX_SCENE
+#include "helpers/gdr_rx_chain.h"
+#include "views/gdr_dual_receiver.h"
+#endif
+#ifdef ENABLE_SHIELD_RX_SCENE
+#include "helpers/gdr_rx_chain.h"
+#include "helpers/gdr_tx_chain.h"
+#endif
+
+#include <gui/gui.h>
+#include <gui/view_dispatcher.h>
+#include <gui/scene_manager.h>
+#include <gui/modules/submenu.h>
+#include <gui/modules/variable_item_list.h>
+#include <gui/modules/widget.h>
+#include <gui/modules/text_input.h>
+#include <notification/notification_messages.h>
+#include <lib/subghz/subghz_setting.h>
+#include <lib/subghz/subghz_worker.h>
+#include <lib/subghz/receiver.h>
+#include <lib/subghz/transmitter.h>
+#include <lib/subghz/devices/devices.h>
+#include <lib/subghz/subghz_file_encoder_worker.h>
+#include <lib/flipper_application/plugins/plugin_manager.h>
+#include <lib/flipper_application/plugins/composite_resolver.h>
+#include <dialogs/dialogs.h>
+#include "defines.h"
+#include "protocols/protocols_common.h"
+#include "protocols/protocol_items.h"
+#include "protocols/gdr_protocol_plugins.h"
+#ifdef ENABLE_EMULATE_FEATURE
+#include "scenes/plugins/gdr_emulate_plugin.h"
+#endif
+#include "scenes/plugins/gdr_psa_bf_plugin.h"
+
+#define GDR_KEYSTORE_DIR_NAME APP_ASSETS_PATH("encrypted")
+
+typedef struct GDRApp GDRApp;
+
+typedef enum {
+    GDRCaptureOwnerNone = 0,
+    GDRCaptureOwnerReceiver,
+    GDRCaptureOwnerDualReceiver,
+#ifdef ENABLE_SHIELD_RX_SCENE
+    GDRCaptureOwnerShieldReceiver,
+#endif
+    GDRCaptureOwnerSubDecode,
+} GDRCaptureOwner;
+
+typedef struct {
+    GDRHistory* history;
+    FuriMutex* mutex;
+    uint16_t index;
+    GDRCaptureOwner owner;
+} GDRSelectedCapture;
+
+typedef struct {
+    SubGhzWorker* worker;
+    SubGhzEnvironment* environment;
+    SubGhzReceiver* receiver;
+    SubGhzRadioPreset* preset;
+    const SubGhzProtocolRegistry* protocol_registry;
+    CompositeApiResolver* plugin_resolver;
+    PluginManager* protocol_plugin_manager;
+    const GDRProtocolPlugin* protocol_plugin;
+    GDRProtocolRegistryFilter protocol_registry_filter;
+    GDRHistory* history;
+    const SubGhzDevice* radio_device;
+    GDRTxRxState txrx_state;
+    GDRHopperState hopper_state;
+    GDRRxKeyState rx_key_state;
+    uint8_t hopper_idx_frequency;
+    uint8_t hopper_timeout;
+    uint16_t idx_menu_chosen;
+} GDRTxRx;
+
+struct GDRApp {
+    Gui* gui;
+    ViewDispatcher* view_dispatcher;
+    SceneManager* scene_manager;
+    NotificationApp* notifications;
+    DialogsApp* dialogs;
+    VariableItemList* variable_item_list;
+    Submenu* submenu;
+    Widget* widget;
+    TextInput* text_input;
+    View* view_about;
+    FuriString* file_path;
+    GDRReceiver* gdr_receiver;
+    GDRTxRx* txrx;
+    SubGhzSetting* setting;
+    GDRLock lock;
+    FuriString* loaded_file_path;
+    bool auto_save;
+    bool radio_initialized;
+    GDRSettings settings;
+    uint32_t start_tx_time;
+    uint8_t tx_power;
+    char save_filename[64];
+    FuriString* save_protocol;
+    uint16_t save_history_idx;
+    bool save_from_saved_info;
+    bool emulate_disabled_for_loaded;
+    bool emulate_feature_enabled;
+    GDRSelectedCapture selected_capture;
+    GDRCaptureOwner unsaved_history_owner;
+#ifdef ENABLE_EMULATE_FEATURE
+#define EMULATE_NAV_NONE     0U
+#define EMULATE_NAV_POP      1U
+#define EMULATE_NAV_STOP_APP 2U
+    CompositeApiResolver* emulate_plugin_resolver;
+    PluginManager* emulate_plugin_manager;
+    const GDREmulatePlugin* emulate_plugin;
+    uint8_t emulate_nav_pending;
+#endif
+    CompositeApiResolver* psa_bf_plugin_resolver;
+    PluginManager* psa_bf_plugin_manager;
+    const GDRPsaBfPlugin* psa_bf_plugin;
+#ifdef ENABLE_DUAL_RX_SCENE
+    GDRDualReceiver* dual_receiver;
+    GDRRxChain* dual_chain_a;
+    GDRRxChain* dual_chain_b;
+    GDRHistory* dual_history;
+    FuriMutex* dual_history_mutex;
+    uint32_t dual_freq_a;
+    uint32_t dual_freq_b;
+    uint8_t dual_preset_a;
+    uint8_t dual_preset_b;
+#endif
+#ifdef ENABLE_SHIELD_RX_SCENE
+    GDRRxChain* shield_rx_chain;
+    GDRTxChain* shield_tx_chain;
+    GDRHistory* shield_history;
+    FuriMutex* shield_history_mutex;
+    uint32_t shield_freq;
+    uint8_t shield_preset_index;
+    uint8_t shield_tx_offset_index;
+    uint8_t shield_tx_power;
+    bool shield_auto_save_failed;
+#endif
+};
+
+#ifdef ENABLE_EMULATE_FEATURE
+void gdr_emulate_context_release(GDRApp* app);
+#endif
+
+typedef enum {
+    GDRSetTypeFord_v0,
+    GDRSetTypeMAX,
+} GDRSetType;
+
+void gdr_preset_init(
+    void* context,
+    const char* preset_name,
+    uint32_t frequency,
+    uint8_t* preset_data,
+    size_t preset_data_size);
+
+void gdr_get_frequency_modulation(
+    GDRApp* app,
+    FuriString* frequency,
+    FuriString* modulation);
+void gdr_get_frequency_modulation_str(
+    GDRApp* app,
+    char* frequency,
+    size_t frequency_size,
+    char* modulation,
+    size_t modulation_size);
+
+void gdr_begin(GDRApp* app, uint8_t* preset_data);
+uint32_t gdr_rx(GDRApp* app, uint32_t frequency);
+void gdr_idle(GDRApp* app);
+void gdr_rx_end(GDRApp* app);
+void gdr_sleep(GDRApp* app);
+void gdr_hopper_update(GDRApp* app);
+void gdr_tx(GDRApp* app, uint32_t frequency);
+void gdr_tx_stop(GDRApp* app);
+bool gdr_radio_init(GDRApp* app);
+void gdr_radio_deinit(GDRApp* app);
+bool gdr_refresh_protocol_registry(GDRApp* app, bool ensure_receiver_ready);
+bool gdr_apply_protocol_registry_for_preset_data(
+    GDRApp* app,
+    const uint8_t* preset_data,
+    size_t preset_data_size);
+bool gdr_ensure_variable_item_list(GDRApp* app);
+bool gdr_ensure_widget(GDRApp* app);
+bool gdr_ensure_text_input(GDRApp* app);
+bool gdr_ensure_view_about(GDRApp* app);
+bool gdr_ensure_receiver_view(GDRApp* app);
+#ifdef ENABLE_DUAL_RX_SCENE
+bool gdr_ensure_dual_receiver_view(GDRApp* app);
+#endif
+void gdr_release_shared_radio_state(GDRApp* app);
+
+void gdr_rx_stack_suspend_for_tx(GDRApp* app);
+
+void gdr_rx_stack_resume_after_tx(GDRApp* app);
+
+void gdr_selected_capture_set(
+    GDRApp* app,
+    GDRHistory* history,
+    FuriMutex* mutex,
+    uint16_t index,
+    GDRCaptureOwner owner);
+void gdr_selected_capture_clear(GDRApp* app);
+bool gdr_selected_capture_is_valid(GDRApp* app);
+GDRHistory* gdr_selected_capture_get_history(GDRApp* app);
+uint16_t gdr_selected_capture_get_index(GDRApp* app);
+GDRHistorySource gdr_selected_capture_get_source(GDRApp* app);
+FlipperFormat* gdr_selected_capture_get_raw_data(GDRApp* app);
+bool gdr_selected_capture_get_path(GDRApp* app, FuriString* out_path);
+void gdr_selected_capture_release_scratch(GDRApp* app);
+
+void gdr_app_free(GDRApp* app);
+
+static const NotificationSequence sequence_tx = {
+    &message_note_c5,
+    &message_vibro_on,
+    &message_red_255,
+    &message_blue_255,
+    &message_blink_start_10,
+    &message_delay_25,
+    &message_vibro_off,
+    &message_delay_25,
+    &message_sound_off,
+    NULL,
+};

applications/system/Garage Door Remote/gdr_history.c

@@ -1,6 +1,6 @@
-// protopirate_history.c
-#include "protopirate_history.h"
-#include "helpers/protopirate_storage.h"
+// gdr_history.c
+#include "gdr_history.h"
+#include "helpers/gdr_storage.h"
 #include <lib/subghz/receiver.h>
 #include <storage/storage.h>
 #include <string.h>
@@ -8,28 +8,28 @@
 #include <furi.h>
 #include "defines.h"
 
-#define TAG                          "ProtoPirateHistory"
+#define TAG                          "GDRHistory"
 #define HISTORY_SCRATCH_TEXT_RESERVE 256U
 #define HISTORY_SCRATCH_PATH_RESERVE 128U
 #define HISTORY_ARENA_RESERVE        1024U
 
-static uint32_t protopirate_history_next_capture_seq = 0;
+static uint32_t gdr_history_next_capture_seq = 0;
 
 typedef struct {
     uint32_t seq_id;
     uint16_t text_offset;
     uint16_t text_len;
     uint8_t type;
-    ProtoPirateHistorySource source;
-} ProtoPirateHistoryItem;
+    GDRHistorySource source;
+} GDRHistoryItem;
 
-ARRAY_DEF(ProtoPirateHistoryItemArray, ProtoPirateHistoryItem, M_POD_OPLIST)
+ARRAY_DEF(GDRHistoryItemArray, GDRHistoryItem, M_POD_OPLIST)
 
-struct ProtoPirateHistory {
-    ProtoPirateHistoryItemArray_t data;
+struct GDRHistory {
+    GDRHistoryItemArray_t data;
     uint16_t last_index;
-    uint32_t last_update_timestamp[ProtoPirateHistorySourceCount];
-    uint8_t code_last_hash_data[ProtoPirateHistorySourceCount];
+    uint32_t last_update_timestamp[GDRHistorySourceCount];
+    uint8_t code_last_hash_data[GDRHistorySourceCount];
     Storage* storage;
     FlipperFormat* loaded_ff;
     int16_t loaded_idx;
@@ -39,26 +39,26 @@ struct ProtoPirateHistory {
     FuriString* text_arena;
 };
 
-static uint32_t protopirate_history_allocate_capture_seq(void) {
+static uint32_t gdr_history_allocate_capture_seq(void) {
     uint32_t tick_seed = (uint32_t)(furi_get_tick() & 0x0FFFFFFF);
     if(tick_seed == 0) {
         tick_seed = 1;
     }
 
     FURI_CRITICAL_ENTER();
-    if(protopirate_history_next_capture_seq == 0 ||
-       protopirate_history_next_capture_seq < tick_seed) {
-        protopirate_history_next_capture_seq = tick_seed;
+    if(gdr_history_next_capture_seq == 0 ||
+       gdr_history_next_capture_seq < tick_seed) {
+        gdr_history_next_capture_seq = tick_seed;
     }
-    uint32_t seq = protopirate_history_next_capture_seq++;
-    if(protopirate_history_next_capture_seq == 0) {
-        protopirate_history_next_capture_seq = 1;
+    uint32_t seq = gdr_history_next_capture_seq++;
+    if(gdr_history_next_capture_seq == 0) {
+        gdr_history_next_capture_seq = 1;
     }
     FURI_CRITICAL_EXIT();
     return seq;
 }
 
-void protopirate_history_release_scratch(ProtoPirateHistory* instance) {
+void gdr_history_release_scratch(GDRHistory* instance) {
     furi_check(instance);
     if(instance->loaded_ff) {
         flipper_format_free(instance->loaded_ff);
@@ -68,27 +68,27 @@ void protopirate_history_release_scratch(ProtoPirateHistory* instance) {
 }
 
 static void
-    protopirate_history_build_path(ProtoPirateHistory* instance, uint32_t seq_id, FuriString* out) {
+    gdr_history_build_path(GDRHistory* instance, uint32_t seq_id, FuriString* out) {
     UNUSED(instance);
-    protopirate_storage_build_history_path(seq_id, out);
+    gdr_storage_build_history_path(seq_id, out);
 }
 
 static void
-    protopirate_history_delete_capture_file(ProtoPirateHistory* instance, uint32_t seq_id) {
-    protopirate_history_build_path(instance, seq_id, instance->scratch_path);
-    protopirate_storage_delete_file(furi_string_get_cstr(instance->scratch_path));
+    gdr_history_delete_capture_file(GDRHistory* instance, uint32_t seq_id) {
+    gdr_history_build_path(instance, seq_id, instance->scratch_path);
+    gdr_storage_delete_file(furi_string_get_cstr(instance->scratch_path));
 }
 
-static void protopirate_history_delete_all_capture_files(ProtoPirateHistory* instance) {
-    size_t item_count = ProtoPirateHistoryItemArray_size(instance->data);
+static void gdr_history_delete_all_capture_files(GDRHistory* instance) {
+    size_t item_count = GDRHistoryItemArray_size(instance->data);
     for(size_t i = 0; i < item_count; i++) {
-        ProtoPirateHistoryItem* item = ProtoPirateHistoryItemArray_get(instance->data, i);
-        protopirate_history_delete_capture_file(instance, item->seq_id);
+        GDRHistoryItem* item = GDRHistoryItemArray_get(instance->data, i);
+        gdr_history_delete_capture_file(instance, item->seq_id);
     }
 }
 
 static void
-    protopirate_history_arena_remove(ProtoPirateHistory* instance, uint16_t offset, uint16_t len) {
+    gdr_history_arena_remove(GDRHistory* instance, uint16_t offset, uint16_t len) {
     if(len == 0) return;
 
     size_t arena_size = furi_string_size(instance->text_arena);
@@ -103,19 +103,19 @@ static void
     furi_string_cat_str(rebuilt, arena + offset + len);
     furi_string_move(instance->text_arena, rebuilt);
 
-    size_t n = ProtoPirateHistoryItemArray_size(instance->data);
+    size_t n = GDRHistoryItemArray_size(instance->data);
     for(size_t i = 0; i < n; i++) {
-        ProtoPirateHistoryItem* it = ProtoPirateHistoryItemArray_get(instance->data, i);
+        GDRHistoryItem* it = GDRHistoryItemArray_get(instance->data, i);
         if(it->text_offset > offset) {
             it->text_offset -= len;
         }
     }
 }
 
-ProtoPirateHistory* protopirate_history_alloc(void) {
-    ProtoPirateHistory* instance = malloc(sizeof(ProtoPirateHistory));
+GDRHistory* gdr_history_alloc(void) {
+    GDRHistory* instance = malloc(sizeof(GDRHistory));
     furi_check(instance);
-    ProtoPirateHistoryItemArray_init(instance->data);
+    GDRHistoryItemArray_init(instance->data);
     instance->last_index = 0;
     memset(instance->last_update_timestamp, 0, sizeof(instance->last_update_timestamp));
     memset(instance->code_last_hash_data, 0, sizeof(instance->code_last_hash_data));
@@ -138,11 +138,11 @@ ProtoPirateHistory* protopirate_history_alloc(void) {
     return instance;
 }
 
-void protopirate_history_free(ProtoPirateHistory* instance) {
+void gdr_history_free(GDRHistory* instance) {
     furi_check(instance);
-    protopirate_history_release_scratch(instance);
-    protopirate_history_delete_all_capture_files(instance);
-    ProtoPirateHistoryItemArray_clear(instance->data);
+    gdr_history_release_scratch(instance);
+    gdr_history_delete_all_capture_files(instance);
+    GDRHistoryItemArray_clear(instance->data);
 
     if(instance->scratch_text) {
         furi_string_free(instance->scratch_text);
@@ -164,29 +164,29 @@ void protopirate_history_free(ProtoPirateHistory* instance) {
     free(instance);
 }
 
-void protopirate_history_reset(ProtoPirateHistory* instance) {
+void gdr_history_reset(GDRHistory* instance) {
     furi_check(instance);
-    protopirate_history_release_scratch(instance);
-    protopirate_history_delete_all_capture_files(instance);
-    ProtoPirateHistoryItemArray_reset(instance->data);
+    gdr_history_release_scratch(instance);
+    gdr_history_delete_all_capture_files(instance);
+    GDRHistoryItemArray_reset(instance->data);
     furi_string_reset(instance->text_arena);
     instance->last_index = 0;
     memset(instance->last_update_timestamp, 0, sizeof(instance->last_update_timestamp));
     memset(instance->code_last_hash_data, 0, sizeof(instance->code_last_hash_data));
 }
 
-uint16_t protopirate_history_get_item(ProtoPirateHistory* instance) {
+uint16_t gdr_history_get_item(GDRHistory* instance) {
     furi_check(instance);
-    return ProtoPirateHistoryItemArray_size(instance->data);
+    return GDRHistoryItemArray_size(instance->data);
 }
 
-uint16_t protopirate_history_get_last_index(ProtoPirateHistory* instance) {
+uint16_t gdr_history_get_last_index(GDRHistory* instance) {
     furi_check(instance);
     return instance->last_index;
 }
 
-void protopirate_history_format_status_text(
-    ProtoPirateHistory* instance,
+void gdr_history_format_status_text(
+    GDRHistory* instance,
     char* output,
     size_t output_size) {
     furi_check(instance);
@@ -196,87 +196,87 @@ void protopirate_history_format_status_text(
         return;
     }
 
-    uint16_t n = protopirate_history_get_item(instance);
-    if(n >= PROTOPIRATE_HISTORY_MAX) {
+    uint16_t n = gdr_history_get_item(instance);
+    if(n >= GDR_HISTORY_MAX) {
         snprintf(output, output_size, "FULL");
     } else {
-        snprintf(output, output_size, "%u/%u", n, PROTOPIRATE_HISTORY_MAX);
+        snprintf(output, output_size, "%u/%u", n, GDR_HISTORY_MAX);
     }
 }
 
-void protopirate_history_get_status_text(ProtoPirateHistory* instance, FuriString* output) {
+void gdr_history_get_status_text(GDRHistory* instance, FuriString* output) {
     furi_check(instance);
     furi_check(output);
 
     char status_text[16];
-    protopirate_history_format_status_text(instance, status_text, sizeof(status_text));
+    gdr_history_format_status_text(instance, status_text, sizeof(status_text));
     furi_string_set_str(output, status_text);
 }
 
-bool protopirate_history_get_capture_path(
-    ProtoPirateHistory* instance,
+bool gdr_history_get_capture_path(
+    GDRHistory* instance,
     uint16_t idx,
     FuriString* out_path) {
     furi_check(instance);
     furi_check(out_path);
 
-    if(idx >= ProtoPirateHistoryItemArray_size(instance->data)) {
+    if(idx >= GDRHistoryItemArray_size(instance->data)) {
         return false;
     }
-    ProtoPirateHistoryItem* item = ProtoPirateHistoryItemArray_get(instance->data, idx);
-    protopirate_history_build_path(instance, item->seq_id, out_path);
+    GDRHistoryItem* item = GDRHistoryItemArray_get(instance->data, idx);
+    gdr_history_build_path(instance, item->seq_id, out_path);
     return true;
 }
 
-bool protopirate_history_capture_path_equals(
-    ProtoPirateHistory* instance,
+bool gdr_history_capture_path_equals(
+    GDRHistory* instance,
     uint16_t idx,
     const char* path) {
     furi_check(instance);
 
-    if(!path || idx >= ProtoPirateHistoryItemArray_size(instance->data)) {
+    if(!path || idx >= GDRHistoryItemArray_size(instance->data)) {
         return false;
     }
 
-    ProtoPirateHistoryItem* item = ProtoPirateHistoryItemArray_get(instance->data, idx);
-    protopirate_history_build_path(instance, item->seq_id, instance->scratch_path);
+    GDRHistoryItem* item = GDRHistoryItemArray_get(instance->data, idx);
+    gdr_history_build_path(instance, item->seq_id, instance->scratch_path);
     return strcmp(furi_string_get_cstr(instance->scratch_path), path) == 0;
 }
 
-ProtoPirateHistorySource protopirate_history_get_source(
-    ProtoPirateHistory* instance,
+GDRHistorySource gdr_history_get_source(
+    GDRHistory* instance,
     uint16_t idx) {
     furi_check(instance);
-    if(idx >= ProtoPirateHistoryItemArray_size(instance->data)) {
-        return ProtoPirateHistorySourceUnknown;
+    if(idx >= GDRHistoryItemArray_size(instance->data)) {
+        return GDRHistorySourceUnknown;
     }
-    return ProtoPirateHistoryItemArray_get(instance->data, idx)->source;
+    return GDRHistoryItemArray_get(instance->data, idx)->source;
 }
 
-const char* protopirate_history_source_name(ProtoPirateHistorySource source) {
+const char* gdr_history_source_name(GDRHistorySource source) {
     switch(source) {
-    case ProtoPirateHistorySourceExternal:
+    case GDRHistorySourceExternal:
         return "External";
-    case ProtoPirateHistorySourceInternal:
+    case GDRHistorySourceInternal:
         return "Internal";
     default:
         return "Unknown";
     }
 }
 
-bool protopirate_history_add_to_history(
-    ProtoPirateHistory* instance,
+bool gdr_history_add_to_history(
+    GDRHistory* instance,
     void* context,
     SubGhzRadioPreset* preset,
-    ProtoPirateHistorySource source) {
+    GDRHistorySource source) {
     furi_check(instance);
     furi_check(context);
 
-    if(source >= ProtoPirateHistorySourceCount) {
-        source = ProtoPirateHistorySourceUnknown;
+    if(source >= GDRHistorySourceCount) {
+        source = GDRHistorySourceUnknown;
     }
 
-    if(ProtoPirateHistoryItemArray_size(instance->data) >= PROTOPIRATE_HISTORY_MAX) {
+    if(GDRHistoryItemArray_size(instance->data) >= GDR_HISTORY_MAX) {
         return false;
     }
 
@@ -289,7 +289,7 @@ bool protopirate_history_add_to_history(
         return false;
     }
 
-    protopirate_history_release_scratch(instance);
+    gdr_history_release_scratch(instance);
 
     furi_string_reset(instance->scratch_text);
     furi_string_reset(instance->scratch_path);
@@ -307,13 +307,13 @@ bool protopirate_history_add_to_history(
         return false;
     }
 
-    if(source != ProtoPirateHistorySourceUnknown) {
+    if(source != GDRHistorySourceUnknown) {
         flipper_format_insert_or_update_string_cstr(
-            temp_ff, "RadioDevice", protopirate_history_source_name(source));
+            temp_ff, "RadioDevice", gdr_history_source_name(source));
     }
 
-    uint32_t seq = protopirate_history_allocate_capture_seq();
-    bool saved = protopirate_storage_save_history_capture(temp_ff, seq, instance->scratch_path);
+    uint32_t seq = gdr_history_allocate_capture_seq();
+    bool saved = gdr_storage_save_history_capture(temp_ff, seq, instance->scratch_path);
     flipper_format_free(temp_ff);
 
     if(!saved) {
@@ -332,7 +332,7 @@ bool protopirate_history_add_to_history(
     furi_check(offset <= UINT16_MAX);
     furi_string_cat_str(instance->text_arena, text_cstr);
 
-    ProtoPirateHistoryItem* item = ProtoPirateHistoryItemArray_push_raw(instance->data);
+    GDRHistoryItem* item = GDRHistoryItemArray_push_raw(instance->data);
     item->seq_id = seq;
     item->text_offset = (uint16_t)offset;
     item->text_len = (uint16_t)text_len;
@@ -345,57 +345,57 @@ bool protopirate_history_add_to_history(
         TAG,
         "Added item %u to history (size: %zu) seq=%lu",
         instance->last_index,
-        ProtoPirateHistoryItemArray_size(instance->data),
+        GDRHistoryItemArray_size(instance->data),
         (unsigned long)seq);
 
     return true;
 }
 
-void protopirate_history_delete_item(ProtoPirateHistory* instance, uint16_t idx) {
+void gdr_history_delete_item(GDRHistory* instance, uint16_t idx) {
     furi_check(instance);
 
-    size_t item_count = ProtoPirateHistoryItemArray_size(instance->data);
+    size_t item_count = GDRHistoryItemArray_size(instance->data);
     if(idx >= item_count) {
         return;
     }
 
     if(instance->loaded_ff) {
         if(instance->loaded_idx == (int16_t)idx) {
-            protopirate_history_release_scratch(instance);
+            gdr_history_release_scratch(instance);
         } else if(instance->loaded_idx > (int16_t)idx) {
             instance->loaded_idx--;
         }
     }
 
-    ProtoPirateHistoryItem* item = ProtoPirateHistoryItemArray_get(instance->data, idx);
+    GDRHistoryItem* item = GDRHistoryItemArray_get(instance->data, idx);
     uint32_t seq_id = item->seq_id;
     uint16_t text_offset = item->text_offset;
     uint16_t text_len = item->text_len;
 
-    protopirate_history_delete_capture_file(instance, seq_id);
-    ProtoPirateHistoryItemArray_pop_at(NULL, instance->data, idx);
-    protopirate_history_arena_remove(instance, text_offset, text_len);
+    gdr_history_delete_capture_file(instance, seq_id);
+    GDRHistoryItemArray_pop_at(NULL, instance->data, idx);
+    gdr_history_arena_remove(instance, text_offset, text_len);
 
     FURI_LOG_I(
         TAG,
         "Deleted history item %u (size: %zu)",
         idx,
-        ProtoPirateHistoryItemArray_size(instance->data));
+        GDRHistoryItemArray_size(instance->data));
 }
 
-void protopirate_history_get_text_item_menu(
-    ProtoPirateHistory* instance,
+void gdr_history_get_text_item_menu(
+    GDRHistory* instance,
     FuriString* output,
     uint16_t idx) {
     furi_check(instance);
     furi_check(output);
 
-    if(idx >= ProtoPirateHistoryItemArray_size(instance->data)) {
+    if(idx >= GDRHistoryItemArray_size(instance->data)) {
         furi_string_set(output, "---");
         return;
     }
 
-    ProtoPirateHistoryItem* item = ProtoPirateHistoryItemArray_get(instance->data, idx);
+    GDRHistoryItem* item = GDRHistoryItemArray_get(instance->data, idx);
     const char* arena = furi_string_get_cstr(instance->text_arena);
     const char* str = arena + item->text_offset;
     size_t remaining = item->text_len;
@@ -407,16 +407,16 @@ void protopirate_history_get_text_item_menu(
 
     uint16_t display_idx = idx + 1;
     const char* source_tag = "";
-    if(item->source == ProtoPirateHistorySourceExternal) {
+    if(item->source == GDRHistorySourceExternal) {
         source_tag = "[E] ";
-    } else if(item->source == ProtoPirateHistorySourceInternal) {
+    } else if(item->source == GDRHistorySourceInternal) {
         source_tag = "[I] ";
     }
     furi_string_printf(output, "%u. %s%.*s", display_idx, source_tag, (int)len, str);
 }
 
-void protopirate_history_get_text_item_detail(
-    ProtoPirateHistory* instance,
+void gdr_history_get_text_item_detail(
+    GDRHistory* instance,
     uint16_t idx,
     FuriString* output,
     SubGhzEnvironment* environment) {
@@ -424,20 +424,20 @@ void protopirate_history_get_text_item_detail(
     furi_check(output);
     UNUSED(environment);
 
-    if(idx >= ProtoPirateHistoryItemArray_size(instance->data)) {
+    if(idx >= GDRHistoryItemArray_size(instance->data)) {
         furi_string_set(output, "---");
         return;
     }
 
-    ProtoPirateHistoryItem* item = ProtoPirateHistoryItemArray_get(instance->data, idx);
+    GDRHistoryItem* item = GDRHistoryItemArray_get(instance->data, idx);
     const char* arena = furi_string_get_cstr(instance->text_arena);
     furi_string_set_strn(output, arena + item->text_offset, item->text_len);
 }
 
-FlipperFormat* protopirate_history_get_raw_data(ProtoPirateHistory* instance, uint16_t idx) {
+FlipperFormat* gdr_history_get_raw_data(GDRHistory* instance, uint16_t idx) {
     furi_check(instance);
 
-    if(idx >= ProtoPirateHistoryItemArray_size(instance->data)) {
+    if(idx >= GDRHistoryItemArray_size(instance->data)) {
         return NULL;
     }
 
@@ -445,10 +445,10 @@ FlipperFormat* protopirate_history_get_raw_data(ProtoPirateHistory* instance, ui
         return instance->loaded_ff;
     }
 
-    protopirate_history_release_scratch(instance);
+    gdr_history_release_scratch(instance);
 
-    ProtoPirateHistoryItem* item = ProtoPirateHistoryItemArray_get(instance->data, idx);
-    protopirate_history_build_path(instance, item->seq_id, instance->scratch_path);
+    GDRHistoryItem* item = GDRHistoryItemArray_get(instance->data, idx);
+    gdr_history_build_path(instance, item->seq_id, instance->scratch_path);
 
     instance->loaded_ff = flipper_format_file_alloc(instance->storage);
     furi_check(instance->loaded_ff);
@@ -464,19 +464,19 @@ FlipperFormat* protopirate_history_get_raw_data(ProtoPirateHistory* instance, ui
     return instance->loaded_ff;
 }
 
-void protopirate_history_set_item_str(ProtoPirateHistory* instance, uint16_t idx, const char* str) {
+void gdr_history_set_item_str(GDRHistory* instance, uint16_t idx, const char* str) {
     furi_check(instance);
     furi_check(str);
 
-    if(idx >= ProtoPirateHistoryItemArray_size(instance->data)) {
+    if(idx >= GDRHistoryItemArray_size(instance->data)) {
         return;
     }
 
-    ProtoPirateHistoryItem* item = ProtoPirateHistoryItemArray_get(instance->data, idx);
+    GDRHistoryItem* item = GDRHistoryItemArray_get(instance->data, idx);
     uint16_t old_offset = item->text_offset;
     uint16_t old_len = item->text_len;
 
-    protopirate_history_arena_remove(instance, old_offset, old_len);
+    gdr_history_arena_remove(instance, old_offset, old_len);
 
     size_t new_offset = furi_string_size(instance->text_arena);
     size_t new_len = strlen(str);

applications/system/Garage Door Remote/gdr_history.h

@@ -0,0 +1,63 @@
+// gdr_history.h
+#pragma once
+
+#include <stddef.h>
+#include <lib/subghz/receiver.h>
+#include <lib/subghz/protocols/base.h>
+
+#define GDR_HISTORY_MAX 10
+
+typedef struct SubGhzEnvironment SubGhzEnvironment;
+typedef struct GDRHistory GDRHistory;
+
+typedef enum {
+    GDRHistorySourceUnknown = 0,
+    GDRHistorySourceExternal,
+    GDRHistorySourceInternal,
+    GDRHistorySourceCount,
+} GDRHistorySource;
+
+GDRHistory* gdr_history_alloc(void);
+void gdr_history_free(GDRHistory* instance);
+void gdr_history_reset(GDRHistory* instance);
+uint16_t gdr_history_get_item(GDRHistory* instance);
+uint16_t gdr_history_get_last_index(GDRHistory* instance);
+GDRHistorySource gdr_history_get_source(
+    GDRHistory* instance,
+    uint16_t idx);
+const char* gdr_history_source_name(GDRHistorySource source);
+void gdr_history_format_status_text(
+    GDRHistory* instance,
+    char* output,
+    size_t output_size);
+void gdr_history_get_status_text(GDRHistory* instance, FuriString* output);
+
+bool gdr_history_get_capture_path(
+    GDRHistory* instance,
+    uint16_t idx,
+    FuriString* out_path);
+bool gdr_history_capture_path_equals(
+    GDRHistory* instance,
+    uint16_t idx,
+    const char* path);
+
+bool gdr_history_add_to_history(
+    GDRHistory* instance,
+    void* context,
+    SubGhzRadioPreset* preset,
+    GDRHistorySource source);
+void gdr_history_delete_item(GDRHistory* instance, uint16_t idx);
+void gdr_history_get_text_item_menu(
+    GDRHistory* instance,
+    FuriString* output,
+    uint16_t idx);
+void gdr_history_get_text_item_detail(
+    GDRHistory* instance,
+    uint16_t idx,
+    FuriString* output,
+    SubGhzEnvironment* environment);
+FlipperFormat* gdr_history_get_raw_data(GDRHistory* instance, uint16_t idx);
+
+void gdr_history_release_scratch(GDRHistory* instance);
+
+void gdr_history_set_item_str(GDRHistory* instance, uint16_t idx, const char* str);

applications/system/Garage Door Remote/gdr_icons.h

@@ -9,5 +9,5 @@ extern const Icon I_PP_scanning_123x52;
 extern const Icon I_PP_scanning_ext_123x52;
 extern const Icon I_Pin_back_arrow_10x8;
 extern const Icon I_WarningDolphin_45x42;
-extern const Icon I_protopirate_10px;
+extern const Icon I_gdr_10px;
 extern const Icon I_subghz_10px;