yeah 0.2.2 → 0.3.3

data/lib/yeah/_platform/ticker.rb

@@ -0,0 +1,21 @@
+module Yeah
+
+# The `Ticker` provides a way to start a game loop.
+# @example Print elapsed time between each tick
+#   Ticker.new.on_tick { |elapsed| puts elapsed }
+# @abstract Provided by a `Platform`.
+class Ticker
+  # @param [Hash] options for new object
+  # @option options [Numeric] :rate (60) at ticks per second
+  def initialize(options = {})
+    raise NotImplementedError
+  end
+
+  # @!attribute [r] rate
+  # @return [Numeric] ticks per second intended
+
+  # @!method on_tick
+  # @yield [elapsed] block to execute per tick
+  # @yieldparam [Numeric] elapsed time since last tick
+end
+end

data/lib/yeah/_template/Gemfile

@@ -0,0 +1,4 @@
+source 'http://rubygems.org'
+
+gem 'yeah', '~> 0.3.3'
+gem 'opal', github: 'opal/opal', ref: '7e843b0'

data/lib/yeah/_template/code/code.rb

@@ -0,0 +1,4 @@
+# Entry point
+# Specify dependencies and game code require order here.
+
+require 'game'

data/lib/yeah/_template/code/game.rb

@@ -0,0 +1,7 @@
+class NewGame < Game
+  def setup
+  end
+
+  def update(elapsed)
+  end
+end

data/lib/yeah/_web.rb

@@ -0,0 +1,9 @@
+module Yeah
+
+# `Web`, through [Opal](http://opalrb.org/), compiles and runs Yeah games on
+# the web.
+#
+# The `Display` is powered by HTML Canvas.
+module Web
+end
+end

data/lib/yeah/color.rb

@@ -1,25 +1,57 @@
-# Color.
-class Yeah::Color
-  # @!attribute rgba_bytes
-  #   @return [Array<(Integer, Integer, Integer, Integer)>] red, green, blue,
-  #     alpha bytes
-  attr_accessor :rgba_bytes
+module Yeah
 
+# A `Color` represents a color.
+#
+# `C` is an alias for `Color`.
+# @example Comparing two colors
+#   C[100, 100, 100] == C['#646464']
+#   # => true
+class Color
   class << self
-    alias_method :[], :new
+    # @param arguments catch-all
+    # @return [Vector]
+    # Alias for ::new.
+    def [](*args)
+      new(*args)
+    end
   end
 
-  def initialize(*values)
-    default_values = [0, 0, 0, 255]
-    values += default_values[values.size..-1]
-    @rgba_bytes = values
+  # @return [Array] color value in RGB format
+  attr_reader :value
+
+  # @overload initialize(red, green, blue)
+  #   @param [Numeric] red value, from 0 to 255
+  #   @param [Numeric] green value, from 0 to 255
+  #   @param [Numeric] blue value, from 0 to 255
+  # @overload initialize(hex_string)
+  #   @param [String] hex string in '#dadada' or '#fff' format
+  def initialize(*args)
+    if args[0].respond_to?(:[]) && args[0][0] == '#' # hex string
+      if args[0].length == 4 # short hex
+        @value = args[0][1..3].chars.map { |h| "#{h}#{h}".to_i(16) }
+      else # normal hex
+        @value = args[0][1..6].scan(/../).map { |h| h.to_i(16) }
+      end
+    else
+      @value = args
+    end
   end
 
+  # @return [String] readable representation
   def inspect
-    "#{self.class.name}[#{rgba_bytes.join(', ')}]"
+    "#{self.class.name}#{value.to_s}"
   end
 
+  # @return [Boolean] whether self matches other color
   def ==(other)
-    self.class == other.class && @rgba_bytes == other.rgba_bytes
+    value == other.value
+  end
+
+  # @return [String] color value as a hex string
+  def to_hex
+    "##{value.map { |v| v.to_s(16).rjust(2, '0') }.join }"
   end
 end
+end
+
+Yeah::C = Yeah::Color

data/lib/yeah/constants.rb

