badline 0.14.0 → 0.15.0

data/lib/badline/chips/ted/fetches.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class TED
+      # What the TED reads for the picture, a single clock cycle at a time,
+      # and the counters that say where it reads.
+      #
+      # The two DMA lines of a character row (Beam) fetch a byte a cycle
+      # in phi2, in the 40 cycles of the character window, columns 54-56
+      # and 0-36: the attributes on the line before the row, from the video
+      # matrix base ($FF14 bits 3-7) with A10 clear, and the character
+      # pointers on the row's first line, with A10 set (the datasheet's
+      # video matrix and attribute addresses). The attributes go to a
+      # buffer of their own, and each takes hold as its character's
+      # pointer is fetched, so the row before shows its own colours to its
+      # last line, as xplus4 shows them.
+      #
+      # On every line of a row, from the cycle after each pointer's, the
+      # TED fetches the character's pattern byte in phi1, columns 55-56
+      # and 0-37: from the character base ($FF13 bits 2-7) with the
+      # pointer and the row's line counter, or from the bitmap base ($FF12
+      # bits 3-5) with the character position and the line counter in
+      # bitmap mode. With $FF07 bit 7 clear the pointer's bit 7 asks for
+      # reverse and the character base supplies A10; extended colour mode
+      # forces A9 and A10 low. The byte stays on the bus, where a read of
+      # an address nothing answers finds it (Plus/4 openio's outrun2).
+      #
+      # The matrix fetches see ROM or RAM as the CPU does at $8000-$FFFF,
+      # and the pattern fetches ROM with $FF12 bit 2 set or RAM with it
+      # clear (Plus4::Bus#ted_fetch and #ted_pattern_fetch).
+      #
+      # The counters: the character position reload ($FF1A-$FF1B), the
+      # character position the row starts at, which steps by 40 at the end
+      # of a row's eighth line, at horizontal count 290; and the vertical
+      # sub-address ($FF1F bits 0-2), the row's line, which steps with the
+      # line count on the display window's lines once the frame's first
+      # row is under way, wrapping from 7 to 0 whatever the DMA lines do.
+      # The attribute line reads the row the reload points to after its
+      # own latch: 40 on from it on a row's eighth line, the reload itself
+      # otherwise. The pointer line is the line after an attribute line. A
+      # frame starts with both counters at 0 and no row under way, and the
+      # frame's first pointer line puts a row under way to the end of the
+      # frame. The display window's lines with a row under way and the
+      # display on fetch pattern bytes.
+      module Fetches
+        # The first and last cycles of the pattern fetches.
+        PATTERN_COLUMN = 55
+        PATTERN_END_COLUMN = 37
+
+        # The cycle that latches the next row's character position.
+        LATCH_COLUMN = 36
+
+        # The cycle that counts the blink counter, horizontal count 336.
+        BLINK_COLUMN = 42
+
+        CHARACTERS = 40
+
+        # The pattern bytes, pointers and attributes of the characters on
+        # the line being fetched.
+        attr_reader :patterns, :pointers, :attributes
+
+        # The character position reload, the row's line, and whether a row
+        # is under way.
+        attr_reader :char_position, :row_line, :row_active
+
+        # The bus the TED fetches from, the machine's.
+        def connect(bus)
+          @bus = bus
+        end
+
+        private
+
+        def reset_fetches
+          @patterns = Array.new(CHARACTERS, 0)
+          @pointers = Array.new(CHARACTERS, 0)
+          @attributes = Array.new(CHARACTERS, 0)
+          @fetched_attributes = Array.new(CHARACTERS, 0)
+          @char_position = 0
+          @line_position = 0
+          @row_line = 0
+          @row_active = false
+          @dma_kind = Beam::NO_DMA
+          @pattern_fetches = false
+        end
+
+        # The fetches and counters of the cycle in +column+.
+        def fetch(column)
+          if column <= Beam::DMA_END_COLUMN || column >= Beam::DMA_COLUMN
+            window_fetch(column)
+          elsif column == PATTERN_END_COLUMN
+            pattern_fetch(column) if @pattern_fetches
+          elsif column == Beam::BA_COLUMN
+            start_line_fetches
+          elsif column == BLINK_COLUMN
+            count_blink
+          end
+        end
+
+        # A cycle of the character window.
+        def window_fetch(column)
+          dma_fetch(column) unless @dma_kind == Beam::NO_DMA
+          pattern_fetch(column) if @pattern_fetches && column != Beam::DMA_COLUMN
+          latch_char_position if column == LATCH_COLUMN
+        end
+
+        # The blink counter counts a frame on one line of the vertical
+        # blank, the line xplus4 counts it on.
+        def count_blink
+          return unless @line == (lines_per_frame == 312 ? 256 : 228)
+
+          @blink = (@blink + 1) & 0x0f
+          blink_carry if @blink.zero?
+        end
+
+        # Column 51: what the line fetches, decided where BA is.
+        def start_line_fetches
+          @dma_kind = dma_kind
+          @row_active = true if @dma_kind == Beam::POINTER_DMA
+          @line_position = @char_position
+          @pattern_fetches = @row_active && @line <= Beam::LAST_DISPLAY_LINE && display_enabled? && !@bus.nil?
+        end
+
+        # The attributes on a line whose low three bits match $FF06's
+        # scroll, below line 203, and the pointers on the line after one
+        # that fetched attributes (the datasheet's DMA timing, step 8),
+        # whatever the scroll says by then.
+        def dma_kind
+          return Beam::NO_DMA unless display_enabled?
+          return Beam::POINTER_DMA if @dma_kind == Beam::ATTRIBUTE_DMA
+          return Beam::NO_DMA unless @line < Beam::LAST_DISPLAY_LINE
+
+          (@line - @registers[0x06]).nobits?(0x07) ? Beam::ATTRIBUTE_DMA : Beam::NO_DMA
+        end
+
+        def display_enabled? = @registers[0x06].anybits?(0x10)
+
+        def dma_fetch(column)
+          bus = @bus
+          return if bus.nil?
+
+          index = column >= Beam::DMA_COLUMN ? column - Beam::DMA_COLUMN : column + (Beam::CYCLES_PER_LINE - Beam::DMA_COLUMN)
+          matrix = (@registers[0x14] & 0xf8) << 8
+          if @dma_kind == Beam::ATTRIBUTE_DMA
+            position = latching? ? @char_position + CHARACTERS : @char_position
+            @fetched_attributes[index] = bus.ted_fetch(matrix | ((position + index) & 0x3ff))
+          else
+            @pointers[index] = bus.ted_fetch(matrix | 0x400 | ((@char_position + index) & 0x3ff))
+            @attributes[index] = @fetched_attributes[index]
+          end
+        end
+
+        def pattern_fetch(column)
+          index = column >= PATTERN_COLUMN ? column - PATTERN_COLUMN : column + (Beam::CYCLES_PER_LINE - PATTERN_COLUMN)
+          @patterns[index] = @bus.ted_pattern_fetch(pattern_address(index), @registers[0x12].anybits?(0x04))
+        end
+
+        def pattern_address(index)
+          return bitmap_address(index) if @registers[0x06].anybits?(0x20)
+
+          pointer = @pointers[index]
+          base = @registers[0x13] & 0xf8
+          if @registers[0x06].anybits?(0x40)
+            pointer &= 0x3f
+          elsif !@registers[0x07].anybits?(0x80)
+            pointer = (pointer & 0x7f) | ((@registers[0x13] & 0x04) << 5)
+          end
+          (base << 8) | (pointer << 3) | @row_line
+        end
+
+        def bitmap_address(index)
+          ((@registers[0x12] & 0x38) << 10) | (((@line_position + index) & 0x3ff) << 3) | @row_line
+        end
+
+        # The end of a row's eighth line moves the reload on to the next
+        # row.
+        def latch_char_position
+          @char_position = (@char_position + CHARACTERS) & 0x3ff if latching?
+        end
+
+        # Whether the line ends a row, and latches the next row's position.
+        def latching? = @row_active && @row_line == 7 && @line <= Beam::LAST_DISPLAY_LINE
+
+        # The line count steps to +line+: the row's next line, up to the
+        # last line of the display window.
+        def step_row_line(line)
+          @row_line = (@row_line + 1) & 0x07 if @row_active && line <= Beam::LAST_DISPLAY_LINE
+        end
+
+        # The end of the frame.
+        def end_fetch_frame
+          @char_position = 0
+          @row_line = 0
+          @row_active = false
+        end
+      end
+    end
+  end
+end

