adamsanderson-lexery 0.1.0

data/lib/lexery/game_over_screen.rb

@@ -0,0 +1,39 @@
+class GameOverScreen < AbstractScreen
+  def initialize(round)
+    super()
+
+    words = round.words
+    imaginary_words = round.imaginary_words
+    
+    add title = Label.new(10, 10, 'Game Over', :color=>Colors::HEADER, :height=>48)
+    title.x = Game.window.width/2 - title.width/2
+    
+    add score = Label.new(320, 256, "'#{round.initial_word}' #{round.score} words")
+    add timer = Timer.new(1000){|ticks|
+      word = words[(ticks+1) % words.length]
+      color = imaginary_words.include?(word) ? Colors::FADED_WARNING : Colors::FADED
+      add FadingMessage.new(320, score.top-32, word, :color=>color)
+    }
+    
+    add new_game = Button.new(score.left, score.bottom + 4, "New Game"){
+      window.next_state = GameScreen.new()
+    }
+    
+    add replay_game = Button.new(new_game.left, new_game.bottom + 4, "Try Again"){
+      window.next_state = GameScreen.new(round.initial_word)
+    }
+    
+    add Button.new(10, height - 32, "Back"){
+      window.next_state = TitleScreen.new
+    }
+    
+    timer.start
+  end
+  
+  def button_down(id)
+    case id
+    when Gosu::KbEscape then  
+      window.next_state = TitleScreen.new
+    end
+  end
+end

data/lib/lexery/game_rules.rb

@@ -0,0 +1,51 @@
+class GameRules
+  def valid_transition?(old_word, new_word)
+    d = distance(old_word, new_word)
+    case d
+    when 1 then true
+    when 2 then 
+      old_word.chars.sort == new_word.chars.sort
+    else
+      false
+    end
+  end
+  
+  private
+  # From:
+  #   http://rubyforge.org/projects/text
+  def distance(str1, str2)
+    if $KCODE =~ /^U/i
+      unpack_rule = 'U*'
+    else
+      unpack_rule = 'C*'
+    end
+    s = str1.unpack(unpack_rule)
+    t = str2.unpack(unpack_rule)
+    n = s.length
+    m = t.length
+    return m if (0 == n)
+    return n if (0 == m)
+
+    d = (0..m).to_a
+    x = nil
+
+    (0...n).each do |i|
+      e = i+1
+      (0...m).each do |j|
+        cost = (s[i] == t[j]) ? 0 : 1
+        x = [
+          d[j+1] + 1, # insertion
+          e + 1,      # deletion
+          d[j] + cost # substitution
+        ].min
+        d[j] = e
+        e = x
+      end
+      d[m] = x
+    end
+
+    return x
+  end
+  
+  
+end

data/lib/lexery/game_screen.rb

