basher-basher 0.1.1

data/lib/basher/handler.rb

@@ -0,0 +1,34 @@
+module Basher
+  class Handler
+    ALPHABET = ('a'..'z').to_a.freeze
+
+    class << self
+      attr_reader :bindings
+
+      def bind(*keys, &action)
+        @bindings ||= {}
+        keys.map(&:to_sym).each do |input|
+          @bindings[input] ||= []
+          @bindings[input] << action
+        end
+      end
+    end
+
+    attr_reader :bindings
+
+    def initialize(custom_bindings = {})
+      @bindings = self.class.bindings.merge(custom_bindings)
+    end
+
+    def invoke(input)
+      bindings.fetch(input.to_sym, []).map do |b|
+        b.call(input)
+      end.last
+    end
+
+    def letter?(input)
+      return false if input.size != 1
+      input =~ /[[:alpha:]]/
+    end
+  end
+end

data/lib/basher/level.rb

@@ -0,0 +1,131 @@
+require 'forwardable'
+
+module Basher
+  # Handles the initialization of a single level in the game.
+  # The defining characteristic of a level is it's #difficulty, which
+  # controls the number of the words in the level, and their size.
+  #
+  # TODO: Extract constants to global configuration values.
+  class Level
+    # Delegate cursor methods to the word itself.
+    extend Forwardable
+    def_delegators :cursor, :position, :previous,
+      :remaining, :advance!, :rewind!, :finished?
+
+    def_delegator :cursor, :item, :word
+
+    # Biggest word size
+    MAX_WORD_SIZE = 15.freeze
+
+    # Word sizes
+    WORD_SIZES = (3..MAX_WORD_SIZE).freeze
+
+    # How many words per level
+    WORDS_PER_LEVEL = 8.freeze
+
+    # Use this attribute to determine the number of the words,
+    # and the length of the words.
+    attr_reader :difficulty
+    attr_reader :words
+    attr_reader :cursor
+    attr_reader :timer
+
+    class << self
+      def start(difficulty, &on_end)
+        level = self.new(difficulty)
+
+        level.start do
+          on_end.call
+        end
+
+        level
+      end
+    end
+
+    # Returns a Level instance with the default difficulty of 1.
+    def initialize(difficulty = 1)
+      @difficulty = difficulty || 1
+      pick_words!
+      @cursor = Cursor.new(words)
+      @timer  = Timer.new
+    end
+
+    def sizes
+      WORD_SIZES
+    end
+
+    def weights
+      sizes.map { |size| calculate(size) }
+    end
+
+    def chances
+      weights.map { |weight| (weight / total_weight * 100.0).round(2) }
+    end
+
+    # Get an array of words that are calculated based on the difficulty.
+    # The bigger the difficulty, the bigger the words.
+    def pick_words!(words_per_level = WORDS_PER_LEVEL)
+      @words = pick(words_per_level).map do |size|
+        Basher::Word.new(Basher::Dictionary.random_word(size))
+      end
+    end
+
+    def pick(words = 15)
+      1.upto(words).collect { roll }
+    end
+
+    def time_limit
+      [((difficulty + 2) * 100.to_f / (average_word_size.to_f ** 2)).ceil, 20].min * 1000
+    end
+
+    def start
+      timer.start
+
+      @thread = Thread.new do
+        begin
+          sleep 0.005 while timer.total_elapsed <= time_limit
+          timer.stop
+          yield
+        end
+      end
+    end
+
+    def pause
+      timer.stop
+    end
+
+    def finish
+      timer.stop
+      @thread.terminate if !@thread.nil? && @thread.alive?
+    end
+
+    def average_word_size
+      words.reduce(0) { |sum, w| sum += w.string.size } / words.size
+    end
+
+    private
+
+    def total_weight
+      weights.reduce(:+)
+    end
+
+    def roll
+      sizes_and_weights = sizes.zip(weights)
+
+      loop do
+        sizes_and_weights.shuffle.each do |tuple|
+          size, weight = *tuple
+
+          chance = (weight / weights.reduce(:+) * 100.0).round(2)
+          rolled = (rand * 100).round(2)
+          return size if rolled <= chance
+        end
+      end
+    end
+
+    def calculate(size)
+      weight = (difficulty / (size / 2) ) ** size
+      weight.round(2)
+    end
+  end
+end

data/lib/basher/refinements/string.rb

@@ -0,0 +1,15 @@
+require 'artii'
+
+module Basher
+  module StringRefinements
+    refine String do
+      def ascii(font: 'broadway')
+        Artii::Base.new(font: font).asciify(self)
+      end
+
+      def ascii_size(font: 'broadway')
+        ascii(font: font).lines.map(&:size).max
+      end
+    end
+  end
+end

data/lib/basher/state.rb

@@ -0,0 +1,46 @@
+module Basher
+  class State
+    TRANSITIONS = {
+      loading:  %i(menu in_game),
+      menu:     %i(loading),
+      in_game:  %i(paused score),
+      paused:   %i(in_game menu),
+      score:    %i(menu)
+    }.freeze
+
+    class << self
+      def all
+        TRANSITIONS.keys
+      end
+    end
+
+    attr_reader   :current
+    attr_accessor :difficulty
+
+    def initialize(initial_state = :loading)
+      @current = initial_state
+    end
+
+    TRANSITIONS.keys.each do |state|
+      define_method "#{state}?" do
+        current == state
+      end
+
+      define_method "#{state}!" do
+        @current = state
+      end
+    end
+
+    def transitions
+      TRANSITIONS.fetch(current, [])
+    end
+
+    def transition_to(state)
+      @current = state if transitions.include?(state)
+    end
+
+    def current_difficulty
+
+    end
+  end
+end

