Building a text-based game in Ruby, part 1

loop do
  input = gets
  puts "You said: #{input}"
end

class Runner
  def self.io_loop
    loop do
      input = nil # We'll implement this in the next section.

      if output = Updater.tick(input)
        puts output
      end
    end
  end
end

class Updater
  def self.tick(input)
    return "You said: #{input}" if input

    # 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)

    time_now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
    time_elapsed = time_now - @time_start

    if time_elapsed >= 1
      outputs = []

      @time_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
      return "One second has passed!"
    end
  end
end

# Run the game.
Runner.io_loop

class Helper
  # These methods call system commands setting the terminal to raw or normal mode.
  # Raw mode means each keystroke is sent straight from the terminal, so that we
  # can work with input directly rather than having to wait for a line of input.
  #
  # Note: The `stty` command only works on MacOS and Linux, so if you're on Windows
  # I suggest using WSL (https://learn.microsoft.com/en-us/windows/wsl) to have
  # Linux within Windows. That will also make your life as a Ruby dev on Windows
  # more pleasant in general.
  def self.io_mode_raw! = `stty raw`
  def self.io_mode_normal! = `stty -raw`

  # 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.
  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.
  def self.puts(str)
    terminal_width = `tput cols`.to_i

    io_mode_normal!
    Kernel.puts str.ljust(terminal_width, ' ')
    io_mode_raw!
  end
end

class Runner
  CURSOR = '█'
  INTERRUPT = "\x03" # Ctrl+C

  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 || '')

        # 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 = @input_buffer.strip
        @input_buffer = ''
      end

      # Allow the game to loop, and print output if any.
      if output = Updater.tick(input)
        Helper.puts output
      end

      # Reset input, to remain empty until next time Enter is pressed.
      input = nil if input
    end
  end
end

# Initial setup.
Helper.io_mode_raw!
Helper.hide_cursor!

# Run the game.
begin
  Runner.io_loop
ensure # when exiting back to the terminal.
  Helper.show_cursor!
  Helper.io_mode_normal!
end