amaterasu 0.6.0

data/lib/amaterasu/game_boy/timer.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+module Amaterasu
+  module GameBoy
+    # Models the built-in clock timer inside the Game Boy.
+    #
+    # As of now it is implemented using M-cycle accuracy,
+    # I might change it afterwards to T-cycle accuracy, but
+    # as of now all acceptance tests are passing, so no need.
+    class Timer
+      # Each tick advances 4 T-cycles / 1 M-cycle
+      T_CYCLES = 4
+
+      # Master clock defined by the hardware specs (in T-cycles).
+      MASTER_CLOCK_FREQUENCY = 4_194_304
+
+      # Frequency in which TIMA increments once for each TAC clock select.
+      TIMA_INCREMENT_FREQUENCIES = [
+        4_096,
+        262_144,
+        65_536,
+        16_384
+      ].freeze
+
+      # How many T-cycles are needed to increment TIMA once for each clock select.
+      TIMA_INCREMENT_CYCLES = [
+        MASTER_CLOCK_FREQUENCY / TIMA_INCREMENT_FREQUENCIES[0b00],
+        MASTER_CLOCK_FREQUENCY / TIMA_INCREMENT_FREQUENCIES[0b01],
+        MASTER_CLOCK_FREQUENCY / TIMA_INCREMENT_FREQUENCIES[0b10],
+        MASTER_CLOCK_FREQUENCY / TIMA_INCREMENT_FREQUENCIES[0b11]
+      ].freeze
+
+      # TIMA only increments if there is a falling edge.
+      # The value needs to be divided by 2 to achieve the correct value.
+      # The given bit needs to flip twice to reach a falling edge (0 -> 1 and 1 -> 0).
+      COUNTER_FALLING_EDGE_CYCLES = [
+        TIMA_INCREMENT_CYCLES[0b00] / 2,
+        TIMA_INCREMENT_CYCLES[0b01] / 2,
+        TIMA_INCREMENT_CYCLES[0b10] / 2,
+        TIMA_INCREMENT_CYCLES[0b11] / 2
+      ].freeze
+
+      # In binary a given Bit N always flips its value after 2^N ticks.
+      # Based on the number of cycles derived above you can find the correct bit to watch.
+      #
+      # Example for clock select 0b00:
+      # - 1024 T-cycles to increment TIMA.
+      # - So we need to find a Bit N that flips (1024 / 2) times to achieve a falling edge.
+      # - 2^N = 512 => N = log2(512) => N = 9 (Watch Bit 9 from the system counter).
+      COUNTER_BITS_TO_WATCH = [
+        Math.log2(COUNTER_FALLING_EDGE_CYCLES[0b00]).round,
+        Math.log2(COUNTER_FALLING_EDGE_CYCLES[0b01]).round,
+        Math.log2(COUNTER_FALLING_EDGE_CYCLES[0b10]).round,
+        Math.log2(COUNTER_FALLING_EDGE_CYCLES[0b11]).round
+      ].freeze
+
+      # Returns the 8-bit value stored in the TIMA (Timer Counter) register.
+      attr_reader :tima
+
+      # Returns the 8-bit value stored in the TMA (Timer Modulo) register.
+      attr_reader :tma
+
+      # Returns the 8-bit value stored in the TAC (Timer Control) register.
+      attr_reader :tac
+
+      # Creates an instance of the timer.
+      #
+      # - Needs the interrupts instance to request a timer interrupt.
+      # - Has an internal-only 16-bit counter that increments each T-cycle.
+      def initialize(interrupts, skip_boot_rom: true, trace_timer: false)
+        @interrupts = interrupts
+        @trace_timer = trace_timer
+
+        @counter = skip_boot_rom ? 0xABCC : 0x0000
+        @tima    = 0x00
+        @tma     = 0x00
+        @tac     = skip_boot_rom ? 0xF8 : 0x00
+
+        @tac_enable_bit = @tac[2]
+        @tac_clock_select_bits = @tac & 0b11
+        @counter_watched_bit_pos = COUNTER_BITS_TO_WATCH[@tac_clock_select_bits]
+
+        @state = :running
+        @tima_overflow = false
+      end
+
+      # Reading DIV only exposes the upper byte of the system counter.
+      #
+      # @return [Integer]
+      def div
+        (@counter >> 8) & 0xFF
+      end
+
+      # Writing to DIV register always resets the system counter.
+      #
+      # When the value is reset to 0x0000, if the current bit being "watched"
+      # goes from 1 -> 0 it can trigger a TIMA increment due to a falling edge
+      # in the joint signal.
+      #
+      # @param value [Integer] Value is ignored and resets the whole @counter.
+      def div=(_value)
+        old_signal = @tac_enable_bit & @counter[@counter_watched_bit_pos]
+        @counter = 0x0000
+        new_signal = @tac_enable_bit & @counter[@counter_watched_bit_pos]
+
+        increment_tima if falling_edge?(old_signal, new_signal)
+      end
+
+      # Sets a 8-bit value into the TIMA register.
+      #
+      # Obscure behaviors:
+      # - If the CPU tries to write to TIMA the same cycle it was already reloaded
+      #   with TMA, the write is completely ignored and TIMA keeps the TMA value.
+      # - If the CPU tries to write to TIMA the cycle immediately after it overflows,
+      #   but hasn't been reloaded with TMA yet, the write succeeds, TIMA keeps the
+      #   value written by the CPU and the reload is cancelled as if the overflow never happened.
+      #
+      # @param value [Integer] 8-bit value to store in the TIMA register.
+      def tima=(value)
+        return if @state == :tima_reloaded
+
+        @state = :tima_reloaded if @state == :tima_reload_pending
+        @tima = value & 0xFF
+      end
+
+      # Sets a 8-bit value into the TMA register.
+      #
+      # Obscure behavior:
+      # - If the CPU writes to TMA the cycle after TIMA was already reloaded,
+      #   TIMA is reloaded a second time with the new value because the TMA latch
+      #   remains open for 2 M-cycles (the original reload + the next).
+      #
+      # @param value [Integer] 8-bit value to store in the TMA register.
+      def tma=(value)
+        @tma = value & 0xFF
+        @tima = @tma if @state == :tima_reloaded
+      end
+
+      # Sets a 8-bit value into the TAC register.
+      #
+      # There are 2 distinct cases in which writing to TAC can cause
+      # a sporadic TIMA increment:
+      # - TAC Enable (Bit 2) going from 1 -> 0 can cause a falling edge in the joint signal.
+      # - Changing the TAC Clock Select (Bits 1-0) can also cause a falling edge
+      #   if the previous bit selected from the counter was 1, and the new one is 0.
+      #
+      # @param value [Integer] 8-bit value to store in the TAC register.
+      def tac=(value)
+        old_signal = @tac_enable_bit & @counter[@counter_watched_bit_pos]
+
+        @tac = value & 0xFF
+        @tac_enable_bit = @tac[2]
+        @tac_clock_select_bits = @tac & 0b11
+        @counter_watched_bit_pos = COUNTER_BITS_TO_WATCH[@tac_clock_select_bits]
+
+        new_signal = @tac_enable_bit & @counter[@counter_watched_bit_pos]
+
+        increment_tima if falling_edge?(old_signal, new_signal)
+      end
+
+      # Advances the system counter, increments TIMA if needed and handles TIMA overflow logic.
+      #
+      # - Counter value should wrap around 0xFFFF (16-bit).
+      # - The Counter is always counting independent from all the other logic.
+      # - The tick is being implemented in M-cycle precision, so each tick is 4 T-cycles.
+      # - After TIMA overflows, there is a 1 M-cycle delay before
+      #   setting TMA into TIMA and requesting the Timer interrupt.
+      def tick
+        old_signal = @tac_enable_bit & @counter[@counter_watched_bit_pos]
+        @counter = (@counter + T_CYCLES) & 0xFFFF
+        new_signal = @tac_enable_bit & @counter[@counter_watched_bit_pos]
+
+        case @state
+        when :running
+          increment_tima if falling_edge?(old_signal, new_signal)
+        when :tima_reload_pending
+          @tima = @tma
+          @interrupts.request(:timer)
+          @state = :tima_reloaded
+        when :tima_reloaded
+          @state = :running
+        end
+
+        log_state(old_signal, new_signal) if @trace_timer
+      end
+
+      private
+
+      # Increments TIMA once, the register is 8-bit so it wraps around 0xFF.
+      # Sets a new Timer state when the overflow occurs to be handled in the M-cycle after.
+      def increment_tima
+        @tima = (@tima + 1) & 0xFF
+        @state = :tima_reload_pending if @tima.zero?
+      end
+
+      # Checks for a falling edge (1 -> 0) in the joint signal.
+      # Joint signal is a bitwise AND between:
+      # - TAC enable bit (Bit 2)
+      # - Currently selected bit in the system counter
+      #
+      # @param old_signal [Integer] Either 0 or 1.
+      # @param new_signal [Integer] Either 0 or 1.
+      # @return [Boolean]
+      def falling_edge?(old_signal, new_signal)
+        old_signal == 1 && new_signal == 0
+      end
+
+      # Logs the state of the Timer for each M-cycle if the Timer trace is set.
+      #
+      # @param old_signal [Integer] Either 1 or 0.
+      # @param new_signal [Integer] Either 1 or 0.
+      def log_state(old_signal, new_signal)
+        $stdout.printf(
+          'COUNTER: $%<n>04X (%<n>06d) || :%<state>-20s || ' \
+          'TIMA: $%<tima>02X || TMA: $%<tma>02X || TAC: %<tac>08b || ' \
+          'OLD SIGNAL: %<os>d => NEW SIGNAL: %<ns>d || ' \
+          "INTERRUPT: %<int>d\n",
+          n: @counter,
+          state: @state.upcase,
+          tima: @tima,
+          tma: @tma,
+          tac: @tac,
+          os: old_signal,
+          ns: new_signal,
+          int: @interrupts.if_register[2]
+        )
+      end
+    end
+  end
+end