data/lib/badline/chips/ted/keyed_state.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class TED
+      class Sound
+        # The sound's fields in a keyed snapshot module (Snapshot::Keyed,
+        # BL-TEDSOUND): each voice's output and when it next toggles, in
+        # cycles from the machine's clock, absent while it never will, the
+        # noise's shift register, and how far behind the clock the voices
+        # last ran. The frequencies, the volume and the reload bit come from
+        # the TED's registers on load (#restored!), and the output's level
+        # from those.
+        module KeyedState
+          def save_fields(out)
+            now = @clock.cycles
+            run_to(now)
+            VOICES.times do |voice|
+              due = @next_toggles[voice]
+              out.int("voice#{voice + 1}.phase", @phases[voice])
+              out.optional_int("voice#{voice + 1}.toggle_in", due >= NEVER ? nil : due - now)
+            end
+            out.int("noise", @noise).int("ran_ago", now - @time)
+          end
+
+          def load_fields(input)
+            now = @clock.cycles
+            VOICES.times do |voice|
+              @phases[voice] = input.masked("voice#{voice + 1}.phase", @phases[voice], 0x01)
+              due = input.optional_int("voice#{voice + 1}.toggle_in")
+              @next_toggles[voice] = due.nil? ? NEVER : now + due
+            end
+            @noise = input.byte("noise", @noise)
+            @time = now - input.int("ran_ago", now - @time)
+          end
+
+          # The frequencies, the volume and the reload bit as `ted`'s
+          # registers $FF0E-$FF12 hold them, and the level they give.
+          def restored!(ted)
+            @frequencies[0] = ted.peek(0xff0e) | ((ted.peek(0xff12) & 0x03) << 8)
+            @frequencies[1] = ted.peek(0xff0f) | ((ted.peek(0xff10) & 0x03) << 8)
+            VOICES.times { |voice| @intervals[voice] = interval_for(@frequencies[voice]) }
+            control = ted.peek(0xff11)
+            @control = control
+            @reloading = control >= 0x80
+            @volume = [control & 0x0f, 8].min
+            @level = level_now
+          end
+        end
+
+        include KeyedState
+      end
+
+      # The DMA a line makes, as a snapshot names it, in Beam's order.
+      DMA_KINDS = %w[none attributes pointers].freeze
+
+      # The shape of the line going out, as the picture paints it. A
+      # snapshot whose line.layout differs repaints the line from its
+      # start.
+      LINE_LAYOUT = 1
+
+      # The TED's fields in a keyed snapshot module (Snapshot::Keyed,
+      # BL-TED): the registers as written, the interrupt flags, the keyboard
+      # latch, the blink counter, the timers, the beam and the clock it gave
+      # the CPU last, the fetches' buffers and counters, and the picture:
+      # where the scanline is, whether the window is open, how far the line
+      # going out is painted (line.*), and the picture itself. The interrupt
+      # mask and the raster compare come from $FF0A and $FF0B on load.
+      module KeyedState
+        def save_fields(out)
+          out.bytes("registers", @registers).int("interrupt_flags", @interrupt_flags).int("key_latch", @key_latch)
+          out.int("blink", @blink).bool("blink_on", @blink_on)
+          save_timer_fields(out)
+          out.int("column", @column).int("line", @line).bool("ba", @ba_low).int("cpu_slots", @cpu_slots)
+          save_fetch_fields(out)
+          out.int("scanline", @scanline).bool("window_open", @window_open)
+          out.int("line.layout", LINE_LAYOUT).int("line.painted", @painted).bytes("display", @display)
+        end
+
+        def load_fields(input)
+          input.bytes_into("registers", @registers)
+          @interrupt_flags = input.byte("interrupt_flags", @interrupt_flags)
+          @key_latch = input.byte("key_latch", @key_latch)
+          @blink = input.masked("blink", @blink, 0x0f)
+          @blink_on = input.bool("blink_on", @blink_on)
+          load_timer_fields(input)
+          @column = input.int("column", @column) % Beam::CYCLES_PER_LINE
+          @line = input.masked("line", @line, 0x1ff)
+          @ba_low = input.bool("ba", @ba_low)
+          @cpu_slots = input.int("cpu_slots", @cpu_slots).clamp(0, 2)
+          load_fetch_fields(input)
+          @scanline = input.int("scanline", @scanline)
+          @window_open = input.bool("window_open", @window_open)
+          load_line_fields(input)
+          input.bytes_into("display", @display)
+        end
+
+        # The interrupt mask and the raster compare from $FF0A and $FF0B,
+        # and every line of the picture changed.
+        def restored!
+          mask = @registers[0x0a]
+          @interrupt_mask = mask & 0x5f
+          @raster_compare = ((mask & 0x01) << 8) | @registers[0x0b]
+          @dirty_lines.fill(true)
+        end
+
+        private
+
+        def save_timer_fields(out)
+          3.times do |index|
+            out.int("timer#{index + 1}.count", @timer_counts[index])
+            out.bool("timer#{index + 1}.running", @timer_running[index])
+          end
+          out.int("timer1.reload", @timer1_reload)
+        end
+
+        def load_timer_fields(input)
+          3.times do |index|
+            @timer_counts[index] = input.word("timer#{index + 1}.count", @timer_counts[index])
+            @timer_running[index] = input.bool("timer#{index + 1}.running", @timer_running[index])
+          end
+          @timer1_reload = input.word("timer1.reload", @timer1_reload)
+        end
+
+        def save_fetch_fields(out)
+          out.bytes("fetch.patterns", @patterns).bytes("fetch.pointers", @pointers)
+          out.bytes("fetch.attributes", @attributes).bytes("fetch.next_attributes", @fetched_attributes)
+          out.int("fetch.char_position", @char_position).int("fetch.line_position", @line_position)
+          out.int("fetch.row_line", @row_line).bool("fetch.row_active", @row_active)
+          out.text("fetch.dma", DMA_KINDS.fetch(@dma_kind)).bool("fetch.patterns_on", @pattern_fetches)
+        end
+
+        def load_fetch_fields(input)
+          input.bytes_into("fetch.patterns", @patterns)
+          input.bytes_into("fetch.pointers", @pointers)
+          input.bytes_into("fetch.attributes", @attributes)
+          input.bytes_into("fetch.next_attributes", @fetched_attributes)
+          @char_position = input.masked("fetch.char_position", @char_position, 0x3ff)
+          @line_position = input.masked("fetch.line_position", @line_position, 0x3ff)
+          @row_line = input.masked("fetch.row_line", @row_line, 0x07)
+          @row_active = input.bool("fetch.row_active", @row_active)
+          @dma_kind = DMA_KINDS.index(input.choice("fetch.dma", DMA_KINDS, DMA_KINDS.fetch(@dma_kind))) || 0
+          @pattern_fetches = input.bool("fetch.patterns_on", @pattern_fetches)
+        end
+
+        def load_line_fields(input)
+          line = input.int("line.layout", 0) == LINE_LAYOUT
+          input.adjust("line in progress from another renderer, restarted") unless line || input.missing?
+          @painted = line ? input.int("line.painted", @painted).clamp(0, Picture::WIDTH) : 0
+        end
+      end
+
+      include KeyedState
+    end
+  end
+end

