gamebox 0.4.1 → 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 29d17db2fdbdf1732b5e68f6b8584d12270e8c3d
+  data.tar.gz: b955424dab5554402acf08f8dd425c1af86649c3
+SHA512:
+  metadata.gz: 17cbdefcebc2f904c9ccfb4a4d44477b5ffc07a0a5eac840933fc7ff2e68da7fe7e343835eb3a69a98c52ec1fdd5d63d84a228dcebe55676690b883571c7c133
+  data.tar.gz: 1e3ac16757af09d3404decd43298a5509fbb0461fff5bfe1cbbcca7af86562ef6f6d5e6c60a88bdd82d8603bf40ae3b86e070400980445be80f5f9a6ecf1457f

data/README.md

@@ -3,12 +3,13 @@
 [![Gamebox Build Status](https://secure.travis-ci.org/shawn42/gamebox.png)](http://travis-ci.org/shawn42/gamebox)
 [![Gamebox Deps Status](https://gemnasium.com/shawn42/gamebox.png)](https://gemnasium.com/shawn42/gamebox)
 [![Code Climate](https://codeclimate.com/github/shawn42/gamebox.png)](https://codeclimate.com/github/shawn42/gamebox)
+[![Stories in Ready](https://badge.waffle.io/shawn42/gamebox.png)](http://waffle.io/shawn42/gamebox) 
 
 * A **game template** for building and distributing Gosu games.
 * Quickly **generate a game** and have it **up and running**.
 * Provide **conventions and DSL** for building your game.
 * Facilitate quickly building **distributable artifacts**.
-* http://shawn42.github.com/gamebox/
+* http://gamebox.io/
 * see [gamebox on rubygems.org](https://rubygems.org/gems/gamebox) for the list of requirements
 
 ## Getting started with Gamebox
@@ -102,7 +103,7 @@ end
 
 ### Behaviors
 
-Behaviors are what bring life to actors.  They interact interact with the actor's internal data, input, audio, etc.
+Behaviors are what bring life to actors.  They interact with the actor's internal data, input, audio, etc.
 
 ```ruby
 define_behavior :projectile do

data/gamebox.gemspec

@@ -26,7 +26,7 @@ Gem::Specification.new do |s|
   s.add_dependency "thor"#, ">= 0.14.6"
   s.add_dependency "require_all"
   s.add_dependency "kvo", ">= 0.1.0"
-  s.add_dependency "listen", ">= 0.5.3"
+  s.add_dependency "listen", ">= 2.4.0"
 
   s.add_development_dependency "pry", '~>0.9.7'
   s.add_development_dependency "pry-remote"

data/lib/gamebox/actors/collidable_debugger.rb

@@ -4,7 +4,7 @@ end
 
 define_behavior :collider_container do
   setup do
-    actor.has_attributes collider: actor.opts[:collider]
+    raise "collider required" unless actor.do_or_do_not(:collider)
     actor.collider.when :remove do
       actor.remove
     end
@@ -14,13 +14,12 @@ end
 define_actor_view :collidable_debugger_view do
 
   setup do
-    @color = Color::WHITE
+    @color = actor.do_or_do_not(:color) || Color::WHITE
   end
 
   draw do |target,x_off,y_off,z|
     collider = actor.collider
-    case collider.shape_type
-    when :circle
+    if collider.shape_type == :circle
       target.draw_circle x_off+collider.center_x, y_off+collider.center_y, collider.radius, @color, z
     else
       collider.cw_world_lines.each do |line|

data/lib/gamebox/actors/label.rb

@@ -35,6 +35,8 @@ define_actor :label do
         actor.font_style.color = actor.color
       end
 
+      recalculate_size
+
     end
 
     helpers do

data/lib/gamebox/actors/score.rb

@@ -2,42 +2,21 @@ define_behavior :score_keeper do
   requires :backstage, :stage
 
   setup do
-    clear if score.nil?
     # TODO helper for "attached subactor"
     label = stage.create_actor(:label, actor.attributes)
-    actor.has_attributes label: label
+    actor.has_attributes label: label, score: 0
     actor.when :position_changed do
       actor.label.x = actor.x
       actor.label.y = actor.y
     end
-    actor.when :remove_me do
-      label.remove
-    end
+    actor.when(:remove_me) { label.remove }
+    actor.when(:score_changed) { update_text }
     update_text
-    reacts_with :subtract, :add
   end
 
   helpers do
-    def score
-      backstage[:score]
-    end
-
-    def clear
-      backstage[:score] = 0
-    end
-
-    def add(amount)
-      backstage[:score] += amount
-      update_text
-    end
-
-    def subtract(amount)
-      backstage[:score] -= amount
-      update_text
-    end
-
     def update_text
-      actor.label.text = score
+      actor.label.text = actor.score
     end
   end
 end

data/lib/gamebox/behaviors/animated_with_spritemap.rb

@@ -0,0 +1,97 @@
+define_behavior :animated_with_spritemap do
+  requires :resource_manager, :director
+  setup do
+
+    actor.has_attributes animation_file: opts[:file],
+                         action: :idle, 
+                         animating: true,
+                         image: nil,
+                         width: 1,
+                         height: 1
+
+    setup_animation if actor.animation_file?
+
+    actor.when :animation_file_changed do
+      setup_animation
+    end
+
+  end
+
+  remove do
+    actor.unsubscribe_all self
+  end
+  
+  helpers do
+    def setup_animation
+      @frame_update_time = opts[:interval] || 60
+      @frame_time = 0
+
+      @frame_num = 0
+
+      file = actor.animation_file
+      rows, cols, actions = opts[:rows], opts[:cols], opts[:actions]
+      # @spritemap = resource_manager.load_image file
+      
+      # negatives means rows/cols instead of w/h 
+      #   http://www.libgosu.org/rdoc/Gosu/Image.html#load_tiles-class_method
+      @sprites = resource_manager.load_tiles file, -cols, -rows
+      
+      @frames = {}
+      actions.each do |action, frames|
+        frames = frames.to_a if frames.is_a?(Range)
+        images = Array.wrap(frames).map { |f| @sprites[f] }
+        @frames[action] = images
+      end
+
+      actor.when :action_changed do |old_action, new_action|
+        unless old_action == new_action
+          action_changed old_action, new_action
+          actor.animating = @frames[new_action].size > 1
+        end
+      end
+      
+      action_changed nil, actor.action
+
+      director.when :update do |time|
+        if actor.animating
+          @frame_time += time
+          if @frame_time > @frame_update_time
+            next_frame
+            @frame_time = @frame_time-@frame_update_time
+          end
+          set_frame
+        end
+      end
+
+    end
+
+    def next_frame
+      action_set = @frames[actor.action]
+      return unless action_set
+      @frame_num = @frame_num + 1
+      if @frame_num >= action_set.size
+        actor.emit :action_loop_complete
+        @frame_num = 0
+      end
+      # @frame_num = (@frame_num + 1) % action_set.size unless action_set.nil?
+    end
+
+    def action_changed(old_action, new_action)
+      @frame_num = 0
+      set_frame
+    end
+
+    def set_frame
+      action_set = @frames[actor.action]
+      raise "unknown action set #{actor.action} for #{actor}" if action_set.nil?
+
+      image = action_set[@frame_num]
+      actor.image = image
+      actor.width = image.width
+      actor.height = image.height
+    end
+
+  end
+  
+end
+

data/lib/gamebox/behaviors/collidable.rb

@@ -15,24 +15,16 @@ Behavior.define :collidable do
     y = (actor.do_or_do_not(:y) || 0) - hh
 
     actor.has_attributes( shape_type: shape_type,
-                          width: w,
-                          height: h,
                           x: x,
-                          y: y )
+                          y: y,
+                          width: w,
+                          height: h
+                        )
 
-    shape = 
-      case shape_type
-      when :circle
-        CircleCollidable.new actor, opts
-      when :aabb
-        AaBbCollidable.new actor, opts
-      when :polygon
-        PolygonCollidable.new actor, opts
-      end
+    shape_klass = shape_type.to_s.capitalize + "Collidable"
+    shape = Object.const_get(shape_klass).new actor, opts
     shape.setup
 
-    actor.width = shape.width
-    actor.height = shape.height
     bb = Rect.new
     bb.x = actor.x
     bb.y = actor.y

data/lib/gamebox/behaviors/collidable/aabb_collidable.rb

@@ -1,14 +1,13 @@
 
 
-class AaBbCollidable < CollidableShape
+class AabbCollidable < CollidableShape
   attr_accessor :cw_local_points
 
   def setup
     @shape_type = opts[:shape]
 
     @cw_local_points = opts[:cw_local_points]
-    @cw_local_points ||= opts[:points] || []
-    @cw_world_points ||= build_aabb
+    @cw_local_points ||= opts[:points] || build_aabb
 
     @radius = opts[:radius]
     @radius ||= calculate_radius

data/lib/gamebox/behaviors/graphical.rb

@@ -4,7 +4,7 @@
 # data/graphics/classname.png
 Behavior.define :graphical do
 
-  requires_behaviors :layered
+  requires_behaviors :layered, :positioned
   requires :resource_manager
   setup do 
     image = actor.do_or_do_not(:image) || resource_manager.load_actor_image(actor)
@@ -23,6 +23,7 @@ Behavior.define :graphical do
                           scale: scale,
                           x_scale: @opts[:x_scale] || scale,
                           y_scale: @opts[:y_scale] || scale,
+                          anchor: @opts[:anchor] || :center,
                           rotation: 0.0 )
 
     actor.when :image_changed do |old, new|

data/lib/gamebox/behaviors/physical.rb

@@ -188,7 +188,7 @@ Behavior.define :physical do
 
     def warp(new_p)
       actor.body.p = new_p
-      physics_manager.space.rehash_static if opts[:fixed]
+      physics_manager.space.reindex_static if opts[:fixed]
     end
 
     # TODO use react_to to handle these requests?

data/lib/gamebox/behaviors/positioned.rb

@@ -1,11 +1,17 @@
 define_behavior :positioned do
   setup do
-    x = opts[:x] || 0
-    y = opts[:y] || 0
-    actor.has_attributes x: x, y: y
-    actor.has_attributes position: vec2(actor.x, actor.y)
+    x = opts[:x] || actor.do_or_do_not(:x) || 0
+    y = opts[:y] || actor.do_or_do_not(:y) || 0
+    actor.has_attributes position: vec2(x, y), x: x, y: y
     actor.when(:x_changed) { actor.position = vec2(actor.x, actor.y) }
     actor.when(:y_changed) { actor.position = vec2(actor.x, actor.y) }
+
+    actor.when(:position_changed) do
+      actor.update_attributes(
+        x: actor.position.x,
+        y: actor.position.y
+      )
+    end
   end
 
 end

data/lib/gamebox/core/actor.rb

@@ -70,7 +70,7 @@ class Actor
     emit :remove_me
   end
 
-  def input
+  def controller
     # TODO conject should have a lazily loaded dependency mechanism
     @input_mapper ||= this_object_context[:input_mapper]
   end

data/lib/gamebox/core/actor_factory.rb

@@ -22,6 +22,8 @@ class ActorFactory
           model.has_attributes attr
         end
 
+        model.has_attributes(view: "#{actor}_view") if actor_definition.view_blk
+
         actor_definition.behaviors.each do |behavior|
           beh_opts = {}
           beh_key = behavior

data/lib/gamebox/core/arbiter.rb

@@ -97,6 +97,8 @@ module Arbiter
 
 
 
+  # This reads terribly and violates open-closed principle,
+  # but does perform better than any dynamic lookup based on shape_types
   def collide?(object, other)
     case object.shape_type
     when :circle

data/lib/gamebox/core/font_style.rb

@@ -13,11 +13,11 @@ class FontStyle
   end
   
   def calc_width(text)
-    @font.text_width text
+    @font.text_width text if @font
   end
   
   def height
-    @font.height
+    @font.height if @font
   end
   
   def reload

data/lib/gamebox/core/input_mapper.rb

@@ -7,10 +7,10 @@ class InputMapper
     @action_ids = {}
   end
 
-  # map_input is to be setup outside of an actor and passed in at construction
+  # map_controls is to be setup outside of an actor and passed in at construction
   # time ie:
   #
-  # mapper.map_input {
+  # mapper.map_controls {
   #  '+a' => :jump,   # emit jump when 'a' is _pressed_
   #  '-b' => :duck,   # emit duck when 'b' is _released_
   #  'c'  => :block   # emit block when 'c' is _pressed_ AND _released_
@@ -20,7 +20,7 @@ class InputMapper
   # create_actor :fighter, input: mapper
   # 
   # all of the actor's behaviors can / should use the input mapper instead of raw key bindings
-  def map_input(input_hash)
+  def map_controls(input_hash)
     input_hash.each do |input, actions|
       if input.start_with? '-'
         register_key_released(input[1..-1], actions)
@@ -35,7 +35,7 @@ class InputMapper
 
   # unsubscribes for all input
   def clear
-    input_manager.unsubscribe_all
+    input_manager.unsubscribe_all self
   end
 
   def method_missing(name, *args)

data/lib/gamebox/core/resource_manager.rb

@@ -14,8 +14,8 @@ class ResourceManager
 
   def load_actor_image(actor)
     # use pngs only for now
-    # actor_name = Inflector.underscore(actor.class)
-    return load_image("#{actor.actor_type}.png")
+    image_name = actor.do_or_do_not(:image_name) || actor.actor_type
+    return load_image("#{image_name}.png")
   end
 
   def load_animation_set(actor, action)

data/lib/gamebox/core/viewport.rb

@@ -10,6 +10,7 @@ class Viewport
     :height, :x_offset_range, :y_offset_range, :boundary, :rotation
 
   attr_reader :speed
+  alias :follow_target? :follow_target
 
   def debug
     "xoff:#{@x_offset} yoff:#{@y_offset}"
@@ -59,64 +60,29 @@ class Viewport
   end
 
   def update(time)
-    scrolled = false
-    if @follow_target
-      x = @follow_target.x
-      y = @follow_target.y
-      if @x_offset_range
-        x = @x_offset_range.min if @x_offset_range.min > x 
-        x = @x_offset_range.max if @x_offset_range.max < x 
-      end
-      if @y_offset_range
-        y = @y_offset_range.min if @y_offset_range.min > y 
-        y = @y_offset_range.max if @y_offset_range.max < y 
-      end
-      x_diff = @width/2 + @follow_offset_x - x - @x_offset
-      if x_diff.abs > @buffer_x
-        # move screen 
-        if x_diff > 0
-          @x_offset += (x_diff - @buffer_x) * @speed
-        else
-          @x_offset += (x_diff + @buffer_x) * @speed
-        end
-
-        scrolled = true
-      end
-
-      y_diff = @height/2 + @follow_offset_y - y - @y_offset
-      if y_diff.abs > @buffer_y
-        # move screen
-        if y_diff > 0
-          @y_offset += (y_diff - @buffer_y) * @speed
-        else
-          @y_offset += (y_diff + @buffer_y) * @speed
-        end
-        scrolled = true
-      end
-
-      # constrain_x_offset
-      if @boundary
-        if @x_offset > 0 - @boundary[0] # Left-wall bump
-          @x_offset = @boundary[0]
-        elsif @x_offset < @width - @boundary[2] # right-wall bump
-          @x_offset = @width - @boundary[2]
-        end
-      end
-
-      # constrain_y_offset
-      if @boundary
-        if @y_offset > 0 - @boundary[1]
-          @y_offset = @boundary[1]
-        elsif @y_offset < @height - @boundary[3]
-          @y_offset = @height - @boundary[3]
-        end
-      end
-
+    if follow_target?
+      scrolled = move_towards_target
+      clamp_to_boundary
       fire :scrolled if scrolled
     end
   end
 
+  # Viewport will stay centered on the targets x,y
+  #
+  # args hash:
+  # :x_offset - keep the viewport centered on x + x_offset
+  # :y_offset - keep the viewport centered on y + y_offset
+  # :x_chain_length - allow this much x slack when following
+  # :y_chain_length - allow this much y slack when following
+  def stay_centered_on(target, args={})
+    offset_x = args[:x_offset] || 0
+    offset_y = args[:y_offset] || 0
+    x_chain_length = args[:x_chain_length] || 0
+    y_chain_length = args[:y_chain_length] || 0
+    follow target, [-offset_x, -offset_y], [x_chain_length, y_chain_length]
+  end
 
+  # deprecated; use #stay_centered_on
   def follow(target, off=[0,0], buff=[0,0])
     @follow_target = target
     @follow_offset_x = off[0]
@@ -133,7 +99,65 @@ class Viewport
   def bounds
     left = -@x_offset
     top = -@y_offset
-    Rect.new left, top, left + @width, top + @height
+    # Rect.new left, top, left + @width, top + @height
+    Rect.new left, top, @width, @height
+  end
+
+  private
+  def move_towards_target
+    scrolled = false
+
+    x = @follow_target.x
+    y = @follow_target.y
+
+    if @x_offset_range
+      x = @x_offset_range.min if @x_offset_range.min > x 
+      x = @x_offset_range.max if @x_offset_range.max < x 
+    end
+    if @y_offset_range
+      y = @y_offset_range.min if @y_offset_range.min > y 
+      y = @y_offset_range.max if @y_offset_range.max < y 
+    end
+    x_diff = @width/2 + @follow_offset_x - x - @x_offset
+    if x_diff.abs > @buffer_x
+      # move screen 
+      if x_diff > 0
+        @x_offset += (x_diff - @buffer_x) * @speed
+      else
+        @x_offset += (x_diff + @buffer_x) * @speed
+      end
+
+      scrolled = true
+    end
+
+    y_diff = @height/2 + @follow_offset_y - y - @y_offset
+    if y_diff.abs > @buffer_y
+      # move screen
+      if y_diff > 0
+        @y_offset += (y_diff - @buffer_y) * @speed
+      else
+        @y_offset += (y_diff + @buffer_y) * @speed
+      end
+      scrolled = true
+    end
+
+    scrolled
+  end
+
+  def clamp_to_boundary
+    if @boundary
+      if @x_offset > 0 - @boundary[0] # Left-wall bump
+        @x_offset = @boundary[0]
+      elsif @x_offset < @width - @boundary[2] # right-wall bump
+        @x_offset = @width - @boundary[2]
+      end
+
+      if @y_offset > 0 - @boundary[1]
+        @y_offset = @boundary[1]
+      elsif @y_offset < @height - @boundary[3]
+        @y_offset = @height - @boundary[3]
+      end
+    end
   end
 
 end