data/lib/basher/timer.rb

@@ -0,0 +1,69 @@
+module Basher
+  class Timer
+    attr_reader :started_at, :stopped_at
+
+    def initialize
+      reset
+    end
+
+    # Milliseconds
+    def elapsed
+      return @total_elapsed unless running?
+      ((looking_at - started_at) * 1000).ceil
+    end
+
+    def total_elapsed
+      return @total_elapsed unless running?
+      @total_elapsed + elapsed
+    end
+
+    def total_elapsed_in_seconds
+      (total_elapsed.to_f / 1000).round
+    end
+
+    def total_elapsed_humanized
+      seconds = total_elapsed_in_seconds
+      [[60, :seconds], [60, :minutes], [24, :hours]].map do |count, name|
+        if seconds > 0
+          seconds, n = seconds.divmod(count)
+          "#{n.to_i} #{name}"
+        end
+      end.compact.reverse.join(' ')
+    end
+
+    def start
+      @stopped_at = nil
+      @started_at = now
+    end
+
+    def stop
+      @total_elapsed += elapsed
+      @stopped_at = now
+    end
+
+    def reset
+      @stopped_at = nil
+      @started_at = nil
+      @total_elapsed = 0
+    end
+
+    def advance(milliseconds)
+      @total_elapsed += milliseconds
+    end
+
+    private
+
+    def now
+      Time.now
+    end
+
+    def running?
+      !started_at.nil? && stopped_at.nil?
+    end
+
+    def looking_at
+      running? ? now : stopped_at
+    end
+
+  end
+end

data/lib/basher/ui.rb

@@ -0,0 +1,125 @@
+require 'basher/ui/base_view'
+require 'basher/ui/debug_view'
+require 'basher/ui/loading_view'
+require 'basher/ui/title_view'
+require 'basher/ui/menu_view'
+require 'basher/ui/info_view'
+require 'basher/ui/current_word_view'
+require 'basher/ui/remaining_words_view'
+require 'basher/ui/progress_view'
+require 'basher/ui/score_view'
+
+module Basher
+  module UI
+    def views
+      @views ||= methods.grep(/(?<!base)_view/).map { |v| self.public_send(v) }.flatten
+    end
+
+    def current_views
+      views = case state.current
+        when :loading
+          [loading_view]
+        when :menu
+          [title_view, menu_view]
+        when :in_game
+          [info_view, current_word_view, remaining_words_view, progress_view]
+        when :score
+          [score_view]
+        when :paused
+          [title_view, menu_view]
+        else
+          []
+        end
+
+      views << debug_view if debugging?
+
+      views
+    end
+
+    def debug_view
+      @debug_view ||= DebugView.new do |v|
+        v.game    = self
+
+        v.lines   = DebugView.lines
+      end
+    end
+
+    def loading_view
+      @loading_view ||= LoadingView.new do |v|
+        v.text = 'Loading...'
+      end
+    end
+
+    def title_view
+      @title_view ||= TitleView.new do |v|
+        v.state     = state
+
+        v.lines   = TitleView.lines
+        v.line    = -> {
+          (v.parent.lines - TitleView.lines - MenuView.lines) / 2
+        }
+      end
+    end
+
+    def menu_view
+      @menu_view ||= MenuView.new do |v|
+        v.state     = state
+
+        v.lines     = MenuView.lines
+        v.line      = -> { v.parent.lines - MenuView.lines }
+      end
+    end
+
+    def current_word_view
+      @current_word_view ||= CurrentWordView.new do |v|
+        v.game = self
+
+        v.lines = CurrentWordView.lines
+        v.line  = -> {
+          other = CurrentWordView.lines + InfoView.lines +
+            RemainingWordsView.lines + ProgressView.lines
+
+          (v.parent.lines - other) / 2
+        }
+      end
+    end
+
+    def info_view
+      @info_view ||= InfoView.new do |v|
+        v.game    = self
+
+        v.line    = 0
+        v.lines   = InfoView.lines
+      end
+    end
+
+    def remaining_words_view
+      @remaining_words_view ||= RemainingWordsView.new do |v|
+        v.game  = self
+
+        v.lines = RemainingWordsView.lines
+        v.line  = -> { v.parent.lines - 2 }
+      end
+    end
+
+    def progress_view
+      @progress_view ||= ProgressView.new do |v|
+        v.game  = self
+
+        v.lines = ProgressView.lines
+        v.line  = -> { v.parent.lines - 1 }
+      end
+    end
+
+    def score_view
+      @score_view ||= ScoreView.new do |v|
+        v.game = self
+
+        v.lines = ScoreView.lines
+        v.line  = -> {
+          (v.parent.lines - ScoreView.lines) / 2
+        }
+      end
+    end
+  end
+end

data/lib/basher/ui/base_view.rb

@@ -0,0 +1,28 @@
+module Basher
+  module UI
+    class BaseView < Curtis::View
+
+      attr_accessor :should_redraw
+
+      def initialize
+        self.should_redraw = false
+        super
+      end
+
+      def will_resize!
+        self.should_redraw = true
+      end
+
+      def resize_and_reposition
+        reposition
+        resize
+        self.should_redraw = false
+      end
+
+      def clear(also_thread = true)
+        clear_thread! if also_thread
+        window.clear
+      end
+    end
+  end
+end