adamsanderson-lexery 0.1.0

data/lib/exuberant/gosu_support.rb

@@ -0,0 +1,7 @@
+module Gosu
+  class Color
+    def argb_components
+      [self.alpha, self.red, self.green, self.blue]
+    end
+  end
+end

data/lib/exuberant/label.rb

@@ -0,0 +1,40 @@
+class Label
+  attr_accessor :x, :y, :width, :height, :text, :color
+  include Positioned
+  
+  def initialize(x,y, text=nil, options={}, &block)
+    super()
+     if text.is_a?(Hash)
+       options = text
+       text = ''
+     end
+    
+    @x = x
+    @y = y
+    @options = options
+    
+    @height = options[:height]  || 32
+    @font =   options[:font]    || Game.load_font(:default, @height - 4)
+    @width =  options[:width]   || @font.text_width(@text) + 4
+    
+    self.text = text
+    @block = block if block_given?
+    
+    @color = options[:color]    || Gosu::Color.new(0x66666666)
+  end
+  
+  def text= new_text
+    if new_text != @text
+      @text = new_text
+      @width = @font.text_width(@text) + 4 unless @options[:width]
+    end
+  end
+  
+  def update
+    self.text = @block.call if @block
+  end
+  
+  def draw
+    @font.draw(text, x , y , Layers::UI, 1, 1, @color, :default)
+  end
+end

data/lib/exuberant/move.rb

@@ -0,0 +1,37 @@
+class Move < MultiTransition
+  class << self
+    # Shorthand to create and start a move effect
+    def [] object, options={}
+      
+      if options[:to]
+        x,y = options[:to]
+      elsif options[:by]
+        x,y = options[:by]
+        x += object.x
+        y += object.y
+      else 
+        raise ArgumentError,"must specify :to, or :by as an option"
+      end
+      
+      duration = options[:in] || 1000
+      
+      Game.state.add self.new(object, x,y, duration, options)
+    end
+    
+    def insert object, options={}
+      options[:before] = lambda{ Game.state.add(object) }.compose(options[:before])
+      self[object, options]
+    end
+    
+    def remove object, options={}
+      options[:after] = lambda{ Game.state.remove(object) }.compose(options[:after])
+      self[object, options]
+    end
+  end
+  
+  def initialize(object, dest_x,dest_y, duration=1000, options={})
+    super(duration, [object.x, object.y], [dest_x,dest_y], options ){|x,y|
+      object.x, object.y = x,y
+    }
+  end
+end

data/lib/exuberant/multi_transition.rb

@@ -0,0 +1,17 @@
+# Operates on multiple attributes at once
+class MultiTransition < Transition
+  # Initialize with multiple start and end values, store them as a vector
+  def initialize(duration, start_values, end_values, options={}, &action)
+    super(duration, Vector[*start_values], Vector[*end_values], options, &action)
+  end
+  
+  # Compute the change for each value
+  def compute_change(start_values, end_values)
+    (end_values - start_values).map{|v| v.to_f}
+  end
+  
+  # Same as the normal apply, but unpack the vector
+  def apply(t)
+    @action.call(* tweening_function[t, @start_value, @change, @duration])
+  end
+end

data/lib/exuberant/positioned.rb

@@ -0,0 +1,30 @@
+# Expects x,y,width,height
+module Positioned
+  def mouse_within?
+    within? Game.window.mouse_x, Game.window.mouse_y
+  end
+  
+  def top
+    y
+  end
+  
+  def bottom
+    y + height
+  end
+  
+  def left
+    x
+  end
+  
+  def right
+    x + width
+  end
+  
+  def within?(x,y)
+    left    <= x and 
+    top     <= y and
+    right   > x and
+    bottom  > y
+
+  end
+end

data/lib/exuberant/publisher.rb