data/lib/amaterasu/game_boy/vram/tile.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Amaterasu
+  module GameBoy
+    class Vram
+      # Models each Tile that lives in the VRAM.
+      class Tile
+        PIXEL_HEIGHT  = 8
+        PIXEL_WIDTH   = 8
+        SIZE_IN_BYTES = 16
+        SIZE_BIT_MASK = 0b111
+
+        # Pre-computes all possible 8 pixel values given the low and high bytes
+        # for the Game Boy address range (0x0000 - 0xFFFF).
+        #
+        # Usage:
+        #   Memory values: $3C (Low), $7E (High)
+        #   PIXELS_LOOKUP[(0x7E << 8) | 0x3C] #=> [0, 2, 3, 3, 3, 3, 2, 0]
+        PIXELS_LOOKUP = Array.new(65_536) do |idx|
+          low_byte  = idx & 0xFF
+          high_byte = (idx >> 8) & 0xFF
+
+          Array.new(8) do |i|
+            bit = 7 - i
+            low_bit = (low_byte >> bit) & 1
+            high_bit = (high_byte >> bit) & 1
+
+            (high_bit << 1) | low_bit
+          end.freeze
+        end.freeze
+
+        attr_reader :data
+
+        def initialize(vram_data:, tile_index:)
+          @vram_data = vram_data
+          @tile_index = tile_index
+          @base_offset = tile_index * SIZE_IN_BYTES
+        end
+
+        # @return [Integer] The low byte of the tile at a given row.
+        def data_low(current_y)
+          current_tile_y = current_y & SIZE_BIT_MASK
+          row_within_tile = current_tile_y * 2
+
+          @vram_data[@base_offset + row_within_tile]
+        end
+
+        # @return [Integer] The high byte of the tile at a given row.
+        def data_high(current_y)
+          current_tile_y = current_y & SIZE_BIT_MASK
+          row_within_tile = current_tile_y * 2
+
+          @vram_data[@base_offset + row_within_tile + 1]
+        end
+
+        def pixel_row(low_byte, high_byte)
+          PIXELS_LOOKUP[(high_byte << 8) | low_byte]
+        end
+
+        def inspect
+          '#<Tile ' \
+            "@tile_index=#{@tile_index} " \
+            "@base_offset=#{@base_offset}>"
+        end
+      end
+    end
+  end
+end