@@ -0,0 +1,128 @@
+class GameScreen < AbstractScreen
+  def initialize(word=nil)
+    super()
+    
+    @rules = GameRules.new
+    @initial_word = word || Game.dictionary.pick
+    @imaginary_count = Game.options['imaginary_words']
+    @words = []
+    @imaginary_words = []
+    @duration = Game.options['duration']
+    
+    @click_sound  = Game.load_sound 'click.wav'
+    @done_sound   = Game.load_sound 'bell.wav'
+    @accept_sound = Game.load_sound 'chick.wav'
+    
+    add @status = Label.new(10, self.height - 32, "current word: #{word}", :height=>32)
+    add score = Label.new(10, 10, :height=>16){"words: #{@words.length}"}
+    add Label.new(10, score.bottom + 2, :height=>16){ "imaginary words remaining: #{@imaginary_count}" }
+    
+    if @duration
+      add remaining_label = Label.new(self.width - 64, 10, @duration)
+      add timer = Timer.new(1000){|ticks|
+        remaining = @duration - ticks
+        remaining_label.text = remaining
+        case remaining
+          when @duration: message "Welcome"
+          when 10:        remaining_label.color = Colors::WARNING
+          when 5:         message "5 seconds remaining", :color=>Colors::WARNING
+                          @click_sound.play
+          when 4,3,2,1:   message "#{remaining}",    :color=>Colors::WARNING
+                          @click_sound.play
+          when 0:         game_over
+                          @done_sound.play
+        end
+      }
+      timer.start
+    end
+    
+    add @word_control = WordControl.new(320, 256, @initial_word)
+    
+    add @reset_button = Button.new(@word_control.left, @word_control.bottom + 10, 'reset'){
+      @word_control.reset
+    }
+    
+    add @ok_button = Button.new(@reset_button.right + 12, @word_control.bottom + 10, 'ok'){ accept }
+    add @done_button = Button.new(width - 64, @status.top, 'done'){ game_over }
+
+    @started = Time.now
+  end
+  
+  def update
+    super 
+    
+    # todo: make this into an event/listener
+    # todo: make this into the rules object
+    unless @last_word == @word_control.text 
+      @valid_transition = @rules.valid_transition? @word_control.word, @word_control.text
+      @valid_word = Game.dictionary.valid_word? @word_control.text
+      @last_word = @word_control.text
+      @changed_word = @word_control.word != @word_control.text
+      @new_word = !@words.include?(@word_control.text)
+      
+      @word_control.valid = @valid_transition && @valid_word && @new_word && @changed_word
+      @imaginary_word = @valid_transition && @new_word && @changed_word && !@valid_word
+      
+      @status.text = if !@changed_word
+        "Add, remove, or change one letter to create a new word"
+      elsif !@valid_transition
+        "You may only add, remove, or change one letter"
+      elsif !@valid_word
+        "'#{@word_control.text}' is not in the dictionary"
+      elsif !@new_word
+        "'#{@word_control.text}' has already been used"
+      else
+        "Click 'ok', or hit 'enter' to use this word"
+      end
+      
+    end
+  end
+  
+  def accept
+    if @word_control.valid || (@imaginary_word && @imaginary_count > 0)
+      word = @word_control.text
+      @accept_sound.play
+      
+      if @imaginary_word
+        @imaginary_words << word
+        @imaginary_count -= 1
+      end
+      
+      @words << word
+      message word, :color=>(@imaginary_word ? Gosu::Color.new(128, 255,0,0) : nil )
+      @word_control.word = word
+    else
+      #@reject_sound.play
+    end
+  end
+  
+  def game_over
+    score = [0, @words.length - @imaginary_words.length].max
+    round = Round.new(
+      :started         => @started,
+      :initial_word    => @initial_word, 
+      :words           => @words,
+      :imaginary_words => @imaginary_words
+    )
+    
+    Game.score_board.record(Game.options_set, round)
+    window.next_state = GameOverScreen.new(round)
+  end
+  
+  def button_down(id)
+    super
+    
+    case id
+    when Gosu::KbReturn, Gosu::KbEnter then
+      accept
+    when Gosu::KbTab then
+      @word_control.reset
+    when Gosu::KbEscape then  
+      window.next_state = TitleScreen.new
+    end
+  end
+  
+  def message(text, options={})
+    add m = FadingMessage.new(320, 224, text, options)
+  end
+end

data/lib/lexery/layers.rb

@@ -0,0 +1,5 @@
+module Layers
+  CURSOR     = 1500
+  UI         = 1000
+  BACKGROUND = 200
+end

data/lib/lexery/round.rb

@@ -0,0 +1,17 @@
+class Round
+  attr_reader :started, :words, :imaginary_words
+  def initialize(hash)
+    @started          = hash[:started]
+    @score            = hash[:score]
+    @words            = hash[:words]
+    @imaginary_words  = hash[:imaginary_words]
+  end
+  
+  def score
+    @words.length
+  end
+    
+  def initial_word
+    words.first
+  end
+end