data/lib/badline/chips/ted/modes.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class TED
+      # The colours a character's pixels take in each mode, by $FF06 bits 5
+      # (bitmap) and 6 (extended colour) and $FF07 bit 4 (multicolour), with
+      # a pattern byte's set bits as 1 (the datasheet's "Character modes"
+      # and "Bit map mode", Härsfalvi's "Talking to TED"). Each was checked
+      # against xplus4 screenshots of the same registers and memory.
+      #
+      # - Text: 1 is the attribute's colour and luminance, bits 0-6, and 0
+      #   the background, $FF15. With $FF07 bit 7 clear a pointer's bit 7
+      #   reverses the character. The cursor ($FF0C-$FF0D, a character
+      #   position) reverses its character, and an attribute's bit 7 makes
+      #   its character flash to the background, each in turns of 16 frames
+      #   of the blink counter.
+      # - Multicolour text: a character whose attribute has bit 3 set takes
+      #   its bits in pairs of double-width pixels, 00 the background, 01
+      #   $FF16, 10 $FF17 and 11 the attribute's bits 0-2 and 4-6. Other
+      #   characters show as in text. No reverse, cursor or flash.
+      # - Extended colour: the pointer's bits 6-7 pick the background,
+      #   $FF15-$FF18. No reverse, cursor or flash.
+      # - Bitmap: 0 takes its colour from the video matrix's low nibble and
+      #   its luminance from the attribute's bits 4-6, 1 from the matrix's
+      #   high nibble and the attribute's bits 0-2.
+      # - Multicolour bitmap: 00 the background, 01 the bitmap's 1, 10 its
+      #   0, 11 $FF16, as xplus4 shows them. The datasheet gives 01 the
+      #   luminance of bits 4-6 as well.
+      # - Extended colour with either of the others: black.
+      module Modes
+        TEXT = 0x00
+        MULTICOLOR_TEXT = 0x10
+        BITMAP = 0x20
+        MULTICOLOR_BITMAP = 0x30
+        EXTENDED_COLOR = 0x40
+
+        private
+
+        def reset_modes
+          @pixel_bits = 0
+          @pixel_colors = Array.new(4, 0)
+          @multicolor_pixels = false
+          @blink_on = false
+        end
+
+        # The mode, $FF06 bits 5 and 6 with $FF07 bit 4.
+        def mode = (@registers[0x06] & 0x60) | (@registers[0x07] & 0x10)
+
+        # Sets the pixel bits and colours of character +index+ in +mode+.
+        def character_colors(index, mode)
+          pattern = @patterns[index]
+          pointer = @pointers[index]
+          attribute = @attributes[index]
+          case mode
+          when TEXT then text_colors(index, pattern, pointer, attribute)
+          when MULTICOLOR_TEXT then multicolor_text_colors(pattern, attribute)
+          when BITMAP then bitmap_colors(pattern, pointer, attribute)
+          when MULTICOLOR_BITMAP then multicolor_bitmap_colors(pattern, pointer, attribute)
+          when EXTENDED_COLOR then hires(pattern, @registers[0x15 + (pointer >> 6)] & 0x7f, attribute & 0x7f)
+          else hires(0, 0, 0)
+          end
+        end
+
+        # Paints pixels +from+ to +to+ of the line at +base+, of a character
+        # whose first pixel is +origin+, in the colours last set.
+        def paint_pixels(base, from, to, origin)
+          display = @display
+          bits = @pixel_bits
+          colors = @pixel_colors
+          multicolor = @multicolor_pixels
+          x = from
+          while x < to
+            offset = x - origin
+            color = multicolor ? colors[(bits >> (6 - (offset & 0x06))) & 0x03] : colors[(bits >> (7 - offset)) & 0x01]
+            display[base + x] = color
+            x += 1
+          end
+        end
+
+        def hires(pattern, background, foreground)
+          @pixel_bits = pattern
+          @pixel_colors[0] = background
+          @pixel_colors[1] = foreground
+          @multicolor_pixels = false
+        end
+
+        def multicolor(pattern, color1, color2, color3)
+          @pixel_bits = pattern
+          colors = @pixel_colors
+          colors[0] = @registers[0x15] & 0x7f
+          colors[1] = color1
+          colors[2] = color2
+          colors[3] = color3
+          @multicolor_pixels = true
+        end
+
+        def text_colors(index, pattern, pointer, attribute)
+          pattern ^= 0xff if pointer >= 0x80 && !@registers[0x07].anybits?(0x80)
+          if @blink_on
+            pattern ^= 0xff if ((@line_position + index) & 0x3ff) == cursor_position
+          elsif attribute >= 0x80
+            pattern = 0
+          end
+          hires(pattern, @registers[0x15] & 0x7f, attribute & 0x7f)
+        end
+
+        def cursor_position = ((@registers[0x0c] & 0x03) << 8) | @registers[0x0d]
+
+        def multicolor_text_colors(pattern, attribute)
+          if attribute.anybits?(0x08)
+            multicolor(pattern, @registers[0x16] & 0x7f, @registers[0x17] & 0x7f, attribute & 0x77)
+          else
+            hires(pattern, @registers[0x15] & 0x7f, attribute & 0x7f)
+          end
+        end
+
+        def bitmap_colors(pattern, pointer, attribute)
+          hires(pattern, (pointer & 0x0f) | (attribute & 0x70), (pointer >> 4) | ((attribute & 0x07) << 4))
+        end
+
+        def multicolor_bitmap_colors(pattern, pointer, attribute)
+          multicolor(pattern, (pointer >> 4) | ((attribute & 0x07) << 4), (pointer & 0x0f) | (attribute & 0x70),
+                     @registers[0x16] & 0x7f)
+        end
+
+        # The blink counter's carry turns the cursor and flash over.
+        def blink_carry
+          @blink_on = !@blink_on
+        end
+      end
+    end
+  end
+end

