spiky-nes 0.1.0__tar.gz

spiky_nes-0.1.0/CMakeLists.txt

@@ -0,0 +1,254 @@
+cmake_minimum_required(VERSION 4.0)
+project(SpikyNes)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+option(SPIKY_NES_ENABLE_TESTS "Build tests" OFF)
+option(SPIKY_NES_ENABLE_ROM_TESTS "Build ROM tests" OFF)
+option(SPIKY_NES_ENABLE_STRICT "Use strict compile options" OFF)
+option(SPIKY_NES_ENABLE_COVERAGE "Enable coverage reporting" OFF)
+option(SPIKY_NES_ENABLE_UI "Build SDL UI" OFF)
+option(SPIKY_NES_BIND_PYTHON "Enable Python binding" OFF)
+option(SPIKY_NES_BIND_ES "Enable ECMAScript binding" OFF)
+
+if(APPLE)
+    set(ENV{PKG_CONFIG_PATH} "/opt/homebrew/lib/pkgconfig:$ENV{PKG_CONFIG_PATH}")
+endif()
+
+if(SPIKY_NES_ENABLE_STRICT)
+    if (CMAKE_CXX_COMPILER_ID MATCHES "Clang|GNU")
+        add_compile_options(
+                -Wall
+                -Wextra
+                -Werror
+                -Wpedantic
+                -Wmissing-include-dirs
+                -Wundef
+                -Wredundant-decls
+        )
+    endif()
+endif()
+
+if(SPIKY_NES_ENABLE_COVERAGE)
+    if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
+        add_compile_options(--coverage -O0 -g -fno-elide-constructors -fno-default-inline)
+        add_link_options(--coverage)
+    endif()
+endif()
+
+add_library(SpikyNesCore STATIC
+        include/core/emulator.h
+        src/core/emulator.cpp
+        include/core/cpu.h
+        src/core/cpu.cpp
+        include/core/ppu.h
+        src/core/ppu.cpp
+        include/core/apu.h
+        src/core/apu.cpp
+        include/core/bus.h
+        src/core/bus.cpp
+        include/core/cartridge.h
+        src/core/cartridge.cpp
+        include/core/constants.h
+        include/core/utils.h
+        src/core/utils.cpp
+        src/core/cpu/addressing.cpp
+        src/core/cpu/operation.cpp
+        src/core/cpu/unofficial.cpp
+        include/core/controller.h
+        src/core/controller.cpp
+        include/core/mapper.h
+        src/core/mapper.cpp
+        src/core/mapper.cpp
+        include/core/mapper/mapper_000.h
+        src/core/mapper/mapper_000.cpp
+        include/core/mapper/mapper_003.h
+        src/core/mapper/mapper_003.cpp
+        include/core/mapper/mapper_001.h
+        src/core/mapper/mapper_001.cpp
+        include/core/mapper/mapper_002.h
+        src/core/mapper/mapper_002.cpp
+        include/core/mapper/mapper_004.h
+        src/core/mapper/mapper_004.cpp
+)
+
+target_include_directories(SpikyNesCore
+        PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include
+)
+
+if(SPIKY_NES_ENABLE_TESTS)
+    enable_testing()
+
+    include(FetchContent)
+
+    FetchContent_Declare(
+            googletest
+            GIT_REPOSITORY https://github.com/google/googletest.git
+            GIT_TAG v1.17.0
+    )
+
+    FetchContent_MakeAvailable(googletest)
+
+    FetchContent_Declare(
+            tinypng
+            GIT_REPOSITORY https://github.com/CyberZHG/TinyPNG.git
+            GIT_TAG v1.0.0
+    )
+
+    FetchContent_MakeAvailable(tinypng)
+
+    add_executable(runTests
+            tests/test_main.cpp
+            tests/core/test_image_utils.h
+            tests/core/test_image_utils.cpp
+            tests/core/cpu/test_cpu_utils.cpp
+            tests/core/cpu/test_cpu_utils.h
+            tests/core/cpu/test_load.cpp
+            tests/core/cpu/test_store.cpp
+            tests/core/cpu/test_transfer.cpp
+            tests/core/cpu/test_stack.cpp
+            tests/core/cpu/test_shift.cpp
+            tests/core/cpu/test_logical.cpp
+            tests/core/cpu/test_arithmetic.cpp
+            tests/core/cpu/test_increment.cpp
+            tests/core/cpu/test_flags.cpp
+            tests/core/cpu/test_jump.cpp
+            tests/core/cpu/test_control.cpp
+            tests/core/cpu/test_branch.cpp
+            tests/core/cpu/test_nop.cpp
+            tests/core/test_cartridge.cpp
+            tests/core/test_controller.cpp
+            tests/core/ppu/test_registers.cpp
+            tests/core/test_utils.cpp
+            tests/core/ppu/test_frame_timing.cpp
+            tests/core/ppu/test_shift_registers.cpp
+            tests/core/ppu/test_scroll.cpp
+            tests/core/ppu/test_background_rendering.cpp
+            tests/core/ppu/test_sprite_rendering.cpp
+            tests/core/ppu/test_ppu_utils.h
+            tests/core/ppu/test_ppu_utils.cpp
+            tests/core/mapper/test_mapper_000.cpp
+            tests/core/mapper/test_mapper_001.cpp
+            tests/core/mapper/test_mapper_002.cpp
+            tests/core/mapper/test_mapper_003.cpp
+            tests/core/mapper/test_mapper_004.cpp
+            tests/core/apu/test_pulse.cpp
+            tests/core/apu/test_triangle.cpp
+            tests/core/apu/test_noise.cpp
+            tests/core/apu/test_dmc.cpp
+            tests/core/ppu/rom/test_ppu_read_buffer.cpp
+            tests/core/ppu/rom/test_ppu_open_bus.cpp
+    )
+
+    if(SPIKY_NES_ENABLE_ROM_TESTS)
+        target_sources(runTests PRIVATE
+                tests/core/cpu/rom/test_nestest.cpp
+                tests/core/cpu/rom/test_cpu_timing.cpp
+                tests/core/cpu/rom/test_all_instrs_v5.cpp
+                tests/core/ppu/rom/test_ppu_tests.cpp
+                tests/core/ppu/rom/test_sprite_hit_tests.cpp
+                tests/core/ppu/rom/test_sprite_overflow_tests.cpp
+                tests/core/ppu/rom/test_vbl_nmi_timing.cpp
+                tests/core/apu/rom/test_apu_test.cpp
+                tests/core/mapper/rom/test_mmc3.cpp
+        )
+        target_compile_definitions(runTests PRIVATE SPIKY_NES_ROM_TESTS_ENABLED)
+    endif()
+
+    target_link_libraries(runTests
+            PRIVATE SpikyNesCore
+            PRIVATE gtest gtest_main
+            PRIVATE TinyPNG
+    )
+
+    add_test(NAME SpikyNesCoreTests COMMAND runTests)
+endif()
+
+if(SPIKY_NES_ENABLE_UI)
+    include(FetchContent)
+
+    FetchContent_Declare(
+            SDL
+            GIT_REPOSITORY https://github.com/libsdl-org/SDL.git
+            GIT_TAG release-3.4.0
+    )
+
+    FetchContent_MakeAvailable(SDL)
+
+    FetchContent_Declare(
+            imgui
+            GIT_REPOSITORY https://github.com/ocornut/imgui.git
+            GIT_TAG docking
+    )
+    FetchContent_MakeAvailable(imgui)
+
+    add_executable(SpikyNesUI
+            src/ui/main.cpp
+            include/ui/sdl_emulator.h
+            src/ui/sdl_emulator.cpp
+    )
+
+    target_sources(SpikyNesUI PRIVATE
+            ${imgui_SOURCE_DIR}/imgui.cpp
+            ${imgui_SOURCE_DIR}/imgui_draw.cpp
+            ${imgui_SOURCE_DIR}/imgui_tables.cpp
+            ${imgui_SOURCE_DIR}/imgui_widgets.cpp
+            ${imgui_SOURCE_DIR}/backends/imgui_impl_sdl3.cpp
+            ${imgui_SOURCE_DIR}/backends/imgui_impl_sdlrenderer3.cpp
+    )
+
+    target_include_directories(SpikyNesUI
+            PRIVATE ${imgui_SOURCE_DIR}
+            PRIVATE ${imgui_SOURCE_DIR}/backends
+            PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include
+    )
+
+    target_link_libraries(SpikyNesUI
+            PRIVATE SpikyNesCore SDL3::SDL3
+    )
+endif()
+
+if(SPIKY_NES_BIND_PYTHON)
+    include(FetchContent)
+    FetchContent_Declare(
+            pybind11
+            GIT_REPOSITORY https://github.com/pybind/pybind11.git
+            GIT_TAG v3.0
+    )
+    FetchContent_MakeAvailable(pybind11)
+
+    pybind11_add_module(_core
+            python/binding.cpp
+    )
+    target_link_libraries(_core
+            PRIVATE SpikyNesCore
+    )
+    install(TARGETS _core
+            LIBRARY DESTINATION spiky_nes)
+    install(FILES python/wrapper/__init__.py DESTINATION spiky_nes)
+endif()
+
+if(SPIKY_NES_BIND_ES)
+    add_executable(SpikyNesWASM
+            wasm/binding.cpp
+    )
+
+    target_link_libraries(SpikyNesWASM
+            PRIVATE SpikyNesCore
+    )
+
+    target_compile_options(SpikyNesWASM PRIVATE "-O3")
+
+    set_target_properties(SpikyNesWASM PROPERTIES SUFFIX ".js")
+
+    target_link_options(SpikyNesWASM PRIVATE
+            "--bind"
+            "-sMODULARIZE=1"
+            "-sEXPORT_ES6=1"
+            "-sEXPORT_NAME=SpikyNesWASMModule"
+            "-sALLOW_MEMORY_GROWTH=1"
+    )
+endif()