data/lib/amaterasu/game_boy/vram/tile_data.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Amaterasu
+  module GameBoy
+    class Vram
+      # Models the Tile Data that lives in the VRAM.
+      class TileData
+        TILE_SIZE = 16
+        TILE_ENTRIES = 384
+
+        attr_reader :tiles, :addressing_mode, :base_offset
+
+        # @param vram_data [Array] Original VRAM @data array object.
+        def initialize(vram_data:)
+          @addressing_mode = :unsigned
+          @base_offset     = 0x0000
+
+          @tiles = Array.new(TILE_ENTRIES) do |index|
+            Tile.new(vram_data: vram_data, tile_index: index)
+          end
+        end
+
+        # @param mode [Symbol] Either :unsigned or :signed.
+        def addressing_mode=(mode)
+          @addressing_mode = mode
+          @base_offset     = mode == :unsigned ? 0x0000 : 0x1000
+        end
+
+        # Fetches a Tile based on a given index, if the addressing mode
+        # is set to :signed, we need to sign the value before fetching
+        # the tile.
+        #
+        # @param tile_index [Integer] 8-bit value representing the tile index.
+        # @return [Vram::Tile]
+        def tile_at(tile_index)
+          tile_index = sign_value(tile_index) if @addressing_mode == :signed
+          tile_offset = @base_offset / Tile::SIZE_IN_BYTES
+
+          @tiles[tile_offset + tile_index]
+        end
+
+        private
+
+        # @param index [Integer] The current Tile index (8-bit value).
+        # @return [Integer] A value between -128 and +127.
+        def sign_value(index)
+          index >= 128 ? index - 256 : index
+        end
+      end
+    end
+  end
+end