@@ -0,0 +1,43 @@
+module Publisher
+  Subscriber = Struct.new :subscriber, :block
+  
+  def subscribers
+    @subscribers ||= Hash.new{|h,k| h[k] = [] }
+  end
+  
+  def subscribe(event, subscriber=nil, &block)
+    validate_event! event
+    subscribers[event] << Subscriber.new(subscriber, block)
+  end
+  
+  def unsubscribe(event, subscriber=nil)
+    validate_event! event
+    subscribers[event].delete_if{|s| s.subscriber == subscriber}
+  end
+  
+  def fire_event(event, *args)
+    validate_event! event
+    subscribers[event].each{|sub| sub.block.call(*args)}
+  end
+  
+  def validate_event!(event)
+    raise "No such event '#{event}', should be one of #{self.class.events.inspect}" unless self.class.events.include? event
+  end
+  
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  
+  module ClassMethods
+    def events(*events)
+      @pub_sub_events ||= []
+      if events.empty?
+        inherited_events = superclass.respond_to?(:events) ? superclass.send(:events) : []
+        [@pub_sub_events, inherited_events].flatten
+      else
+        @pub_sub_events.insert(0,*events)
+      end
+      
+    end    
+  end
+end

data/lib/exuberant/support.rb

@@ -0,0 +1,42 @@
+# Ensure that classes are loaded on demand.
+class Module
+  def const_missing(sym)
+    require sym.to_s.underscore
+    c = const_get(sym)
+  end
+end
+
+# String Helper, from ActiveSupport
+class String
+  def underscore
+    self.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+  
+  def get(index)
+    chars[index]
+  end
+  
+  def chars
+    self.split(//)
+  end
+end
+
+class Range
+  def [] index
+    raise ArgumentError.new("Index #{index} must be between 0 and 1") if (index > 1 || index < 0)
+    (self.end - self.begin) * index + self.begin
+  end
+end
+
+class Proc
+  def compose(g)
+    return self if g.nil?
+    lambda { |*args| self[g[*args]] }
+  end
+  def *(g)
+    compose(self, g)
+  end
+end

data/lib/exuberant/timer.rb

@@ -0,0 +1,30 @@
+class Timer
+  include Publisher
+  events :ticked
+  attr_reader :ticks
+  
+  def initialize(period, &action)
+    @period = period
+    @ticks = nil
+    subscribe(:ticked, self, &action) if block_given?
+  end
+  
+  def start
+    @started = Gosu::milliseconds
+  end
+  
+  def stop
+    @started = nil
+  end
+  
+  def update
+    if @started
+      current_ticks = (Gosu::milliseconds - @started) / @period
+      if !@ticks || current_ticks > @ticks
+        @ticks = current_ticks
+        fire_event :ticked, current_ticks
+      end
+    end
+  end
+  
+end

data/lib/exuberant/transition.rb

@@ -0,0 +1,71 @@
+class Transition
+  def initialize(duration, start_value, end_value, options={}, &action)
+    @duration = duration.to_f
+    @start_value = start_value
+    @change = compute_change(start_value, end_value)
+    @options = options
+    
+    @action = action
+    
+    delay = options[:delay] || 0
+    
+    before
+    @starts = Gosu::milliseconds + delay
+  end
+  
+  def before
+    @options[:before].call if @options[:before]
+  end
+  
+  def after
+    @options[:after].call if @options[:after]
+    Game.state.remove self
+  end
+  
+  def tweening_function
+    return @function if @function
+    
+    if @options[:mode].is_a? Symbol
+      @function = TWEEN_FUNCTIONS[@options[:mode]]
+    else
+      @function = @options[:mode] || TWEEN_FUNCTIONS.default
+    end
+
+    @function
+  end
+  
+  def compute_change(start_value, end_value)
+    start_value.to_f - end_value.to_f
+  end
+  
+  def update
+    t =  (Gosu::milliseconds - @starts)
+    
+    if t >= @duration
+      after
+    elsif t >= 0
+      apply(t)
+    end
+  end
+  
+  def apply(t)
+    @action.call(tweening_function[t, @start_value, @change, @duration])
+  end
+  
+  # Tweening functions; as per Robert Penner
+  #  http://www.robertpenner.com/easing/penner_chapter7_tweening.pdf
+  # t: time
+  # b: beginning
+  # c: change
+  # d: duration
+  TWEEN_FUNCTIONS={
+    :linear_tween =>  lambda{|t, b, c, d| c*(t/d) + b},
+    :ease_in_quad =>  lambda{|t, b, c, d| c*(t/=d)*t + b},
+    :ease_out_quad => lambda{|t, b, c, d| c * (t/=d)*(t-2)*-1 + b},
+    :ease_in_quart => lambda{|t, b, c, d| c * ((t/d) ** 4) + b},
+    :ease_out_quart =>lambda{|t, b, c, d| c * ((t/d-1) ** 4)*-1 -1 + b},
+    :ease_in_sine =>  lambda{|t, b, c, d| c * (1 - Math.cos(t/d * (Math::PI/2))) + b},
+    :ease_out_sine => lambda{|t, b, c, d| c * Math.sin(t/d * (Math::PI/2)) + b}
+  }
+  TWEEN_FUNCTIONS.default = TWEEN_FUNCTIONS[:linear_tween]
+end

data/lib/lexery.rb

@@ -0,0 +1,11 @@
+GAME_ROOT = File.join(File.dirname(__FILE__),'..')
+
+require 'rubygems'
+require 'gosu'
+require 'matrix' # used in multi_transition
+require 'set'
+
+$LOAD_PATH << File.join(GAME_ROOT,'lib','lexery')
+$LOAD_PATH << File.join(GAME_ROOT,'lib','exuberant')
+require 'support'
+require 'gosu_support'

data/lib/lexery/colors.rb

@@ -0,0 +1,9 @@
+module Colors
+  HEADER =  Gosu::Color.new(0x666666FF)
+  WARNING = Gosu::Color.new(128, 255,0,0)
+  FADED =   Gosu::Color.new(96, 128, 128, 128)
+  FADED_WARNING = Gosu::Color.new(96, 128, 0, 0)
+  
+  BACKGROUND_TOP    = Gosu::Color.new(255, 255, 255, 255)
+  BACKGROUND_BOTTOM = Gosu::Color.new(255, 200, 200, 255)
+end

data/lib/lexery/dictionary.rb

@@ -0,0 +1,14 @@
+class Dictionary
+  def initialize(path)
+    @words = Marshal.load(File.read(path))
+  end
+  
+  def valid_word?(word)
+    @words.include? word.downcase
+  end
+  
+  def pick(length=5)
+    candidates = @words.select{|w| w.length == length }
+    candidates[ rand(candidates.length) ]
+  end
+end

data/lib/lexery/fading_message.rb

@@ -0,0 +1,22 @@
+class FadingMessage < Label
+  def initialize(x,y, text, options={})
+    super(x,y, text, options)
+    
+    @start_y    = self.y
+    @target_y   = 0 - self.height
+    @base_color = self.color
+    
+    Game.state.add MultiTransition.new(3000, [@start_y, 255], [@target_y, 0],
+      :mode=>options[:mode], 
+      :after=>lambda{Game.state.remove self}
+      ){|y, alpha|
+          self.color = Gosu::Color.new(
+            alpha.to_i, 
+            @base_color.red,
+            @base_color.green,
+            @base_color.blue
+          )
+        self.y = y
+    }
+  end
+end

data/lib/lexery/fps_counter.rb

@@ -0,0 +1,19 @@
+class FpsCounter
+  attr_reader :fps
+  
+  def initialize
+    @current_second = Gosu::milliseconds / 1000
+    @accum_fps = 0
+    @fps = 0
+  end
+  
+  def register_tick
+    @accum_fps += 1
+    current_second = Gosu::milliseconds / 1000
+    if current_second != @current_second
+      @current_second = current_second
+      @fps = @accum_fps
+      @accum_fps = 0
+    end
+  end
+end

data/lib/lexery/game.rb

@@ -0,0 +1,32 @@
+class Game < ExuberantGame
+  class << self
+    def options_set
+      @options_set ||= 'short game'
+    end
+  
+    def all_options
+      @options ||= YAML.load_file(File.join(GAME_ROOT, 'options.yml'))
+    end
+  
+    def options
+      all_options[options_set]
+    end
+    
+    def dictionary
+      @dictionary ||= begin
+        path = File.join(GAME_ROOT, 'wordlists', 'words.set')
+        Dictionary.new(path)
+      end
+    end
+    
+    def score_board
+      @score_board ||= begin
+        locations = [File.join(GAME_ROOT, 'scores'), File.join(ENV['HOME'],'.lexery_scores')]
+        # find a place where we can write the scores to
+        path = locations.find{|p| File.writable?(File.dirname(p))}
+        ScoreBoard.new(path)
+      end
+    end
+    
+  end
+end