data/lib/badline/chips/ted/palette.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class TED
+      # The TED's 128 colours.
+      module Palette
+        # The colours by index, (luminance << 4) | colour, as RGB, from the
+        # Plus/4 hardware manual's TED chapter. Luma comes from each
+        # luminance level's voltage (4.4.3): level 0, 2.0 V, is black, the
+        # eight luminances are levels 1-8, and 4.8 V is white. Chroma takes
+        # the PAL column's hue phase (4.4.4), with U along 0 degrees and V
+        # along 90, at an amplitude of half CHROMA OUT's 1 Vp-p over the
+        # 2.8 V from black to white (4.4.2). Colour 0 is black at every
+        # luminance and colour 1 has no chroma. BT.601 turns them into RGB,
+        # B-Y = U / 0.492 and R-Y = V / 0.877, clamped. NTSC machines take
+        # the same palette. The datasheet's NTSC column is the PAL one less
+        # 33 degrees, but for orange, which it gives 129 on PAL and 90 on
+        # NTSC.
+        PALETTE = [
+          0x000000, 0x242424, 0x570f10, 0x003a39, 0x4e045c, 0x004400, 0x19197f, 0x303000,
+          0x4d1b00, 0x402600, 0x173d00, 0x580830, 0x00401c, 0x05266e, 0x390a7a, 0x084200,
+          0x000000, 0x323232, 0x651c1d, 0x004847, 0x5c126a, 0x055205, 0x26278c, 0x3e3e00,
+          0x5a2900, 0x4e3300, 0x254a00, 0x66163d, 0x004e2a, 0x13347c, 0x461787, 0x165000,
+          0x000000, 0x404040, 0x722a2b, 0x0d5555, 0x692077, 0x126013, 0x34349a, 0x4b4b00,
+          0x683706, 0x5b4100, 0x325800, 0x73234b, 0x0c5c38, 0x21418a, 0x542595, 0x235d00,
+          0x000000, 0x525252, 0x853c3d, 0x1f6867, 0x7b328a, 0x257225, 0x4646ac, 0x5e5e00,
+          0x7a4918, 0x6d5303, 0x456a00, 0x85365d, 0x1e6e4a, 0x33549c, 0x6637a7, 0x366f04,
+          0x000000, 0x767676, 0xa96162, 0x448c8b, 0xa056ae, 0x49964a, 0x6b6bd1, 0x82821c,
+          0x9f6d3c, 0x927828, 0x698f1d, 0xaa5a82, 0x43926e, 0x5778c0, 0x8b5ccc, 0x5a9429,
+          0x000000, 0x929292, 0xc47c7d, 0x5fa7a7, 0xbb72c9, 0x64b265, 0x8686ec, 0x9d9d38,
+          0xba8857, 0xad9343, 0x84aa38, 0xc5759d, 0x5eae8a, 0x7293dc, 0xa677e7, 0x75af44,
+          0x000000, 0xbfbfbf, 0xf2aaaa, 0x8dd5d4, 0xe99ff7, 0x92df92, 0xb4b4ff, 0xcbcb65,
+          0xe8b685, 0xdbc071, 0xb2d766, 0xf3a3cb, 0x8cdbb7, 0xa0c1ff, 0xd4a4ff, 0xa3dd72,
+          0x000000, 0xffffff, 0xffe9ea, 0xccffff, 0xffdfff, 0xd2ffd2, 0xf3f3ff, 0xffffa5,
+          0xfff6c5, 0xffffb1, 0xf2ffa6, 0xffe3ff, 0xcbfff7, 0xe0ffff, 0xffe4ff, 0xe3ffb1
+        ].freeze
+
+        def palette = PALETTE
+      end
+    end
+  end
+end