data/lib/amaterasu/game_boy/vram/tile_map.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Amaterasu
+  module GameBoy
+    class Vram
+      # Models the Tile Map that live in VRAM.
+      #
+      # - Each Tile Map is a 32 x 32 grid of Tile indices.
+      # - Each Tile index is exactly 1 byte.
+      # - So each Tile Map has exactly 32 * 32 * 1 = 1024 bytes (1 KiB).
+      #
+      # Grid representation in 2 dimensions, each (X, Y) pair -> 1 byte:
+      #
+      #               X = 0       X = 1      X = 2          X = 31
+      #
+      #     Y = 0     (0, 0)     (1, 0)     (2, 0)    ...  (31, 0)   <- Row 0
+      #
+      #     Y = 1     (0, 1)     (1, 1)     (2, 1)    ...  (31, 1)   <- Row 1
+      #
+      #     Y = 2     (0, 2)     (1, 2)     (2, 2)    ...  (31, 2)   <- Row 2
+      #
+      #      ...       ...         ...        ...            ...         ...
+      #
+      #     Y = 31    (0, 31)    (1, 31)    (2, 31)   ...  (31, 31)  <- Row 31
+      #
+      #                  ↑         ↑        ↑              ↑
+      #
+      #               Column 0   Column 1   Column 2  ...  Column 31
+      #
+      class TileMap
+        # Total number of columns in the grid.
+        GRID_WIDTH  = 32
+
+        # Total number of rows in the grid.
+        GRID_HEIGHT = 32
+
+        # Mask to keep values between 0 and 31.
+        BIT_MASK_WRAP_VALUE = 0x1F
+
+        # @param vram_data [Array] Reference to the original VRAM data.
+        # @param base_offset [Integer] Tile map start address within the VRAM data.
+        def initialize(vram_data:, base_offset:)
+          @vram_data   = vram_data
+          @base_offset = base_offset
+        end
+
+        # Fetches a Tile index from the Tile Map at a given (X, Y) position.
+        #
+        # Before looking up in which column or row the Tile index is,
+        # we need to wrap the values around 32 (0x1F).
+        #
+        # Since the Memory is a flat array (single dimension) we need to
+        # offset the given Y value by the Grid WIDTH to "jump over" the rows in
+        # between and reach the correct row.
+        #
+        # @param tile_x [Integer] Which column in the grid.
+        # @param tile_y [Integer] Which row in the grid.
+        # @return [Integer] 1 byte representing the Tile index at the given (X, Y).
+        def tile_index_at(tile_x:, tile_y:)
+          grid_row    = tile_y & BIT_MASK_WRAP_VALUE
+          grid_column = tile_x & BIT_MASK_WRAP_VALUE
+
+          tile_index_row    = grid_row * GRID_WIDTH
+          tile_index_column = grid_column
+
+          @vram_data[@base_offset + tile_index_row + tile_index_column]
+        end
+      end
+    end
+  end
+end

