worlds-terminal 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5f66773252b9e9c4dde7a90174f3715e8be7cb32ba46bf88833698f631aa8a71
+  data.tar.gz: 20ef4d48c714b41cf58b236d3368b80357a212b44bf0f7ed5b23ab8b1e930733
+SHA512:
+  metadata.gz: 221cf441e1d4a20f2f86de54c71fbe3db670e9db1f0f7888a92749e2988cdc1bcd04404cf1df8bf9a1509c0e0413a085cac0f2b8180b56606368886ee7f662cc
+  data.tar.gz: 0c0f66fb15ae29187705e1360040da4113777cb044bf6c2baea029fc230eb9d4e5a2c361fd48defc0d36ac0b33e06381073438ca204f730bdc51e154d2830f62

data/bin/worlds

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+# Runs the game.
+
+require_relative '../lib/worlds/terminal/helper'
+require_relative '../lib/worlds/terminal/runner'
+
+# Not namespaced as Worlds::Terminal because the Worlds module will eventually be
+# split into its own gem, which can be used by more than this terminal interface
+# (e.g. a web interface).
+module Worlds
+  module Terminal
+    Helper.io_mode_raw!
+    Helper.hide_cursor!
+
+    begin
+      Runner.io_loop
+    ensure
+      Helper.show_cursor!
+      Helper.io_mode_normal!
+    end
+  end
+end
+

data/lib/worlds/area.rb

@@ -0,0 +1,21 @@
+module Worlds
+  class Area
+    attr_reader :name, :entities, :linked_areas
+
+    def initialize(name)
+      @name = name
+      @entities = []
+      @linked_areas = []
+    end
+
+    def update(ms)
+      entities.flat_map { |entity|
+        entity.update(ms)
+      }
+    end
+
+    def to_s
+      name
+    end
+  end
+end

data/lib/worlds/components/component.rb

@@ -0,0 +1,37 @@
+module Worlds
+  module Components
+    class Component
+      attr_reader :owner
+      attr_accessor :commands
+
+      def initialize(entity, commands: [])
+        @owner = entity
+        @commands = commands
+      end
+
+      def select_heading
+        "Select an option:"
+      end
+
+      def select_options
+        []
+      end
+
+      def select
+        return nil unless select_options.any?
+
+        {
+          type: :select,
+          heading: select_heading,
+          options: select_options.map(&:to_s),
+        }
+      end
+
+      def invoke
+      end
+
+      def update(ms)
+      end
+    end
+  end
+end

data/lib/worlds/components/ticker.rb

@@ -0,0 +1,10 @@
+module Worlds
+  module Components
+    class Ticker < Component
+      def update(ms)
+        @tick = !@tick
+        { color: :blue, content: @tick ? 'Tick!' : 'Tock!' }
+      end
+    end
+  end
+end

data/lib/worlds/components/travel.rb

@@ -0,0 +1,25 @@
+module Worlds
+  module Components
+    class Travel < Component
+      def select_heading
+        "Choose a destination:"
+      end
+
+      def select_options
+        owner.area.linked_areas
+      end
+
+      # @param target [Area, Integer] an Area, or the index of an Area in the
+      #   owner's linked areas.
+      def invoke(target)
+        target = target.is_a?(Area) ? target : owner.area.linked_areas[target]
+
+        owner.area&.entities&.delete(owner)
+        target.entities << owner
+        owner.area = target
+
+        { color: :green, content: "You are now in #{target.name}" }
+      end
+    end
+  end
+end

data/lib/worlds/entity.rb

@@ -0,0 +1,20 @@
+module Worlds
+  class Entity
+    attr_reader :components
+    attr_accessor :area
+
+    class << self
+      attr_accessor :player
+    end
+
+    def initialize
+      @components = []
+    end
+
+    def update(ms)
+      components.flat_map { |component|
+        component.update(ms)
+      }
+    end
+  end
+end

data/lib/worlds/special_commands.rb

@@ -0,0 +1,10 @@
+module Worlds
+  class SpecialCommands
+    ACTIONS = {
+      exit: -> {
+        [{ color: :white, content: "Exiting..." },
+          { type: :exit }]
+      },
+    }
+  end
+end

data/lib/worlds/terminal/helper.rb