@@ -0,0 +1,6 @@
+module Yeah
+  DEFAULT_DISPLAY_SIZE = V[1280, 720]
+  DEFAULT_DISPLAY_FONT_FAMILY = 'DejaVu Serif'
+  DEFAULT_DISPLAY_FONT_SIZE = 36
+  DEFAULT_TICKER_RATE = 60
+end

data/lib/yeah/game.rb

@@ -1,54 +1,102 @@
-# Manages entities.
-class Yeah::Game
-  # @!attribute resolution
-  #   @return [Vector] size of screen
-  # @!attribute screen
-  #   @return [Surface] visual render
-  # @!attribute [r] platform
-  #   @return [Platform] underlying platform bindings
-  # @!attribute entities
-  #   @return [Array] active entities
-  attr_accessor :resolution, :screen
-  attr_reader :entities, :platform
-
-  def initialize
-    @resolution = V[320, 180]
-    @screen = Surface.new(@resolution)
-    @platform = Desktop.new
-    @entities = []
-  end
+module Yeah
+
+# A `Game` is subclassed to create the core of a game project.
+#
+# A project's `Game` is instantiated at runtime. Its {#setup} is called one
+# time, then {#update} is called repeatedly.
+#
+# I/O objects are provided and can be used to build a modern video game.
+# @abstract Subclass this to make a game.
+class Game
+  class << self
+    # @param [Hash] configuration used for new game instances
+    # @option configuration [Hash] :ticker options
+    # @option configuration [Hash] :display options
+    # @option configuration [Hash] :keyboard options
+    # @option configuration [Hash] :mouse options
+    # @return [Hash] configuration for new game instances
+    def config
+      @config ||= {
+        ticker: {},
+        display: {},
+        keyboard: {},
+        mouse: {}
+      }
+    end
+
+    # @return [Game] default subclass (i.e. project game)
+    def default
+      subclasses.last
+    end
 
-  # Start the game loop.
-  def start
-    platform.each_tick do
-      update
-      draw
-      break if @stopped
+    private
+
+    def inherited(klass)
+      subclasses << klass
+
+      super
     end
+
+    def subclasses
+      @@subclasses ||= []
+    end
+  end
+
+  # @return [Ticker] ticker used for game loop and one-shot input
+  attr_reader :ticker
+
+  # @return [Display] display for drawing
+  attr_reader :display
+
+  # @return [Keyboard] keyboard input
+  attr_reader :keyboard
+
+  # @return [Mouse] mouse input
+  attr_reader :mouse
+
+  # @param [Hash] options
+  # @option options [Ticker] :ticker
+  # @option options [Display] :display
+  # @option options [Keyboard] :keyboard
+  # @option options [Mouse] :mouse
+  def initialize(options = {})
+    options = defaults.merge(options)
+    @ticker = options[:ticker]
+    @display = options[:display]
+    @keyboard = options[:keyboard]
+    @mouse = options[:mouse]
+
+    setup
+
+    @ticker.on_tick { |e| update(e) }
   end
 
-  # Stop the game loop.
-  def stop
-    @stopped = true
+  # @abstract
+  # Setup game at start.
+  def setup
   end
 
-  def entities=(value)
-    @entities = value
-    @entities.each { |e| e.game = self }
+  # @param [Numeric] elapsed time since last update
+  # @abstract
+  # Update game on tick.
+  def update(elapsed)
   end
 
-  protected
+  private
 
-  def update
-    @entities.each { |e| e.update }
+  def config
+    self.class.config
   end
 
-  def draw
-    screen.fill(Color[0, 0, 0, 0])
-    @entities.each do |entity|
-      surface = entity.draw
-      screen.draw(surface, entity.position) unless surface.nil?
-    end
-    platform.render(screen)
+  def defaults
+    ticker = Ticker.new(config[:ticker])
+
+    {
+      ticker: ticker,
+      display: Display.new(config[:display]),
+      keyboard: Keyboard.new({ ticker: ticker }.merge(config[:keyboard])),
+      mouse: Mouse.new({ ticker: ticker }.merge(config[:mouse]))
+    }
   end
 end