data/lib/amaterasu/game_boy/vram.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Amaterasu
+  module GameBoy
+    # Models the VRAM (Video RAM) from the DMG Game Boy.
+    #
+    # The VRAM address range can be divided into 2 main parts.
+    # 1. Tile Data:
+    #   - Lives in 0x8000 -> 0x97FF (6144 bytes)
+    #   - Each tile is composed of 8 x 8 = 64 pixels
+    #   - Each pixel is encoded as 2 bits in the DMG Game Boy
+    #   - So each tile has 64 * 2 = 128 bits (16 bytes)
+    # 2. Tile Maps:
+    #   - Has a total of 2 Tile Maps (0x9800 -> 0x9BFF) / (0x9C00 -> 0x9FFF)
+    #   - Each Tile Map is a 32 x 32 grid of Tile indices (each index is 1 byte)
+    #   - So each Tile Map has exactly 1024 bytes (1 KiB)
+    class Vram < Ram
+      # VRAM Start Address in the Memory Map
+      START_ADDRESS = 0x8000
+
+      # VRAM End Address in the Memory Map
+      END_ADDRESS   = 0x9FFF
+
+      # VRAM Size in bytes: 8192 bytes (8 KiB)
+      SIZE_IN_BYTES = (END_ADDRESS - START_ADDRESS) + 1
+
+      # Exposes the tile data and maps to the PPU
+      attr_reader :tile_data,
+                  :tile_map_low,
+                  :tile_map_high
+
+      # Creates "lens objects" passing the original VRAM @data Array,
+      # when a value is written into VRAM it will be correctly read
+      # by all the Tile Data and Tile Maps.
+      def initialize
+        super(size: SIZE_IN_BYTES, offset: START_ADDRESS)
+
+        @tile_data     = TileData.new(vram_data: @data)
+        @tile_map_low  = TileMap.new(vram_data: @data, base_offset: 0x1800)
+        @tile_map_high = TileMap.new(vram_data: @data, base_offset: 0x1C00)
+      end
+
+      def inspect
+        '#<Vram ' \
+          "@tile_data=#{@tile_data} " \
+          "@tile_map_low=#{@tile_map_low} " \
+          "@tile_map_high=#{@tile_map_high}>"
+      end
+    end
+  end
+end

data/lib/amaterasu/hal/console.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Amaterasu
+  module HAL
+    # Console display renderer.
+    class Console
+      LCD_WIDTH  = 160
+      LCD_HEIGHT = 144
+
+      DOUBLE_CHAR = '▀'
+      CONSOLE_CHARS = [' ', '░', '▒', '█'].freeze
+      # CONSOLE_CHARS = [' ', ':', '#', '@'].freeze
+
+      def initialize
+        $stdout.print("\e[?1049h")
+      end
+
+      def shutdown
+        $stdout.print("\e[?1049l")
+      end
+    end
+  end
+end

data/lib/amaterasu/hal/sdl2/bindings.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module Amaterasu
+  module HAL
+    class SDL2
+      # Implement all SDL2 bindings needed.
+      module Bindings
+        extend FFI::Library
+
+        ffi_lib 'SDL2'
+
+        INIT_VIDEO              = 0x00000020
+        WINDOWPOS_CENTERED      = 0x2FFF0000
+        WINDOW_SHOWN            = 0x00000004
+        PIXELFORMAT_ARGB8888    = 0x16362004
+        TEXTUREACCESS_STREAMING = 1
+        RENDERER_ACCELERATED    = 0x00000002
+        QUIT                    = 0x100
+        EVENT_SIZE              = 56
+
+        SCANCODE_UP    = 82
+        SCANCODE_DOWN  = 81
+        SCANCODE_LEFT  = 80
+        SCANCODE_RIGHT = 79
+
+        SCANCODE_Z = 29
+        SCANCODE_X = 27
+        SCANCODE_RETURN = 40
+        SCANCODE_RSHIFT = 229
+
+        attach_function :init, :SDL_Init, [:uint32], :int
+        attach_function :quit, :SDL_Quit, [], :void
+        attach_function :get_error, :SDL_GetError, [], :string
+
+        attach_function :create_window, :SDL_CreateWindow, %i[string int int int int uint32], :pointer
+        attach_function :set_window_title, :SDL_SetWindowTitle, %i[pointer string], :void
+        attach_function :destroy_window, :SDL_DestroyWindow, [:pointer], :void
+
+        attach_function :create_renderer, :SDL_CreateRenderer, %i[pointer int uint32], :pointer
+        attach_function :destroy_renderer, :SDL_DestroyRenderer, [:pointer], :void
+
+        attach_function :create_texture, :SDL_CreateTexture, %i[pointer uint32 int int int], :pointer
+        attach_function :update_texture, :SDL_UpdateTexture, %i[pointer pointer pointer int], :int
+        attach_function :destroy_texture, :SDL_DestroyTexture, [:pointer], :void
+
+        attach_function :render_copy, :SDL_RenderCopy, %i[pointer pointer pointer pointer], :int
+        attach_function :render_present, :SDL_RenderPresent, [:pointer], :void
+        attach_function :render_clear, :SDL_RenderClear, [:pointer], :int
+
+        attach_function :poll_event, :SDL_PollEvent, [:pointer], :int
+
+        attach_function :get_keyboard_state, :SDL_GetKeyboardState, [:pointer], :pointer
+        attach_function :pump_events, :SDL_PumpEvents, [], :void
+      end
+    end
+  end
+end