spiky_nes-0.1.0/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.2
+Name: spiky-nes
+Version: 0.1.0
+Summary: A toy NES emulator.
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: C++
+Classifier: Operating System :: OS Independent
+Project-URL: Homepage, https://github.com/CyberZHG/SpikyNES
+Project-URL: Repository, https://github.com/CyberZHG/SpikyNES
+Project-URL: Issues, https://github.com/CyberZHG/SpikyNES/issues
+Requires-Python: >=3.8
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: black; extra == "test"
+Requires-Dist: isort; extra == "test"
+Requires-Dist: flake8; extra == "test"
+Description-Content-Type: text/markdown
+
+# spiky-nes
+
+Python bindings for [SpikyNES](https://github.com/CyberZHG/SpikyNES), a toy NES emulator.
+
+Supported mappers: 0 (NROM), 1 (MMC1), 2 (UxROM), 3 (CNROM), 4 (MMC3).
+
+## Installation
+
+```bash
+pip install spiky-nes
+```
+
+## Quick Start
+
+```python
+import spiky_nes
+
+emulator = spiky_nes.Emulator()
+assert emulator.load_rom("game.nes")
+
+emulator.press(spiky_nes.Button.START)
+audio = emulator.run_frame(sample_rate=44100)
+emulator.release(spiky_nes.Button.START)
+
+rgba = emulator.frame_buffer()  # 256 * 240 * 4 bytes
+```
+
+Saving a frame with Pillow:
+
+```python
+from PIL import Image
+
+Image.frombytes("RGBA", (spiky_nes.SCREEN_WIDTH, spiky_nes.SCREEN_HEIGHT), emulator.frame_buffer()).save("frame.png")
+```
+

spiky_nes-0.1.0/include/core/apu.h

@@ -0,0 +1,183 @@
+#ifndef SPIKYNES_APU_H
+#define SPIKYNES_APU_H
+
+#include <array>
+
+#include "core/constants.h"
+#include "core/utils.h"
+
+namespace nes_core {
+
+    class Bus;
+
+    struct PulseRegisters {
+        void reset();
+        void write(std::uint16_t addr, std::uint16_t value);
+        [[nodiscard]] std::uint8_t output() const;
+
+        void envelopeStep();
+        void sweepStep(bool isPulse1);
+        void timerStep();
+        void lengthCounterStep();
+
+        std::uint8_t duty, dutyBit;
+        bool lengthCounterHalted;
+        bool constantVolume;
+        std::uint8_t volume;
+
+        bool sweepEnabled;
+        std::uint8_t sweepDividerPeriod;
+        bool sweepNegate;
+        std::uint8_t sweepShift;
+        bool sweepReload;
+        std::uint8_t sweepCounter;
+
+        std::uint16_t timerPeriod;
+        std::uint8_t lengthCounterLoad;
+        bool envelopeStart;
+        std::uint8_t envelopeDecayLevel;
+        std::uint8_t envelopeDivider;
+
+        std::uint16_t timer;
+        std::uint8_t lengthCounter;
+    };
+
+    struct TriangleRegisters {
+        void reset();
+        void write(std::uint16_t addr, std::uint16_t value);
+        [[nodiscard]] std::uint8_t output() const;
+
+        void linearCounterStep();
+        void timerStep();
+        void lengthCounterStep();
+
+        bool lengthCounterHalted;
+        std::uint8_t linearCounterReload;
+        std::uint8_t linearCounter;
+
+        std::uint16_t timerPeriod;
+        std::uint8_t lengthCounterLoad;
+        bool linearStart;
+
+        std::uint8_t dutyIndex;
+        std::uint16_t timer;
+        std::uint8_t lengthCounter;
+    };
+
+    struct NoiseRegisters {
+        void reset();
+        void write(std::uint16_t addr, std::uint16_t value);
+        [[nodiscard]] std::uint8_t output() const;
+
+        void envelopeStep();
+        void timerStep();
+        void lengthCounterStep();
+
+        bool lengthCounterHalted;
+        bool constantVolume;
+        std::uint8_t volume;
+
+        bool mode;
+        std::uint8_t periodIndex;
+        std::uint16_t shiftRegister;
+
+        bool envelopeStart;
+        std::uint8_t envelopeDecayLevel;
+        std::uint8_t envelopeDivider;
+
+        std::uint16_t timer;
+        std::uint8_t lengthCounter;
+    };
+
+    struct DMCRegisters {
+        void reset();
+        void write(std::uint16_t addr, std::uint16_t value);
+        [[nodiscard]] std::uint8_t output() const;
+
+        void timerStep();
+        void restart();
+
+        bool irqEnabled;
+        bool loopEnabled;
+        std::uint8_t rateIndex;
+
+        std::uint8_t outputLevel;
+
+        std::uint8_t sampleAddress;
+        std::uint8_t sampleLength;
+
+        std::uint16_t currentAddress;
+        std::uint16_t bytesRemaining;
+        std::uint8_t sampleBuffer;
+        bool sampleBufferEmpty;
+
+        std::uint8_t shiftRegister;
+        std::uint8_t bitsRemaining;
+        bool silence;
+
+        bool irqFlag;
+        std::uint16_t timer;
+    };
+
+    struct APURegisters {
+        void reset();
+
+        void write(std::uint16_t addr, std::uint16_t value);
+
+        PulseRegisters pulse1{};
+        PulseRegisters pulse2{};
+        TriangleRegisters triangle{};
+        NoiseRegisters noise{};
+        DMCRegisters dmc{};
+
+        bool pulse1Enabled = false;
+        bool pulse2Enabled = false;
+        bool triangleEnabled = false;
+        bool noiseEnabled = false;
+        bool dmcEnabled = false;
+
+        bool sequencerMode = false;
+        bool irqInhibited = false;
+        bool frameIrqFlag = false;
+    };
+
+    class APU {
+    public:
+        explicit APU(Bus* bus);
+
+        void reset();
+
+        [[nodiscard]] std::uint8_t read(std::uint16_t addr);
+        void write(std::uint16_t addr, std::uint8_t value);
+
+        void step();
+
+        APURegisters& registers() { return regs_; }
+        [[nodiscard]] const APURegisters& registers() const { return regs_; }
+
+        [[nodiscard]] float outputBuffer() const { return outputBuffer_; }
+
+        [[nodiscard]] bool irqAsserted() const { return regs_.frameIrqFlag || regs_.dmc.irqFlag; }
+
+    protected:
+        void quarterFrameStep();
+        void halfFrameStep();
+
+        [[nodiscard]] std::uint8_t pulse1Output() const;
+        [[nodiscard]] std::uint8_t pulse2Output() const;
+        [[nodiscard]] std::uint8_t triangleOutput() const;
+        [[nodiscard]] std::uint8_t noiseOutput() const;
+        [[nodiscard]] std::uint8_t dmcOutput() const;
+        [[nodiscard]] float mixOutputs() const;
+
+    private:
+        Bus* bus_ = nullptr;
+        APURegisters regs_{};
+        std::int64_t cycle_ = 0;
+        float outputBuffer_ = 0.0;
+        int frameResetCountdown_ = -1;
+    };
+
+}
+
+#endif //SPIKYNES_APU_H

spiky_nes-0.1.0/include/core/bus.h

@@ -0,0 +1,59 @@
+#ifndef SPIKYNES_BUS_H
+#define SPIKYNES_BUS_H
+
+#include <cstdint>
+
+#include "core/constants.h"
+
+namespace nes_core {
+
+    class CPU;
+    class PPU;
+    class APU;
+    class Cartridge;
+    class Controller;
+
+    class Bus {
+    public:
+        Bus(CPU* cpu, PPU* ppu, APU* apu, Cartridge* cartridge, Controller* controller1, Controller* controller2);
+
+        void reset();
+
+        [[nodiscard]] std::uint8_t cpuRead(std::uint16_t addr);
+        void cpuWrite(std::uint16_t addr, std::uint8_t value);
+        [[nodiscard]] std::uint8_t lastBusValue() const { return lastBusValue_; }
+        void setLastBusValue(const std::uint8_t value) { lastBusValue_ = value; }
+
+        [[nodiscard]] std::uint8_t ppuRead(std::uint16_t addr) const;
+        void ppuWrite(std::uint16_t addr, std::uint8_t value) const;
+
+        void cpuNMI() const;
+        void cpuNMIClear() const;
+        void cpuStall(int cycles) const;
+        [[nodiscard]] std::int64_t cpuCycles() const;
+
+        [[nodiscard]] std::int32_t ppuScanline() const;
+        [[nodiscard]] std::int32_t ppuCycle() const;
+        [[nodiscard]] std::int64_t ppuFrame() const;
+        [[nodiscard]] std::int64_t ppuCycles() const;
+
+        void notifyA12(std::uint16_t addr) const;
+        void mapperPpuStep() const;
+
+        [[nodiscard]] bool irqAsserted() const;
+        [[nodiscard]] Mirroring mirroring() const;
+
+    private:
+        CPU* cpu_ = nullptr;
+        PPU* ppu_ = nullptr;
+        APU* apu_ = nullptr;
+        Cartridge* cartridge_ = nullptr;
+        Controller* controller1_ = nullptr;
+        Controller* controller2_ = nullptr;
+
+        std::uint8_t lastBusValue_ = 0;
+    };
+
+}
+
+#endif //SPIKYNES_BUS_H

spiky_nes-0.1.0/include/core/cartridge.h

@@ -0,0 +1,76 @@
+#ifndef SPIKYNES_CARTRIDGE_H
+#define SPIKYNES_CARTRIDGE_H
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <memory>
+
+#include "constants.h"
+#include "core/mapper.h"
+
+namespace nes_core {
+
+    class Bus;
+
+    struct INESHeader {
+        std::uint8_t prgRomBanks = 0;  // PRG ROM size in 16KB units
+        std::uint8_t prgRamBanks = 0;  // PRG RAM size in 8KB units
+        std::uint8_t chrRomBanks = 0;  // CHR ROM size in 8KB units
+        std::uint16_t mapper = 0;      // Mapper number
+        std::uint8_t subMapper = 0;    // Sub-mapper number
+        bool isNES2 = false;
+        bool verticalMirroring = false;
+        bool batteryBacked = false;
+        bool trainer = false;
+    };
+
+    class Cartridge {
+    public:
+        explicit Cartridge(Bus* bus);
+
+        bool loadFromFile(const std::string& path);
+        bool loadFromMemory(const std::vector<std::uint8_t>& buffer);
+        void reset();
+
+        /** Initialize PRG ROM with given size (for testing). */
+        void initPrgRom(std::size_t size);
+        /** Initialize PRG RAM with given size (for testing). */
+        void initPrgRam(std::size_t size = PRG_RAM_BANK_SIZE);
+        /** Initialize CHR ROM with given size (for testing). */
+        void initChrRom(std::size_t size);
+        /** Initialize CHR RAM with given size (for testing). */
+        void initChrRam(std::size_t size = CHR_ROM_BANK_SIZE);
+
+        void initMapper(std::uint16_t mapperId, std::uint8_t prgRomBanks, std::uint8_t prgRamBanks, std::uint8_t chrRomBanks);
+
+        [[nodiscard]] std::uint8_t cpuRead(std::uint16_t addr) const;
+        void cpuWrite(std::uint16_t addr, std::uint8_t value);
+
+        [[nodiscard]] std::uint8_t ppuRead(std::uint16_t addr) const;
+        void ppuWrite(std::uint16_t addr, std::uint8_t value);
+
+        void notifyA12(std::uint16_t addr) const;
+        void mapperPpuStep() const;
+
+        [[nodiscard]] Mirroring mirroring() const;
+        [[nodiscard]] bool irqAsserted() const;
+        void setMirroring(const Mirroring m) { mirroring_ = m; }
+
+        [[nodiscard]] const INESHeader& header() const { return header_; }
+
+    private:
+        Bus* bus_ = nullptr;
+
+        INESHeader header_{};
+        std::vector<std::uint8_t> prgRom_{};
+        std::vector<std::uint8_t> prgRam_{};
+        std::vector<std::uint8_t> chrRom_{};
+        std::vector<std::uint8_t> chrRam_{};
+        std::unique_ptr<Mapper> mapper_ = nullptr;
+        Mirroring mirroring_ = Mirroring::HORIZONTAL;
+    };
+
+}
+
+#endif //SPIKYNES_CARTRIDGE_H

spiky_nes-0.1.0/include/core/constants.h

@@ -0,0 +1,58 @@
+#ifndef SPIKYNES_CONSTANTS_H
+#define SPIKYNES_CONSTANTS_H
+
+#include <cstdint>
+#include <cstdio>
+
+namespace nes_core {
+
+    constexpr std::int32_t CPU_FREQUENCY_NTSC = 1789773;  // 1.789773 MHz
+    constexpr std::int32_t CPU_FREQUENCY_PAL = 1662607;  // 1.662607 MHz
+
+    constexpr std::size_t CPU_RAM_SIZE = 0x0800;
+    constexpr std::size_t CPU_STACK_OFFSET = 0x0100;
+    constexpr std::size_t CPU_PROGRAM_BEGIN = 0x0200;
+    constexpr std::uint16_t CPU_RAM_END = 0x2000;
+    constexpr std::uint16_t CPU_VECTOR_NMI = 0xFFFA;
+    constexpr std::uint16_t CPU_VECTOR_RESET = 0xFFFC;
+    constexpr std::uint16_t CPU_VECTOR_IRQ = 0xFFFE;
+
+    constexpr std::uint16_t PPU_REG_START = 0x2000;
+    constexpr std::size_t PPU_REG_COUNT = 8;
+    constexpr std::uint16_t PPU_REG_END = 0x4000;
+    constexpr std::uint16_t PPU_MEM_MASK = 0x3FFF;
+    constexpr std::uint16_t PPU_NAMETABLE_START = 0x2000;
+    constexpr std::uint16_t PPU_NAMETABLE_MIRRO_START = 0x3000;
+    constexpr std::size_t PPU_NAMETABLE_SIZE = 0x1000;
+    constexpr std::uint16_t PPU_PALETTE_START = 0x3F00;
+    constexpr std::size_t PPU_PALETTE_SIZE = 0x20;
+    constexpr std::uint16_t PPU_OAM_SIZE = 0x100;
+    constexpr std::uint16_t PPU_SECONDARY_OAM_SIZE = 32;
+    constexpr std::uint16_t PPU_FRAME_BUFFER_SIZE = 256 * 240;
+
+    constexpr std::uint16_t APU_REG_START = 0x4000;
+    constexpr std::size_t APU_REG_COUNT = 0x18;
+    constexpr std::uint16_t APU_REG_END = 0x4018;
+
+    constexpr std::uint16_t PRG_RAM_START = 0x6000;
+    constexpr std::size_t PRG_RAM_SIZE = 0x2000;
+    constexpr std::size_t PRG_RAM_BANK_SIZE = 0x2000;
+    constexpr std::size_t PRG_ROM_SIZE = 0x8000;
+    constexpr std::uint16_t PRG_ROM_START = 0x8000;
+    constexpr std::size_t PRG_ROM_BANK_SIZE = 0x4000;
+
+    constexpr std::size_t CHR_ROM_BANK_SIZE = 0x2000;
+
+    constexpr std::size_t INES_HEADER_SIZE = 16;
+
+    enum class Mirroring {
+        INVALID,
+        HORIZONTAL,
+        VERTICAL,
+        SINGLE_LOWER,
+        SINGLE_UPPER,
+    };
+
+}
+
+#endif //SPIKYNES_CONSTANTS_H