+end

data/lib/yeah/vector.rb

@@ -1,137 +1,160 @@
-# Three-dimensional geometric vector. Used as position or size.
-class Yeah::Vector
-  # @!attribute components
-  #   @return [Array<(Numeric, Numeric, Numeric)>]
-  # @!attribute [r] to_a
-  #   @see components
-  # @!attribute []
-  #   @param [Integer] *n* of component
-  #   @return [Numeric] *n*th component
-  attr_reader :components
-  alias_method :to_a, :components
+require 'forwardable'
+
+module Yeah
+
+# The `Vector` represents a mathematical vector. It can be used to describe
+# a position, velocity or direction.
+#
+# `V` is an alias for `Vector`.
+#
+# @example Basic vector math
+#   V[5, 5] + V[10, 20]
+#   # => Yeah::Vector[15, 25, 0]
+#
+#   V[3, 6, 9] / 3
+#   # => Yeah::Vector[1, 2, 3]
+class Vector
+  extend Forwardable
 
-  def self.random(*component_maxes)
-    components = component_maxes.map { |cm| Random.rand(cm) }
-    self.new(*components)
+  class << self
+    # @param arguments catch-all
+    # @return [Vector]
+    # Alias for ::new.
+    def [](*args)
+      new(*args)
+    end
   end
 
-  def initialize(*components)
-    if components.size > 3
-      error_message = "too many arguments (#{components.size} for up to 3)"
-      raise ArgumentError, error_message
-    end
+  # @return [Array] vector components
+  attr_accessor :components
 
-    self.components = components
+  # @!attribute []
+  # @return [Numeric] *n*th component value
+  def_delegators :@components, :[]
+
+  # @param [Numeric] first component, defaults to 0
+  # @param [Numeric] second component, defaults to 0
+  # @param [Numeric] third component, defaults to 0
+  def initialize(*components)
+    @components = components + [0] * (3 - components.size)
   end
 
+  # @return [String] readable representation
   def inspect
-    "#{self.class.name}[#{components.join(', ')}]"
+    "#{self.class.name}#{@components.to_s}"
   end
 
-  def components=(values)
-    if values.size > 3
-      error_message = "too many elements (#{values.size} for up to 3)"
-      raise ArgumentError, error_message
-    end
+  # @!attribute x
+  # @param [Numeric] first component value
+  # @return [Numeric] first component value
 
-    @components = values + [0] * (3 - values.size)
-  end
+  # @!attribute y
+  # @param [Numeric] second component value
+  # @return [Numeric] second component value
 
-  class << self
-    alias_method :[], :new
-
-    def define_component_helpers
-      component_name_sets = [[:x, :width], [:y, :height], [:z, :depth]]
-      component_name_sets.each_with_index do |set, ci|
-        set.each do |name|
-          define_method(name) { @components[ci] }
-          define_method("#{name}=") { |val| @components[ci] = val }
-        end
-      end
-    end
+  # @!attribute z
+  # @param [Numeric] third component value
+  # @return [Numeric] third component value
+  %i[x y z].each_with_index do |component, i|
+    define_method(component) { @components[i] }
+    define_method("#{component}=") { |v| @components[i] = v }
   end
 
-  define_component_helpers
+  # @return [Numeric] vector's length
+  def length
+    Math.sqrt(@components[0] ** 2 + @components[1] ** 2 + @components[2] ** 2)
+  end
 
-  def ==(other)
-    other.class == self.class && @components == other.components ? true : false
+  # @return [Vector] vector of same direction whose length is 1
+  def normalize
+    self / magnitude
   end
 
-  def [](index)
-    @components[index]
+  # @param [Vector] vector to add
+  # @return [Vector] vector added into other vector
+  def +(vector)
+    self.class.new(*
+      [@components, vector.components].transpose.map { |cc|
+        cc.reduce(:+) })
   end
 
