yeah 0.2.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d01dc8962df50d909356224581bb6c5e566991f5
-  data.tar.gz: 789fa6d989ad7422f05e1b13fd1c2bea2718c128
+  metadata.gz: 3ca889c593c853c056b2945402f87240a708abc3
+  data.tar.gz: 1a215b41c68cf68ff4ead5d5a77589dcfc2f92c4
 SHA512:
-  metadata.gz: a0ae07e88b7f9334db886be3caf5497d95528bdeaa69eb82ed24a56885f04426088e1878758732afd0ca33d4d327a640fe30fa38ed156f7ff425591717600ef9
-  data.tar.gz: 82e2bdb785e40f172378eeafc06e6c091ec0769fd06e7e8cd64a1806270526e3d18f811e50720efadd816617f73875d6d9f8d62f1702ceea84c4131dd626959b
+  metadata.gz: c4d99208cb6cbd3f8e86b37f4dcb0b7492233d4a3879cf1cd00fca8662306bcf5c4302c8a9c877c56cf7b81dd89b300f59b57343fb50f1d9fa8c2f9442c7ee83
+  data.tar.gz: 172905029424fa4dbad2bd7b9db2b892a4f963a14c9d72ddc4645506124996ee46c4ce96d84bb7ec1fe4b38a7674bfddfcf77e7bbf4d0864d60f3eb943979c2e

data/CHANGELOG.md

@@ -1,7 +1,28 @@
-## 0.1.0 [2013-09-05]
-* Added basic Vector, Entity and Game classes.
+## 0.2.3 [pend]
+* Yemo demo
+
+## 0.2.2 [2013-11-12]
+* Shootguy -> Vyzer
+* Expanded and revised Vyzer demo
+* Optimized drawing
+* Input interface
+* Entity-Game relationship
+* Entity subpositions and basic collision detection
+* 16:9 default resolution
+* Basic Map API
+* Vector V shorthand
+* Misc.
+
+## 0.2.1 [2013-10-18]
+* Shootguy demo/API model
+* Cleanup
+* Documentation
+* Misc.
 
 ## 0.2.0 [2013-09-21]
 * Added Color, Surface, Rectangle, Map and Desktop classes.
 * Extended Vector, Entity and Game classes.
 * Added Happy Rectangle demo.
+
+## 0.1.0 [2013-09-05]
+* Added basic Vector, Entity and Game classes.

data/README.md

@@ -1,8 +1,8 @@
 Yeah
 ====
-A Ruby video game framework that prioritizes happiness and agility over raw performance.
+An early-stage Ruby video game framework that optimizes for development efficiency.
 
-> Premature optimization is the root of all evil. - Donald Knuth
+It is in very early stages, but at version 0.3.0 the Vyzer demo should be functional. Any version below 1.0.0 is unstable and lacks backward compatibility.
 
 Planned features
 ----------------
@@ -10,3 +10,11 @@ Planned features
 * Command line initialization script to help one hit the ground running.
 * Graphical tools for creating video game resources like sprites and maps.
 * Multiple target platforms, starting with desktop and web.