@@ -0,0 +1,42 @@
+module Worlds
+  module Terminal
+    # Utility methods for allowing output above the input line in the terminal.
+    class Helper
+      # To allow output above the input line, disables input buffering.
+      def self.io_mode_raw! = `stty raw`
+      def self.io_mode_normal! = `stty -raw`
+
+      # From https://stackoverflow.com/a/50152099
+      # If the cursor weren't hidden, it would appear at the beginning of the line
+      # due to ::io_mode_raw!
+      def self.hide_cursor! = print "\033[?25l"
+      def self.show_cursor! = print "\033[?25h"
+
+      # Reads newly inputted characters in a way that doesn't block output,
+      # to allow output above the input line. Based on https://stackoverflow.com/a/9900628
+      # @return [String] all inputted characters.
+      def self.read_nonblock
+        line = ''
+
+        while char = STDIN.read_nonblock(1, exception: false)
+          return line if char == :wait_readable
+          line << char
+        end
+      end
+
+      # To allow output above the input line, wraps `puts` in a change to the
+      # terminal mode. Also right-pads the output with spaces to prevent the input
+      # from "bleeding over" into output wherever an output line is shorter than a
+      # line being inputted.
+      # @parmam str [String] The string to print.
+      def self.puts(str)
+        # From https://gist.github.com/KINGSABRI/4687864
+        terminal_width = `tput cols`.to_i
+
+        io_mode_normal!
+        Kernel.puts str.ljust(terminal_width, ' ')
+        io_mode_raw!
+      end
+    end
+  end
+end

data/lib/worlds/terminal/runner.rb