data/lib/amaterasu/hal/sdl2.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module Amaterasu
+  module HAL
+    class SDL2
+      LCD = Bindings
+      LCD_WIDTH  = 160
+      LCD_HEIGHT = 144
+      SCALE = 3
+
+      PALETTE = [0xFFFFFFFF, 0xFFAAAAAA, 0xFF555555, 0xFF000000].freeze
+
+      attr_accessor :joypad
+
+      def initialize
+        LCD.init(LCD::INIT_VIDEO)
+        @window = LCD.create_window(
+          'Amaterasu',
+          LCD::WINDOWPOS_CENTERED,
+          LCD::WINDOWPOS_CENTERED,
+          LCD_WIDTH * SCALE,
+          LCD_HEIGHT * SCALE,
+          LCD::WINDOW_SHOWN
+        )
+        @renderer = LCD.create_renderer(@window, -1, LCD::RENDERER_ACCELERATED)
+        @texture = LCD.create_texture(
+          @renderer,
+          LCD::PIXELFORMAT_ARGB8888,
+          LCD::TEXTUREACCESS_STREAMING,
+          LCD_WIDTH,
+          LCD_HEIGHT
+        )
+
+        @pixel_buffer = FFI::MemoryPointer.new(:uint32, LCD_WIDTH * LCD_HEIGHT)
+        @event = FFI::MemoryPointer.new(:uint8, LCD::EVENT_SIZE)
+        @frame_count = 0
+        @fps_timer = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      def draw(framebuffer)
+        @pixel_buffer.write_array_of_uint32(framebuffer.map { |shade| PALETTE[shade] })
+        LCD.update_texture(@texture, FFI::Pointer::NULL, @pixel_buffer, LCD_WIDTH * 4)
+        LCD.render_copy(@renderer, @texture, FFI::Pointer::NULL, FFI::Pointer::NULL)
+        LCD.render_present(@renderer)
+
+        @frame_count += 1
+        @elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - @fps_timer
+
+        if @elapsed >= 1.0
+          fps = @frame_count / @elapsed
+          # LCD.set_window_title(@window, "Amaterasu | FPS: #{fps.round(2)}")
+          $stdout.print "\rFPS: #{fps.round(2)}  "
+          $stdout.flush
+        end
+
+        while LCD.poll_event(@event) == 1
+          # first 4 bytes of the event struct are the event type (uint32)
+          type = @event.read_uint32
+          case type
+          when LCD::QUIT
+            shutdown
+            exit
+          end
+        end
+
+        keyboard_state = LCD.get_keyboard_state(nil)
+
+        if keyboard_state.get_uint8(LCD::SCANCODE_UP) == 0
+          joypad.release_dpad(:up)
+        else
+          joypad.press_dpad(:up)
+        end
+
+        if keyboard_state.get_uint8(LCD::SCANCODE_DOWN) == 0
+          joypad.release_dpad(:down)
+        else
+          joypad.press_dpad(:down)
+        end
+
+        if keyboard_state.get_uint8(LCD::SCANCODE_RIGHT) == 0
+          joypad.release_dpad(:right)
+        else
+          joypad.press_dpad(:right)
+        end
+
+        if keyboard_state.get_uint8(LCD::SCANCODE_LEFT) == 0
+          joypad.release_dpad(:left)
+        else
+          joypad.press_dpad(:left)
+        end
+
+        if keyboard_state.get_uint8(LCD::SCANCODE_Z) == 0
+          joypad.release_face(:a)
+        else
+          joypad.press_face(:a)
+        end
+
+        if keyboard_state.get_uint8(LCD::SCANCODE_X) == 0
+          joypad.release_face(:b)
+        else
+          joypad.press_face(:b)
+        end
+
+        if keyboard_state.get_uint8(LCD::SCANCODE_RETURN) == 0
+          joypad.release_face(:start)
+        else
+          joypad.press_face(:start)
+        end
+
+        if keyboard_state.get_uint8(LCD::SCANCODE_RSHIFT) == 0
+          joypad.release_face(:select)
+        else
+          joypad.press_face(:select)
+        end
+      end
+
+      def shutdown
+        LCD.destroy_texture(@texture)
+        LCD.destroy_renderer(@renderer)
+        LCD.destroy_window(@window)
+        LCD.quit
+      end
+    end
+  end
+end