+
+Installation
+------------
+Install with `gem install yeah`. Yeah depends on Rubygame, which depends on SDL; see [these guides](https://github.com/rubygame/rubygame/wiki/Install).
+
+Blog
+----
+[Why am I making Yeah?](http://skofo.github.io/blog/why-am-i-making-yeah)

data/lib/monkey/numeric.rb

@@ -0,0 +1,6 @@
+class Numeric
+  def limit(value)
+    sign_mult = self <=> 0
+    self.abs > value.abs ? value * sign_mult : self
+  end
+end

data/lib/yeah/basic_physics.rb

@@ -0,0 +1,11 @@
+module Yeah::BasicPhysics
+  attr_writer :velocity
+
+  def velocity
+    @velocity ||= V[0, 0, 0]
+  end
+
+  def move
+    self.position += @velocity
+  end
+end

data/lib/yeah/color.rb

@@ -1,22 +1,25 @@
+# Color.
 class Yeah::Color
+  # @!attribute rgba_bytes
+  #   @return [Array<(Integer, Integer, Integer, Integer)>] red, green, blue,
+  #     alpha bytes
   attr_accessor :rgba_bytes
 
   class << self
     alias_method :[], :new
   end
 
-  def initialize(*arguments)
-    arguments = [0, 0, 0, 255] if arguments.empty?
+  def initialize(*values)
+    default_values = [0, 0, 0, 255]
+    values += default_values[values.size..-1]
+    @rgba_bytes = values
+  end
 
-    case arguments[0]
-    when Numeric
-      @rgba_bytes = [*arguments]
-    when Array
-      @rgba_bytes = arguments[0]
-    end
+  def inspect
+    "#{self.class.name}[#{rgba_bytes.join(', ')}]"
   end
 
   def ==(other)
-    self.class == other.class && @rgba_bytes == other.rgba_bytes ? true : false
+    self.class == other.class && @rgba_bytes == other.rgba_bytes
   end
 end

data/lib/yeah/desktop.rb

@@ -1,12 +1,25 @@
 require 'rubygame'
 
+# Bindings to the native desktop powered by Rubygame.
 class Yeah::Desktop
+  # @!attribute [r] screen
+  #   @return [Rubygame::Screen]
+  # @!attribute resolution
+  #   @return [Vector] size of game window
+  # @!attribute tickrate
+  #   @return [Integer] target ticks per second
   attr_reader :screen, :resolution, :tickrate
 
-  def initialize(resolution=Vector[320, 240])
+  def initialize(resolution=V[320, 180])
     self.resolution = resolution
+
     @clock = Rubygame::Clock.new
     self.tickrate = 30
+
+    @pressables = {}
+    pressables_keys = [(:a..:z).to_a, (:A..:Z).to_a, (0..9).to_a,
+                       :up, :down, :left, :right].flatten
+    pressables_keys.each { |pk| @pressables[pk] = false }
   end
 
   def resolution=(value)
@@ -14,21 +27,46 @@ class Yeah::Desktop
     @resolution = value
   end
 
-  def render(surface)
-    struct = screen.send(:struct)
-    struct.pixels.write_string(surface.data(:bgra), surface.data.length)
-    screen.update
-  end
-
   def tickrate=(value)
     @clock.target_framerate = value
     @tickrate = value
   end
 
+  # Project a surface onto screen.
+  # @param [Surface]
+  def render(surface)
+    masks = [0x0000ff,  0x00ff00,  0xff0000, 0]
+    rg_surface = Rubygame::Surface.new(surface.size.to_a[0..1], masks: masks)
+    rg_surface.pixels = surface.data
+    rg_surface.blit(screen, [0, 0])
+    screen.update
+  end
+
+  # Execute passed block on each tick.
+  # @yield
   def each_tick
     loop do
       yield
       @clock.tick
     end
   end
+
+  # Press a key or button.
+  # @param [Symbol|Integer] key or button
+  def press(pressable)
+    @pressables[pressable] = true
+  end
+
+  # Release a key or button.
+  # @param [Symbol|Integer] key or button
+  def release(pressable)
+    @pressables[pressable] = false
+  end
+
+  # Is a key or button being pressed?
+  # @param [Symbol|Integer] key or button
+  def pressing?(*pressables)
+    raise ArgumentError if pressables.empty?
+    pressables.any? { |p| @pressables[p] }
+  end
 end

data/lib/yeah/entity.rb

@@ -1,35 +1,137 @@
+# Game object.
 class Yeah::Entity
-  attr_accessor :position, :visual
+  # @!attribute position
+  #   @return [Vector] position within a game
+  # @!attribute size
+  #   @return [NilClass|Vector] visual size
+  # @!attribute state
+  #   @return [Symbol] state in game
+  # @!attribute visual
+  #   @return [Visual] visual representation within a game
+  # @!attribute game
+  #   @return [Game] game to which this belongs to
+  attr_accessor :position, :state, :visual
+  attr_reader :game
+  attr_writer :size
 
-  def initialize(position=Vector[])
+  def initialize(position=V[])
     @position = position
   end
 
-  def x
-    @position.x
+  class << self
+    def define_position_helpers
+      %w(x y z).each_with_index do |coord, i|
+        define_method(coord) { @position[i] }
+        define_method("#{coord}=") { |val| @position[i] = val }
+      end
+    end
   end
 
-  def x=(value)
-    @position.x = value
+  def size
+    @size || visual && visual.size || V[]
   end
 
-  def y
-    @position.y
+  def game=(value)
+    @game = value
+    @game.entities << self unless @game.entities.include? self
   end
 
-  def y=(value)
-    @position.y = value
+  # @!attribute x
+  #   @return [Vector] position.x
+  # @!attribute y
+  #   @return [Vector] position.y
+  # @!attribute z
+  #   @return [Vector] position.z
+  define_position_helpers
+
+  # Update entity.
+  def update
   end
 
-  def z
-    @position.z
+  # Get visual representation from visual.
+  #   @return [Surface] visual representation
+  def draw
+    visual.draw if visual
   end
 
-  def z=(value)
-    @position.z = value
+  def pressing?(pressable)
+    game.pressing? pressable
   end
 
-  def draw
-    visual.draw if visual
+  def control(attrName, input, value)
+    if input.class == Array
+      polarity = 0
+      polarity += 1 if game.platform.pressing?(input.first)
+      polarity -= 1 if game.platform.pressing?(input.last)
+    else
+      polarity = game.platform.pressing?(input) ? 1 : -1
+    end
+
+    self.instance_eval("#{attrName} += #{value} * #{polarity}")
+  end
+
+  # X of right edge.
+  #   @return [Integer]
+  def right
+    position.x + size.x
+  end
+
+  # X of left edge.
+  #   @return [Integer]
+  def left
+    position.x
+  end
+
+  # Y of top edge.
+  #   @return [Integer]
+  def top
+    position.y + size.y
+  end
+
+  # Y of bottom edge.
+  #   @return [Integer]
+  def bottom
+    position.y
+  end
+
+  # Z of front edge.
+  #   @return [Integer]
+  def front
+    position.z + size.z
+  end
+
+  # Z of back edge.
+  #   @return [Integer]
+  def back
+    position.z
+  end
+
+  # Coordinate of center.
+  #   @return [Vector]
+  def center
+    position + size / 2
+  end
+
+  # Is intersected with other entity or entity of subclass?
+  #   @return [Boolean]
+  def touching?(other)
+    return false if other == self
+
+    if other.is_a?(Class)
+      if game
+        return game.entities.select { |e| e.is_a? other }
+                            .any? { |e| touching? e }
+      else
+        return false
+      end
+    end
+
+    return false if size == V[] || other.size == V[]
+
+    not_touching_x = left > other.right || right < other.left
+    not_touching_y = bottom > other.top || top < other.bottom
+    not_touching_z = back > other.front || front < other.back
+
+    !(not_touching_x && not_touching_y && not_touching_z)
   end
 end

data/lib/yeah/game.rb

@@ -1,13 +1,44 @@
+# Manages entities.
 class Yeah::Game
-  attr_accessor :entities, :screen, :platform, :resolution
+  # @!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 = Vector[320, 240]
+    @resolution = V[320, 180]
     @screen = Surface.new(@resolution)
     @platform = Desktop.new
     @entities = []
   end
 
+  # Start the game loop.
+  def start
+    platform.each_tick do
+      update
+      draw
+      break if @stopped
+    end
+  end
+
+  # Stop the game loop.
+  def stop
+    @stopped = true
+  end
+
+  def entities=(value)
+    @entities = value
+    @entities.each { |e| e.game = self }
+  end
+
+  protected
+
   def update
     @entities.each { |e| e.update }
   end
@@ -20,11 +51,4 @@ class Yeah::Game
     end
     platform.render(screen)
   end
-
-  def start
-    platform.each_tick do
-      update
-      draw
-    end
-  end
 end

data/lib/yeah/map.rb

@@ -1,7 +1,40 @@
+# A map of entities for a Game.
 class Yeah::Map
-  attr_accessor :background
+  # @!attribute background
+  #   @return [Color] background color
+  # @!attribute key
+  #   @return [Hash] tile key
+  # @!attribute tile_size
+  #   @return [Vector] size of each character in #tiles
+  # @!attribute tiles
+  #   @return [Array<String>] entities at relative positions
+  attr_accessor :background, :key, :tile_size, :tiles
+
+  def self.background(background)
+    @@background = background
+  end
+
+  def self.key(key)
+    @@key = key
+  end
+
+  def self.tile_size(tile_size)
+    @@tile_size = tile_size
+  end
+
+  def self.tiles(tiles)
+    @@tiles = tiles
+  end
 
   def initialize
-    @background = Color[]
+    @background = @@background || Color[]
+    @key = @@key ||= {}
+    @tile_size = @@tile_size ||= nil
+    @tiles = @@tiles ||= []
+  end
+
+  def key=(key)
+    @key = key
+    self.tile_size = @key.first.last.new.size if @key.first && tile_size.nil?
   end
 end

data/lib/yeah/rectangle.rb

@@ -1,11 +1,18 @@
+# Colored rectangle Visual.
 class Yeah::Rectangle
+  # @!attribute size
+  #   @return [Vector]
+  # @!attribute color
+  #   @return [Color]
   attr_accessor :size, :color
 
-  def initialize(size=Vector[], color=Color[*[255]*4])
+  def initialize(size=V[], color=Color[*[255]*4])
     @size = size
     @color = color
   end
 
+  # Surface representation.
+  # @return [Surface]
   def draw
     surface = Surface.new(size)
     surface.fill(color)

data/lib/yeah/surface.rb

@@ -1,8 +1,14 @@
+# Rectangular pixel data.
 class Yeah::Surface
+  # @!attribute size
+  #   @return [Vector]
+  # @!attribute data
+  #   @param [Symbol] color byte order (:rgba or :bgra)
+  #   @return [String] pixel data as string of bytes
   attr_reader :size
-  attr_writer :data
+  attr_accessor :data
 
-  def initialize(size=Vector[])
+  def initialize(size=V[])
     self.size = size
   end
 
@@ -11,15 +17,9 @@ class Yeah::Surface
     @data = "\x00" * 4 * size.x * size.y
   end
 
-  def data(format=:rgba)
-    case format
-    when :rgba
-      @data
-    when :bgra
-      @data.scan(/.{4}/).map { |p| p[2] + p[1] + p[0] + p[3] }.join
-    end
-  end
-
+  # Color of pixel at a position.
+  # @param [Vector] position of pixel
+  # @return [Color]
   def color_at(position)
     data_lines = data.scan(/.{#{size.x*4}}/)
     line = data_lines[position.y]
@@ -29,7 +29,11 @@ class Yeah::Surface
     Color[*color_bytes]
   end
 
-  def fill(color, position1=Vector[0, 0], position2=size-1)
+  # Fill a rectangular area with a color.
+  # @param [Color] fill color
+  # @param [Vector] position of first corner
+  # @param [Vector] position of other corner
+  def fill(color, position1=V[0, 0], position2=size-1)
     color_byte_string = color.rgba_bytes.pack('C*')
     data_lines = data.scan(/.{#{size.x*4}}/)
 
@@ -43,7 +47,10 @@ class Yeah::Surface
     @data = data_lines.join
   end
 
-  def draw(surface, position=Vector[0, 0])
+  # Draw onto other surface.
+  # @param [Surface] surface to draw on
+  # @param [Vector] position to draw on other surface
+  def draw(surface, position=V[0, 0])
     data_lines = data.scan(/.{#{size.x*4}}/)
     surface_data_lines = surface.data.scan(/.{#{surface.size.x*4}}/)
 

data/lib/yeah/vector.rb

@@ -1,6 +1,18 @@
+# Three-dimensional geometric vector. Used as position or size.
 class Yeah::Vector
-  class << self
-    alias_method :[], :new
+  # @!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
+
+  def self.random(*component_maxes)
+    components = component_maxes.map { |cm| Random.rand(cm) }
+    self.new(*components)
   end
 
   def initialize(*components)
@@ -12,8 +24,8 @@ class Yeah::Vector
     self.components = components
   end
 
-  def components
-    @components
+  def inspect
+    "#{self.class.name}[#{components.join(', ')}]"
   end
 
   def components=(values)
@@ -25,6 +37,22 @@ class Yeah::Vector
     @components = values + [0] * (3 - values.size)
   end
 
+  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
+  end
+
+  define_component_helpers
+
   def ==(other)
     other.class == self.class && @components == other.components ? true : false
   end
@@ -85,46 +113,25 @@ class Yeah::Vector
     self.class[*components]
   end
 
-  def x
-    @components[0]
-  end
-  alias_method :width, :x
-
-  def y
-    @components[1]
-  end
-  alias_method :height, :y
-
-  def z
-    @components[2]
-  end
-  alias_method :depth, :z
-
-  def x=(value)
-    @components[0] = value
-  end
-  alias_method :width=, :x=
-
-  def y=(value)
-    @components[1] = value
-  end
-  alias_method :height=, :y=
-
-  def z=(value)
-    @components[2] = value
-  end
-  alias_method :depth=, :z=
-
-  def norm
+  # @return [Numeric]
+  def magnitude
     Math.sqrt(@components.reduce(0) { |m, c| m + c*c })
   end
-  alias_method :magnitude, :norm
-  alias_method :length, :norm
-  alias_method :distance, :norm
-  alias_method :speed, :norm
-
+  # @!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]
-    self
   end
 end
+
+# Shorthand for Vector.
+Yeah::V = Yeah::Vector

data/lib/yeah.rb

@@ -1,8 +1,11 @@
 module Yeah
-  VERSION = '0.2.0'
+  VERSION = '0.2.2'
 end
 
-requires = %i(vector color surface rectangle entity map desktop game)
-requires.each do |req|
+require 'monkey/numeric'
+
+yeah_requires = %i(vector color surface rectangle entity map desktop game
+                   basic_physics)
+yeah_requires.each do |req|
   require "yeah/#{req}"
 end