data/lib/lexery/score_board.rb

@@ -0,0 +1,31 @@
+require 'round'
+
+class ScoreBoard
+  def initialize(path)
+    @path = path
+    if path and File.exist?(path)
+      @games = Marshal.load(File.read(path))
+    else
+      @games = {}
+    end
+  end
+  
+  def rounds(type)
+    @games[type] ||= []
+  end
+  
+  def record(type, round)
+    raise ArgumentError unless round.is_a? Round
+    
+    rounds(type) << round
+    save!
+  end
+  
+  def save!
+    return unless @path
+    
+    File.open(@path,'w') do |io|
+      Marshal.dump(@games,io)
+    end
+  end
+end

data/lib/lexery/stats_screen.rb

@@ -0,0 +1,46 @@
+class StatsScreen < AbstractScreen
+  def initialize
+    super
+    add title = Label.new(10, 10, 'Lexery Stats', :color=>Colors::HEADER, :height=>48)
+    title.x = Game.window.width/2 - title.width/2
+    
+    labels = []
+    Game.all_options.each_with_index{|option, i|
+      key = option.first
+      y = 128+i*96
+      add label = Label.new(320, y, key.capitalize)
+      games = Game.score_board.rounds(key)
+      count = games.length
+      
+      if count > 0
+        scores = games.select{|g| g.score > 0}.map{|g| g.score}
+        average = scores.inject{|m,v| m+v} / scores.length.to_f # TODO: need some stats helpers
+        best_round = games.sort_by{|g| [-g.score, -g.started.to_i]}.first
+        
+        add label = Label.new(340, y+36, "Rounds Played", :height=>18)
+        add label = Label.new(480, y+36, count,           :height=>18)
+        add label = Label.new(340, y+50, "Average Score", :height=>18)
+        add label = Label.new(480, y+50, format('%.2f',average),         :height=>18)
+        add label = Label.new(340, y+66, "Best Round",    :height=>18)
+        add label = Label.new(480, y+66, "'#{best_round.initial_word}' #{best_round.score}", :height=>18)
+      else
+        add label = Label.new(340, y+36, "No games played yet", :height=>18)
+      end
+      labels << label
+    }
+    
+    add Button.new(10, height - 32, "Back"){
+      window.next_state = TitleScreen.new
+    }
+  end
+  
+  def button_down(id)
+    super
+    
+    case id
+    when Gosu::KbEscape then  
+      window.next_state = TitleScreen.new
+    end
+  end
+  
+end

data/lib/lexery/title_screen.rb

