good_luck_wizard 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0cb37ba935956a080d7e4f02a6f771d50c78396d9929d5424d1f9427f354bc1
-  data.tar.gz: 185370ffabbe5b7688304cb97cf8fa1a385e49e9461cff77e8f185763bec3434
+  metadata.gz: 4542c554b53395dec06ab3026510aa4ad8b24511077f0820e607daa8a48eeb57
+  data.tar.gz: 6991409bd222f25a008b86716cda64f1cb06928637882ade5676e5114a126c5c
 SHA512:
-  metadata.gz: f03c3bdc66579466bad239ff5f04faaa4cfef2ea547364e083955ee8a43e371d4b33aa3652882088a6906193269f20b8136d496fb8454f11ab94231f2df60551
-  data.tar.gz: 1716b9749d7ec53582ab84234cdc9927ac49ec8f8a12b1d741fed7a3f436a89a392b74d5c3bd22b5d0bdd5233d74dafb817532ac4849b33a57c9172102651832
+  metadata.gz: acd95d8a41e16661a57ec519052d91ff93747478ba29d8b4882e1e1c7207297427df4af973f55bed324af70758aca83a078cc81f27e16939c27d334ff8212e2f
+  data.tar.gz: 5f56f58dc3a2074ab355f2694ae40356f10d5623b1f8186790c75cfbba5dd78e075017bd55d77b37bb324e027b67d624d703041d9904aee952ea6442cb4da0b1

data/Gemfile

@@ -8,3 +8,5 @@ gemspec
 gem "rake", "~> 13.2"
 gem "rspec", "~> 3.4"
 gem "standard", "~> 1.45"
+
+gem "debug"

data/README.md

@@ -1,26 +1,20 @@
-**Good Luck, Wizard**. You're going to need it. Especially because this is an
-_extremely_ unfinished game. It's hard to even call it a game at this point. You
-should come back later when there's something worth playing.
+**good luck, wizard**. you're going to need it. not least of all because this is
+an _extremely_ unfinished game. not really a game at all, yet. come back later.
 
-**If you absolutely must try it, you can install it** with `gem install
-good_luck_wizard` and run it with `glw`. This assumes you have a working Ruby
+if you absolutely must try it, you can install it with `gem install
+good_luck_wizard` and run it with `glw`. this assumes you have a working Ruby
 environment and a new enough version of Ruby.
 