-  def []=(index, value)
-    @components[index] = value
+  # @param [Vector] vector to subtract
+  # @return [Vector] vector from which other vector was subtracted
+  def -(vector)
+    self.class.new(*
+      [@components, vector.components].transpose.map { |cc|
+        cc.reduce(:-) })
   end
 
-  def +(addend)
-    case addend
-    when self.class
-      comp_addends = addend.components
-    when Numeric
-      comp_addends = [addend] * 3
-    end
-    components = @components.zip(comp_addends).map { |c| c.reduce(:+) }
+  # @param [Numeric] numeric value to multiply vector
+  # @return [Vector] vector multiplied by a numeric value
+  def *(numeric)
+    self.class.new(*@components.map { |c| c * numeric })
+  end
 
-    self.class[*components]
+  # @param [Numeric] numeric value to divide vector
+  # @return [Vector] vector divided by a numeric value
+  def /(numeric)
+    self.class.new(*@components.map { |c| c / numeric })
   end
 
-  def -(subtrahend)
-    case subtrahend
-    when self.class
-      comp_subtrahends = subtrahend.components
-    when Numeric
-      comp_subtrahends = [subtrahend] * 3
-    end
-    components = @components.zip(comp_subtrahends).map { |c| c.reduce(:-)}
+  # @return [Vector] identical vector
+  def +@
+    self.class.new(*@components)
+  end
 
-    self.class[*components]
+  # @return [Vector] negative vector
+  def -@
+    self.class.new(*@components.map(&:-@))
   end
 
-  def *(multiple)
-    case multiple
-    when self.class
-      comp_multiples = multiple.components
-    when Numeric
-      comp_multiples = [multiple] * 3
-    end
+  # @param [Vector] position
+  # @return [Numeric] distance to a position
+  def distance_to(position)
+    Math.sqrt((x - position.x) ** 2 +
+              (y - position.y) ** 2 +
+              (z - position.z) ** 2)
+  end
 
-    components = @components.zip(comp_multiples).map { |c| c.reduce(:*) }
-    self.class[*components]
+  # @param [Vector] position
+  # @return [Numeric] angle to 2D position, in radians
+  def angle_to(position)
+    diff = position - self
+    Math.atan2(diff.y, diff.x)
   end
 
-  def /(divisor)
-    case divisor
-    when self.class
-      comp_divisors = divisor.components
-    when Numeric
-      comp_divisors = [divisor] * 3
-    end
+  # @param [Numeric] angle to move along, in radians
+  # @param [Numeric] distance to move
+  # @return [Vector] position moved along an angle for a distance in 2D
+  def along(angle, distance)
+    self.class.new(x + Math.cos(angle) * distance,
+                   y + Math.sin(angle) * distance)
+  end
 
-    components = @components.zip(comp_divisors).map { |c| c.reduce(:/) }
-    self.class[*components]
+  # @param (see #along)
+  # @return [Vector] self after moving along an angle for a distance in 2D
+  def along!(angle, distance)
+    self.x += Math.cos(angle) * distance
+    self.y += Math.sin(angle) * distance
+    self
   end
 
-  # @return [Numeric]
-  def magnitude
-    Math.sqrt(@components.reduce(0) { |m, c| m + c*c })
+  # @param [Vector] position to move to
+  # @param [Vector] distance to move
+  # @return [Vector] position moved toward other position for a distance in 2D
+  # @todo Make work in 3D.
+  def toward(position, distance)
+    along angle_to(position), amount
   end
-  # @!attribute length
-  #   @see magnitude
-  # @!attribute distance
-  #   @see magnitude
-  # @!attribute speed
-  #   @see magnitude
-  alias_method :length, :magnitude
-  alias_method :distance, :magnitude
-  alias_method :speed, :magnitude
 
-  # Reset every component to 0.
-  def reset
-    @components = [0, 0, 0]
+  # @param (see #toward)
+  # @return [Vector] self after moving toward other position for a distance in
+  #   2D
+  # @todo Make work in 3D.
+  def toward!(position, amount)
+    along! angle_to(position), amount
   end
 end
+end
 
-# Shorthand for Vector.
 Yeah::V = Yeah::Vector