@@ -0,0 +1,100 @@
+require 'pastel'
+require_relative 'helper'
+require_relative 'updater'
+
+module Worlds
+  module Terminal
+    # A container for the input loop, which is needed because input is read in
+    # a non-blocking way, i.e. input is read while new output is displayed.
+    class Runner
+      PASTEL = Pastel.new
+      CURSOR = '█'
+      BACKSPACE = "\x7F"
+      CTRL_BACKSPACE = "\x17" # or Cmd+Backspace on MacOS
+      INTERRUPT = "\x03" # Ctrl+C
+
+      # Loops continuously, reading input and allowing Worlds to update and output.
+      def self.io_loop
+        loop do
+          # We need our own input buffer here because the terminal input buffer is
+          # disabled due to Helper::io_mode_raw!
+          @input_buffer ||= ''
+
+          new_input = Helper.read_nonblock
+
+          if new_input
+            return if new_input.include?(INTERRUPT)
+
+            # Handle Enter.
+            new_input_has_newline = new_input.include?("\n") || new_input.include?("\r")
+            new_input = new_input.split(/[\n\r]/).first if new_input_has_newline
+
+            # Add new input to buffer (or add nothing, if no new input).
+            @input_buffer << (new_input || '')
+
+            # Handle deletion: Ctrl + Backspace (line), or Backspace (character).
+            # In either case, re-print the input buffer with spaces at the end
+            # to cover over the deleted characters.
+            if @input_buffer.include?(CTRL_BACKSPACE)
+              print "#{CURSOR}#{' ' * @input_buffer.length}\r"
+              @input_buffer = ''
+            else
+              backspace_count = @input_buffer.count(BACKSPACE)
+
+              while @input_buffer.length > 0 && @input_buffer.include?(BACKSPACE)
+                @input_buffer.sub!(/[^#{BACKSPACE}]#{BACKSPACE}/, '')
+                @input_buffer = '' if @input_buffer.chars.uniq == [BACKSPACE]
+              end
+
+              print "#{@input_buffer}#{CURSOR}#{' ' * backspace_count}\r"
+            end
+
+            # Echo input. The \r is to make the line replaceable by new output,
+            # while the input line will re-appear below the new output; in effect,
+            # to allow output above the input line.
+            print "#{@input_buffer}#{CURSOR}\r"
+          end
+
+          # Empty the input buffer if Enter was pressed.
+          if new_input_has_newline
+            input_line = @input_buffer.strip
+            @input_buffer = ''
+          end
+
+          # If a line was just inputted, set up an input hash as either a number
+          # selection (if a selection menu was just shown) or else a new command.
+          if input_line
+            if @select_for && input_line.match?(/\A\d+\z/)
+              input = { type: :select, command: @select_for, selection: input_line.to_i }
+              @select_for = nil
+            else
+              input = { type: :command, command: input_line }
+            end
+          end
+
+          # Allow Worlds to loop, and print outputs if any.
+          if outputs = Worlds::Updater.tick(input)
+            outputs.each do |output|
+              case output[:type]
+              when :exit
+                return
+              when :select # selection menu
+                Helper.puts PASTEL.white(output[:heading])
+                output[:options].each.with_index do |option, i|
+                  Helper.puts PASTEL.blue("#{i + 1}. ") + PASTEL.white(option)
+                end
+
+                @select_for = input_line
+              else # informational
+                Helper.puts PASTEL.send(output[:color], output[:content])
+              end
+            end
+          end
+
+          # Reset input, to remain empty until next time Enter is pressed.
+          input_line = nil && input = nil if input_line
+        end
+      end
+    end
+  end
+end

data/lib/worlds/terminal/updater.rb

@@ -0,0 +1,69 @@
+require_relative '../special_commands'
+require_relative '../world'
+
+module Worlds
+  # A container for ::tick, which processes input and updates the world state.
+  class Updater
+    UPDATES_PER_SECOND = 1
+
+    # Whether the world has been started.
+    # @return [Boolean]
+    def self.started?
+      !!@time_start
+    end
+
+    # Processes input if any, or performs an update if enough time has passed.
+    # @param input [Hash] a line of input from the player.
+    # @return [Array<Hash>, nil] an array of output hashes, if input was processed
+    #   or an update was performed.
+    def self.tick(input = nil)
+      unless started?
+        # On why not Time.now, see
+        # https://blog.dnsimple.com/2018/03/elapsed-time-with-ruby-the-right-way
+        @time_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        return World.setup
+      end
+
+      return process_input(input) if input
+
+      time_now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      time_elapsed = time_now - @time_start
+
+      if time_elapsed >= (1.0 / UPDATES_PER_SECOND)
+        @time_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        return update
+      end
+    end
+
+    # Processes input and returns output in response.
+    # @param input [Hash] a line of input from the player.
+    # @return [Array<Hash>, nil] an array of output hashes.
+    private_class_method def self.process_input(input)
+      outputs = []
+
+      if action = SpecialCommands::ACTIONS[input[:command].to_sym]
+        outputs += action.call
+      else
+        outputs += [World.input(input)].flatten.compact
+      end
+
+      if outputs.empty?
+        outputs << { color: :red, content: "Invalid command: #{input[:command]}" }
+      end
+
+      outputs
+    end
+
+    # Updates the world state and returns any resulting output.
+    # @return [Array<Hash>, nil] an array of output hashes.
+    private_class_method def self.update
+      outputs = []
+
+      ms = 1000 / UPDATES_PER_SECOND.round(2)
+      outputs += World.update(ms)
+
+      outputs
+    end
+  end
+end

data/lib/worlds/terminal/version.rb

@@ -0,0 +1,5 @@
+module Worlds
+  module Terminal
+    VERSION = '0.1.0'
+  end
+end

data/lib/worlds/world.rb

@@ -0,0 +1,87 @@
+require_relative 'entity'
+require_relative 'components/component'
+require_relative 'components/travel'
+require_relative 'components/ticker'
+require_relative 'area'
+
+module Worlds
+  class World
+    attr_reader :areas
+
+    class << self
+      attr_reader :instance
+    end
+
+    def self.setup
+      @instance = new
+      @instance.demo_setup
+    end
+
+    def self.input(input)
+      instance.input(input)
+    end
+
+    def self.update(ms)
+      instance.update(ms)
+    end
+
+    def initialize
+      @areas = []
+    end
+
+    def input(input)
+      Entity.player.components.each do |component|
+        if component.commands.include? input[:command]
+          if input[:type] == :select
+            selection_index = input[:selection] - 1
+
+            if selection_index >= component.select_options.count
+              return { color: :red, content: "Invalid selection" }
+            end
+
+            return component.invoke(selection_index)
+          else
+            return [component.select] || [component.invoke]
+          end
+        end
+      end
+
+      nil
+    end
+
+    def update(ms)
+      outputs = []
+
+      areas.each { |area|
+        area_outputs = area.update(ms)
+        outputs = area_outputs.compact if area == Entity.player.area
+      }
+
+      return outputs
+    end
+
+    def demo_setup
+      hero = Entity.new
+      hero.components << Components::Travel.new(hero, commands: %w[travel t go leave])
+      Entity.player = hero
+
+      clock = Entity.new
+      clock.components << Components::Ticker.new(clock)
+
+      street = Area.new("a quiet street")
+      street.entities << hero
+
+      shop = Area.new("Rolf's Clock Shop")
+      shop.linked_areas << street
+      shop.entities << clock
+      street.linked_areas << shop
+
+      @areas << street
+      @areas << shop
+
+      output = Entity.player.components.find { _1.is_a? Components::Travel }.invoke(street)
+
+      [output]
+    end
+  end
+end

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification
+name: worlds-terminal
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Felipe Vogel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-03-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pastel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: debug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: shoulda-context
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: pretty-diffs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rubycritic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.7'
+description: 
+email:
+- fps.vogel@gmail.com
+executables:
+- worlds
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/worlds
+- lib/worlds/area.rb
+- lib/worlds/components/component.rb
+- lib/worlds/components/ticker.rb
+- lib/worlds/components/travel.rb
+- lib/worlds/entity.rb
+- lib/worlds/special_commands.rb
+- lib/worlds/terminal/helper.rb
+- lib/worlds/terminal/runner.rb
+- lib/worlds/terminal/updater.rb
+- lib/worlds/terminal/version.rb
+- lib/worlds/world.rb
+homepage: https://github.com/fpsvogel/worlds-terminal
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/fpsvogel/worlds-terminal
+  source_code_uri: https://github.com/fpsvogel/worlds-terminal
+  changelog_uri: https://github.com/fpsvogel/worlds-terminal/blob/master/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.6
+signing_key: 
+specification_version: 4
+summary: A command-line interface for Worlds, a text-based world simulation and role-playing
+  game toolkit.
+test_files: []