-**This project is not seeking contributions,** but bug reports are accepted [on
+this project is not seeking contributions, but bug reports are accepted [on
 GitHub](https://github.com/jarednorman/good_luck_wizard).
 
-**This project is intended to be a safe, welcoming space for collaboration.**
-Everyone interacting in the _Good Luck, Wizard_ project’s codebases, issue
-trackers, chat rooms and mailing lists is expected to follow the [code of
+this project is intended to be a safe, welcoming space for collaboration. yes,
+even though i don't want you to contribute, i will still ensure you aren't
+descriminated against if you try. everyone interacting in the _good luck,
+wizard_ project’s codebases, issue trackers, chat rooms and mailing lists is
+expected to follow the [code of
 conduct](https://github.com/jarednorman/good_luck_wizard/blob/master/CODE_OF_CONDUCT.md).
 
----
-
-**To run thep roject locally,** checck out the repo and run `bin/setup` to
-install dependencies. The tests are run with `bundle exec rspec`. You can also
-run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To release a new version, update the version number in `version.rb`, and then
-run `bundle exec rake release`, which will create a git tag for the version,
-push git commits and tags, and push the `.gem` file to
-[rubygems.org](https://rubygems.org).
+to run the project locally: check out the repo and run `bin/setup` to install
+dependencies. the tests are run with `bundle exec rspec`. you can also run
+`bin/console` for an interactive prompt that will allow you to experiment.

data/Rakefile

@@ -7,4 +7,4 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList["test/**/*_test.rb"]
 end
 
-task :default => :test
+task default: :test

data/bin/release

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "date"
+require "fileutils"
+
+# Parse version argument
+if ARGV.empty?
+  puts "Usage: bin/release VERSION"
+  puts "Example: bin/release 1.2.3"
+  exit 1
+end
+
+version = ARGV[0]
+unless version.match?(/^\d+\.\d+\.\d+$/)
+  puts "Error: Version must be in format X.Y.Z (e.g., 1.2.3)"
+  exit 1
+end
+
+puts "Releasing version #{version}..."
+
+# 1. Update lib/glw/version.rb
+version_file = "lib/glw/version.rb"
+version_content = File.read(version_file)
+updated_version_content = version_content.gsub(
+  /VERSION = "[^"]+"/, 
+  %(VERSION = "#{version}")
+)
+File.write(version_file, updated_version_content)
+puts "✓ Updated #{version_file}"
+
+# 4. Commit changes
+commit_message = "v#{version}"
+system("jj", "commit", "-m", commit_message) || exit(1)
+puts "✓ Committed changes with message '#{commit_message}'"
+
+# 5. Move main branch to the change we just made
+system("jj", "bookmark", "set", "main", "-r", "@-") || exit(1)
+puts "✓ Moved main branch to release commit"
+
+# 6. Tag the version
+tag_name = "v#{version}"
+tag_message = "Version #{version}"
+system("git", "tag", "-m", tag_message, tag_name) || exit(1)
+puts "✓ Created tag #{tag_name}"
+
+# 7. Push changes and tags
+system("jj", "git", "push", "-b", "main") || exit(1)
+puts "✓ Pushed main branch"
+
+system("git", "push", "--tags") || exit(1)
+puts "✓ Pushed tags"
+
+# 8. Build and push gem
+gem_file = "good_luck_wizard-#{version}.gem"
+system("gem", "build", "good_luck_wizard.gemspec") || exit(1)
+puts "✓ Built gem"
+
+system("gem", "push", gem_file) || exit(1)
+puts "✓ Pushed gem"
+
+system("rm", gem_file)
+puts "✓ Cleaned up gem file"
+
+puts "\n🎉 Successfully released version #{version}!"

data/exe/glw

@@ -1,4 +1,11 @@
 #!/usr/bin/env ruby
 
-require 'glw'
+if ENV["DEBUG"] == "true"
+  # This avoids terminal corruption unless something has actually gone wrong.
+  ENV["RUBY_DEBUG_LOG_LEVEL"] = "ERROR"
+
+  require "debug/open_nonstop"
+end
+
+require "glw"
 GLW.start!

data/good_luck_wizard.gemspec

@@ -24,6 +24,7 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = ">= 3.4.0"
 
-  spec.add_dependency "curses", "~> 1.4.0"
   spec.add_dependency "zeitwerk", "~> 2.4"
+  spec.add_dependency "concurrent-ruby"
+  spec.add_dependency "concurrent-ruby-edge", "~> 0.7"
 end

data/lib/glw/buffer_state.rb

@@ -0,0 +1,15 @@
+module GLW
+  BufferState = Data.define(:width, :height, :cells) do
+    def self.blank(height:, width:)
+      new(
+        width,
+        height,
+        Array.new(height * width) { ScreenCell.blank }
+      )
+    end
+
+    def [](x, y)
+      cells[y * width + x]
+    end
+  end
+end

data/lib/glw/input.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module GLW
+  module Input
+    class << self
+      ESCAPE_TIMEOUT = 0.02 # 20ms
+
+      BYTES = {
+        "\t" => :k_tab,
+        "\r" => :k_enter,
+        "\n" => :k_enter,
+        "\x7F" => :k_backspace,
+        "\b" => :k_backspace,
+        " " => :k_space,
+        "\x03" => :k_ctrl_c,
+        "[" => :k_left_bracket,
+        "]" => :k_right_bracket,
+        ";" => :k_semicolon,
+        "'" => :k_single_quote,
+        "," => :k_comma,
+        "." => :k_period
+      }.tap do |h|
+        ("a".."z").each { |c| h[c] = :"k_#{c}" }
+        ("A".."Z").each { |c| h[c] = :"k_#{c}" }
+        ("0".."9").each { |c| h[c] = :"k_#{c}" }
+      end
+
+      def pop
+        @queue.pop
+      end
+
+      def start!
+        return if @queue
+
+        @queue = Thread::Queue.new
+
+        Thread.new do
+          loop do
+            byte = read_byte
+
+            if byte == "\e"
+              handle_escape byte
+            else
+              handle_byte byte
+            end
+          rescue EOFError
+            break
+          end
+        end
+      end
+
+      private
+
+      def handle_escape(first_byte)
+        second_byte = read_byte(timeout: true)
+
+        if second_byte.nil?
+          @queue << :k_escape
+          nil
+        elsif second_byte == "["
+          third_byte = read_byte(timeout: true)
+
+          case third_byte
+          when "A"
+            @queue << :k_up
+          when "B"
+            @queue << :k_down
+          when "C"
+            @queue << :k_right
+          when "D"
+            @queue << :k_left
+          else
+            @queue << :k_escape
+            handle_byte second_byte
+            handle_byte third_byte if third_byte
+          end
+        else
+          @queue << :k_escape
+          handle_byte second_byte
+        end
+      end
+
+      def handle_byte(byte)
+        return unless BYTES.key?(byte)
+
+        @queue << BYTES[byte]
+      end
+
+      def read_byte(timeout: false)
+        return if timeout && !IO.select([STDIN], nil, nil, 0.02)
+
+        STDIN.readpartial(1)
+      end
+    end
+  end
+end

data/lib/glw/screen.rb

@@ -0,0 +1,103 @@
+module GLW
+  module Screen
+    class << self
+      UpdateBlock = Data.define(:start_index, :cells) do
+        def self.make(start_index) = new(start_index, [])
+
+        def to_s(current_fg: nil, current_bg: nil)
+          output = ""
+          fg = current_fg
+          bg = current_bg
+
+          cells.each do |cell|
+            if cell.fg_color != fg
+              output << Terminal.set_fg(cell.fg_color)
+              fg = cell.fg_color
+            end
+
+            if cell.bg_color != bg
+              output << Terminal.set_bg(cell.bg_color)
+              bg = cell.bg_color
+            end
+
+            output << cell.char
+          end
+
+          [output, fg, bg]
+        end
+      end
+
+      def start!
+        @render_queue = Thread::Queue.new
+
+        @render_queue.push BufferState.blank(
+          height: IO.console.winsize[0],
+          width: IO.console.winsize[1]
+        )
+
+        Thread.new do
+          STDOUT.print Terminal.hide_cursor
+
+          last_state = nil
+
+          loop do
+            state = @render_queue.pop
+
+            # Throw away stale states until we have the newest one.
+            state = @render_queue.pop until @render_queue.empty?
+
+            render(last_state, state)
+            last_state = state
+          end
+        end
+      end
+
+      def push_state(state)
+        @render_queue.push(state)
+      end
+
+      private
+
+      def render(last_state, state)
+        updates = []
+        current_block = nil
+
+        state.cells.each_with_index do |cell, index|
+          next if last_state && cell == last_state.cells[index]
+
+          if current_block && current_block.start_index + current_block.cells.length == index
+            current_block.cells << cell
+          else
+            updates << current_block if current_block
+
+            current_block = UpdateBlock.new(index, [cell])
+          end
+        end
+
+        updates << current_block if current_block
+
+        current_fg = nil
+        current_bg = nil
+
+        STDOUT.print(
+          updates.flat_map do |block|
+            y = block.start_index / state.width
+            x = block.start_index % state.width
+
+            block_output, current_fg, current_bg = block.to_s(
+              current_fg:,
+              current_bg:
+            )
+
+            [
+              Terminal.move_to(x, y),
+              block_output
+            ]
+          end.join
+        )
+
+        STDOUT.flush
+      end
+    end
+  end
+end

data/lib/glw/screen_cell.rb

@@ -0,0 +1,7 @@
+module GLW
+  ScreenCell = Data.define(:char, :fg_color, :bg_color) do
+    def self.blank
+      @blank ||= new(" ", :black, :black)
+    end
+  end
+end

data/lib/glw/terminal.rb

@@ -0,0 +1,31 @@
+module GLW
+  module Terminal
+    class << self
+      PALETTE = {
+        black: [0, 0, 0],
+        white: [255, 255, 255]
+      }.transform_values do |(r, g, b)|
+        [
+          "\e[38;2;#{r};#{g};#{b}m",
+          "\e[48;2;#{r};#{g};#{b}m"
+        ]
+      end.freeze
+
+      def move_to(x, y)
+        "\e[#{y + 1};#{x + 1}H"
+      end
+
+      def set_fg(color)
+        PALETTE.fetch(color)[0]
+      end
+
+      def set_bg(color)
+        PALETTE.fetch(color)[1]
+      end
+
+      def hide_cursor
+        "\e[?25l"
+      end
+    end
+  end
+end

data/lib/glw/version.rb

@@ -1,3 +1,3 @@
 module GLW
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/lib/glw.rb

@@ -1,33 +1,31 @@
-require 'curses'
+require "io/console"
+require "concurrent/actor"
+
 require "zeitwerk"
 
-require "glw/version"
+Zeitwerk::Loader.for_gem.tap do |loader|
+  loader.inflector.inflect(
+    "glw" => "GLW"
+  )
+
+  loader.setup
+end
 
 module GLW
   class << self
     def start!
-      initialize_zeitwerk
-
-      GLW::Term.with_term do |t|
-        g = Game.new(term: t)
+      IO.console.raw do
+        Screen.start!
+        Input.start!
 
         loop do
-          g.render
-          break if g.send_key(t.getch) == :quit
-        end
-      end
-    end
-
-    def initialize_zeitwerk
-      return if @zeitwerk_enabled
+          content = Input.pop
 
-      Zeitwerk::Loader.new.tap do |loader|
-        loader.inflector.inflect("glw" => "GLW")
-        loader.push_dir(__dir__)
-        loader.setup
+          exit(0) if content == :k_escape || content == :k_ctrl_c
+        end
       end
-
-      @zeitwerk_enabled = true
+    rescue
+      raise
     end
   end
 end

data/test_input.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "lib/glw"
+
+puts "Input Test - Press keys to see symbols (press 'q' or Ctrl-C to quit)"
+puts "Try: letters, numbers, arrows, ESC, space, tab, enter, backspace, Ctrl-C"
+puts "-" * 60
+
+IO.console.raw do
+  GLW::Input.start!
+
+  loop do
+    key = GLW::Input.pop
+    puts "Received: #{key.inspect}"
+
+    break if key == :k_q || key == :k_ctrl_c
+  end
+end
+
+puts "\nExiting..."

metadata

@@ -1,42 +1,56 @@
 --- !ruby/object:Gem::Specification
 name: good_luck_wizard
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Jared Norman
 bindir: exe
 cert_chain: []
-date: 2025-03-09 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: curses
+  name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: '2.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: '2.4'
 - !ruby/object:Gem::Dependency
-  name: zeitwerk
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby-edge
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.4'
+        version: '0.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.4'
+        version: '0.7'
 description: An unfinished terminal-based roguelike game
 email:
 - jared@super.gd
@@ -53,16 +67,19 @@ files:
 - README.md
 - Rakefile
 - bin/console
+- bin/release
 - bin/setup
 - exe/glw
 - good_luck_wizard.gemspec
 - lib/glw.rb
-- lib/glw/game.rb
-- lib/glw/map.rb
+- lib/glw/buffer_state.rb
+- lib/glw/input.rb
 - lib/glw/random.rb
-- lib/glw/term.rb
-- lib/glw/term_colors.rb
+- lib/glw/screen.rb
+- lib/glw/screen_cell.rb
+- lib/glw/terminal.rb
 - lib/glw/version.rb
+- test_input.rb
 homepage: http://github.com/jarednorman/good_luck_wizard
 licenses: []
 metadata: {}
@@ -80,7 +97,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 4.0.2
 specification_version: 4
 summary: An unfinished terminal-based roguelike game
 test_files: []

data/lib/glw/game.rb

@@ -1,31 +0,0 @@
-module GLW
-  class Game
-    def initialize(term:)
-      @map = Map.new
-      @term = term
-    end
-
-    def send_key(key)
-      case key
-      when "q"
-        :quit
-      when "h"
-        @map.send_event :left
-      when "l"
-        @map.send_event :right
-      when "k"
-        @map.send_event :up
-      when "j"
-        @map.send_event :down
-      end
-    end
-
-    def render
-      map.render(term, width: term.width - 60, height: term.height)
-    end
-
-    private
-
-    attr_reader :term, :map
-  end
-end

data/lib/glw/map.rb

@@ -1,71 +0,0 @@
-module GLW
-  class Map
-    MAP = <<~TXT
-      ############
-      #..........#          ##########
-      #..........############....#...#
-      #..............................#
-      #.......g..############....#...#
-      #..........#          #....#...#
-      ############          ##########
-    TXT
-
-    def initialize
-      @player_x = 3
-      @player_y = 3
-
-      @map = Hash.new(" ")
-      MAP.lines.each_with_index do |line, y|
-        line.chars.each_with_index do |c, x|
-          @map[[x, y]] = c
-        end
-      end
-
-      @offset_x = 1
-      @offset_y = 1
-    end
-
-    def send_event(e)
-      case e
-      when :left
-        @player_x -= 1 if valid_player_position?(@player_x - 1, @player_y)
-      when :right
-        @player_x += 1 if valid_player_position?(@player_x + 1, @player_y)
-      when :up
-        @player_y -= 1 if valid_player_position?(@player_x, @player_y - 1)
-      when :down
-        @player_y += 1 if valid_player_position?(@player_x, @player_y + 1)
-      end
-    end
-
-    def render(term, width:, height:)
-      (0..width - 1).each do |x|
-        (0..height - 1).each do |y|
-
-          if [@player_x + @offset_x, @player_y + @offset_y] == [x, y]
-            term.set(
-              x: x,
-              y: y,
-              c: "@",
-              fg: 220
-            )
-          else
-            term.set(
-              x: x,
-              y: y,
-              c: @map[[x - @offset_x, y - @offset_y]]
-            )
-          end
-        end
-      end
-
-      term.refresh
-    end
-
-    private
-
-    def valid_player_position?(x, y)
-      @map[[x, y]] == "."
-    end
-  end
-end

data/lib/glw/term.rb

@@ -1,72 +0,0 @@
-module GLW
-  # This class is responsible for handling all interactions with the terminal
-  # so that this thing can be half-ways frontend independent, though I have no
-  # intention of ever switching frontends.
-  class Term
-    DEFAULT_FG = 255
-    DEFAULT_BG = 16
-
-    Cell = Struct.new(:c, :fg, :bg)
-
-    DEFAULT_CELL = Cell.new(" ", DEFAULT_FG, DEFAULT_BG)
-
-    class << self
-      def with_term
-        Curses.init_screen
-        Curses.start_color
-        Curses.curs_set(0)
-        Curses.noecho
-
-        Curses.assume_default_colors(DEFAULT_FG, DEFAULT_BG)
-
-        yield new(Curses::Window.new(0, 0, 0, 0))
-      ensure
-        Curses.close_screen
-      end
-    end
-
-    def initialize(window)
-      @window = window
-      @tiles = Hash.new { DEFAULT_CELL }
-      @next_tiles = {}
-      @colors = TermColors.new
-    end
-
-    def set(x:, y:, c:, fg: DEFAULT_FG, bg: DEFAULT_BG)
-      cell = Cell.new(c, fg, bg)
-
-      @next_tiles[[x, y]] = cell unless @tiles[[x, y]] == cell
-    end
-
-    def width
-      Curses.cols
-    end
-
-    def height
-      Curses.lines
-    end
-
-    def getch
-      window.getch
-    end
-
-    def refresh
-      @next_tiles.each do |coords, cell|
-        x, y = *coords
-        window.setpos(y, x)
-
-        window.attron(colors[cell.fg, cell.bg]) do
-          window << cell.c
-        end
-      end
-
-      @tiles = @tiles.merge(@next_tiles)
-
-      window.refresh
-    end
-
-    private
-
-    attr_reader :window, :colors
-  end
-end

data/lib/glw/term_colors.rb

@@ -1,22 +0,0 @@
-module GLW
-  class TermColors
-    def initialize(curses = Curses)
-      index = 1
-
-      @colors = Hash.new do |hash, key|
-        fg, bg = *key
-
-        curses.init_pair(index, fg, bg)
-        hash[key] = curses.color_pair(index)
-
-        index += 1
-
-        hash[key]
-      end
-    end
-
-    def [](fg, bg)
-      @colors[[fg, bg]]
-    end
-  end
-end