@@ -0,0 +1,83 @@
+class TitleScreen < AbstractScreen
+  def initialize
+    super
+    add title = Label.new(10, 10, 'Lexery', :color=>Colors::HEADER, :height=>48)
+    title.x = Game.window.width/2 - title.width/2
+    
+    add @word = Label.new(320, 200, '', :color=>Colors::HEADER, :height=>36)
+    
+    add timer = Timer.new(4000){|ticks|
+      case ticks % 8
+        when 0:         message "Make Words Into New Words"
+        when 1:         message "Start with Grass"
+                        word "Grass"
+        when 2:         message "Replace the r with l"
+                        word "Glass"
+        when 3:         message "Remove the G"
+                        word "Lass"
+        when 4:         message "Replace the s with t"  
+                        word "Last"
+        when 5:         message "Swap the L and s"  
+                        word "Salt"
+        when 6:         message "Add an S"  
+                        word "Salts"
+        when 7:         message "That's all there is to it"
+                        word ""
+      end
+    }
+    timer.start
+    
+    start_buttons = []
+    Game.all_options.each_with_index{|option, i|
+      key = option.first
+      add button = Button.new(320, 256+i*42, key.capitalize){
+        Game.options_set = key
+        window.next_state = GameScreen.new
+      }
+      start_buttons << button
+    }
+    
+    add Button.new(start_buttons.last.left, start_buttons.last.bottom + 32, "Statistics"){
+      window.next_state = StatsScreen.new
+    }
+    
+    add Button.new(10, height - 32, "Quit"){
+      window.close
+    }    
+  end
+  
+  def draw
+    super
+    # Draw the decoration around the instructions:
+    top = @word.top - @word.height * 1.4
+    bottom = @word.bottom + @word.height * 0.2
+    window.draw_quad 0, top,          0x66ffffff,   
+                     width, top,      0x66ffffff,
+                     0, bottom,       0x66ffffff,
+                     width, bottom,   0x66ffffff
+    window.draw_line 0, top,          0xccccccff,
+                     width, top,      0xccccccff
+    window.draw_line 0, bottom,       0xccccccff,
+                     width, bottom,   0xccccccff
+  end
+  
+  def button_down(id)
+    case id
+    when Gosu::KbEscape:  window.close
+    when Gosu::KbQ:       window.close
+    end
+  end
+  
+  def message(text, options={})
+    label = Label.new(@word.left, @word.top - @word.height * 1.2, text)
+    Move.insert(label, :to=>[label.x, -label.height], :delay=>3000, :in=>1000, :mode=>:ease_in_quad, :after=>lambda{remove label})
+    Fade[label, {:to=>:out, :delay=>2500, :mode=>:ease_in_quad}]
+  end
+  
+  def word(text)
+    Fade[@word, {
+      :to=>:out, :in=>500, :delay=>1000,
+      :after=>lambda{@word.text = text; Fade[@word, {:to=>:in}]}
+    }]
+  end
+end

data/lib/lexery/word_control.rb

@@ -0,0 +1,72 @@
+class WordControl < Gosu::TextInput
+  attr_accessor :x, :y
+  attr_accessor :word, :width, :height
+  attr_reader   :command
+  attr_accessor :valid
+  
+  include Positioned
+  
+  CARET_COLOR     = Gosu::Color.new 0x996666FF
+  TEXT_COLOR      = Gosu::Color.new 0x996666FF
+  VALID_COLOR     = Gosu::Color.new 0xCC66DD66
+  INVALID_COLOR   = Gosu::Color.new 0xCCFF6666
+  SELECTION_COLOR = Gosu::Color.new 0x330000FF
+  
+  def initialize(x,y,word)
+    super()
+    
+    @height = 64
+    @font = Game.load_font :default, @height
+    self.word = word
+    self.text = word
+
+    @x = x
+    @y = y
+    
+    Game.window.text_input = self
+  end
+  
+  def text
+    (super || '').downcase
+  end
+      
+  def word= new_word
+    @width = @font.text_width(new_word)
+    @word = new_word
+    @valid = false
+  end
+  
+  def reset
+    self.text = @word
+  end
+   
+  def update
+    
+  end
+  
+  def draw
+    # Calculate the position of the caret and the selection start.
+    pos_x = x + @font.text_width(self.text[0...self.caret_pos])
+    sel_x = x + @font.text_width(self.text[0...self.selection_start])
+    
+    # Draw the selection background, if any; if not, sel_x and pos_x will be
+    # the same value, making this quad empty.
+    Game.window.draw_quad(sel_x, y,          SELECTION_COLOR,
+                      pos_x, y,          SELECTION_COLOR,
+                      sel_x, y + height, SELECTION_COLOR,
+                      pos_x, y + height, SELECTION_COLOR,
+                      Layers::UI)
+    
+    Game.window.draw_line(pos_x, y,          CARET_COLOR,
+                      pos_x, y + height, CARET_COLOR, 
+                      Layers::UI)
+
+    if self.word == self.text
+      color = TEXT_COLOR
+    else
+      color = valid ? VALID_COLOR : INVALID_COLOR
+    end
+    
+    @font.draw(self.text, x , y , Layers::UI, 1, 1, color, :default)
+  end
+end