pixie_dust 0.0.1

data/lib/pixie_dust/version.rb

@@ -0,0 +1,3 @@
+module PixieDust
+  VERSION = "0.0.1"
+end

data/lib/pixie_dust.rb

@@ -0,0 +1,14 @@
+require "pixie_dust/version"
+
+require "cornerstone-source"
+
+if defined? ::Rails
+  class Engine < ::Rails::Engine
+    config.paths['app/assets'] = "source"
+  end
+elsif defined? ::Sprockets
+  root_dir = File.expand_path(File.dirname(File.dirname(__FILE__)))
+  asset_dir = File.join(root_dir, "source")
+
+  ::Sprockets.append_path asset_dir
+end

data/pixie.json

@@ -0,0 +1,15 @@
+{
+  "author": "STRd6",
+  "main": null,
+  "name": "gamelib",
+  "library": true,
+  "libs": {
+    "corelib.js": "https://raw.github.com/PixieEngine/Cornerstone/pixie/game.js"
+  },
+  "directories": {
+    "lib": "lib",
+    "source": "source",
+    "test": "test"
+  },
+  "autosave": true
+}

data/pixie_dust.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pixie_dust/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "pixie_dust"
+  spec.version       = PixieDust::VERSION
+  spec.authors       = ["Daniel Moore"]
+  spec.email         = ["yahivin@gmail.com"]
+  spec.description   = %q{
+    Amazing libraries for developing games.
+    Defines the main PixieEngine GameObject and includes mixins to easily augment their behavior.
+  }
+
+  spec.summary       = %q{Amazing libraries for developing games}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+
+  spec.add_dependency "cornerstone-source"
+end

data/source/active_bounds.coffee

@@ -0,0 +1,48 @@
+###*
+The ActiveBounds module automatically destroys objects that
+are outside of the specified bounds. The default bounds are
+the dimensions of your game. Useful for bullet type objects.
+
+    bullet = GameObject
+      x: 10
+      y: 50
+      width: 20
+      height: 20
+      velocity: Point(120, 0)
+
+    bullet.include ActiveBounds
+
+    # => bullet will be removed when it
+         goes outside of the game bounds.
+    
+    bullet2 = GameObject
+      x: 50
+      y: 50
+      width: 30
+      height: 20
+      activeBounds: Rectangle
+        x: 30
+        y: 20
+        width: 100
+        height 100
+
+    # => bullet2 will be removed unless 30 <= I.x <= 130
+         and 20 <= I.y <= 120
+
+@name ActiveBounds
+@module
+@constructor
+@param {Object} I Instance variables
+@param {Core} self Reference to including object
+###
+ActiveBounds = (I={}, self) ->
+  Object.reverseMerge I,
+    activeBounds: Rectangle
+      x: 0
+      y: 0
+      width: App.width
+      height: App.height
+
+  self.bind 'update', ->
+    self.destroy() unless I.activeBounds.left <= I.x <= I.activeBounds.right
+    self.destroy() unless I.activeBounds.top <= I.y <= I.activeBounds.bottom

data/source/ageable.coffee

@@ -0,0 +1,23 @@
+###*
+The Ageable module handles keeping track of an object's age.
+
+    player = GameObject()
+    
+    player.update(1)
+    
+    #=> player.I.age == 1   
+
+@name Ageable
+@module
+@constructor
+@param {Object} I Instance variables
+@param {Core} self Reference to including object
+###
+Ageable = (I={}, self) ->
+  Object.reverseMerge I,
+    age: 0
+
+  self.bind 'afterUpdate', (dt) ->
+    I.age += dt
+
+  return {}

data/source/bounded.coffee

@@ -0,0 +1,282 @@
+###*
+The Bounded module is used to provide basic data about the
+location and dimensions of the including object. This module is included
+by default in `GameObject`.
+
+    player = Core
+      x: 10
+      y: 50
+      width: 20
+      height: 20
+      other: "stuff"
+      more: "properties"
+    
+    player.position()
+    # => Uncaught TypeError: Object has no method 'position'
+    
+    player.include(Bounded)
+    
+    # now player has all the methods provided by this module
+    player.position()
+    # => {x: 10, y: 50}
+
+@see GameObject
+
+Bounded module
+@name Bounded
+@module
+@constructor
+@param {Object} I Instance variables
+@param {Core} self Reference to including object
+###
+
+Bounded = (I={}, self) ->
+  Object.reverseMerge I,
+    x: 0
+    y: 0
+    width: 8
+    height: 8
+    collisionMargin: Point(0, 0)
+
+  ###*
+  Get the object closest to this one.
+
+  @name closest
+  @methodOf Bounded#
+  @param {Object|Array|String} selector An object or set of objects to find the closest from.
+  ###
+  closest: (selector) ->
+    if Object.isString(selector)
+      selector = engine.find(selector)
+    else
+      selector = [].concat(selector)
+
+    position = self.position()
+
+    selector.sort (a, b) ->
+      Point.distanceSquared(position, a.position()) - Point.distanceSquared(position, b.position())
+    .first()
+
+  ###*
+  Distance between two objects. Proxies to Point.distance.
+  In order for this to work, `otherObj` must have a 
+  position method.
+
+      player = GameObject
+        x: 50
+        y: 50
+        width: 10
+        height: 10
+      
+      player.include Bounded
+      
+      enemy = GameObject
+        x: 110
+        y: 120
+        width: 7
+        height: 20
+        
+      player.distance(enemy)
+      # => 92.19544457292888
+
+  @name distance
+  @methodOf Bounded#
+  @see Point.distance
+  @returns {Number} Distance between the two objects
+  ###  
+  distance: (otherObj) ->
+    Point.distance(self.position(), otherObj.position())
+
+  ###*
+  The position of this game object. By default it is the top left point.
+  Redefining the center method will change the relative position.
+
+      player = Core
+        x: 50
+        y: 40
+    
+      player.include(Bounded)      
+    
+      player.position()
+      # => {x: 50, y: 40}
+
+  @name position
+  @methodOf Bounded#
+  @returns {Point} The position of this object
+  ###
+  position: (newPosition) ->
+    if newPosition?
+      I.x = newPosition.x
+      I.y = newPosition.y
+    else
+      Point(I.x, I.y)
+
+  changePosition: (delta) ->
+    I.x += delta.x
+    I.y += delta.y
+
+    self
+
+  ###*
+  Does a check to see if this object is overlapping
+  with the bounds passed in.
+
+      player = Core
+        x: 4
+        y: 6
+        width: 20
+        height: 20
+    
+      player.include(Bounded)  
+    
+      player.collides({x: 5, y: 7, width: 20, height: 20})
+      # => true
+
+  @name collides
+  @methodOf Bounded#
+  @returns {Point} The position of this object
+  ###
+  collides: (bounds) ->
+    Collision.rectangular(self.bounds(), bounds)
+
+  ###*
+  This returns a modified bounds based on the collision margin.
+  The area of the bounds is reduced if collision margin is positive
+  and increased if collision margin is negative.
+
+      player = Core
+        collisionMargin: 
+          x: -2
+          y: -4
+        x: 50
+        y: 50
+        width: 20
+        height: 20
+    
+      player.include(Bounded)
+    
+      player.collisionBounds()
+      # => {x: 38, y: 36, height: 28, width: 24}
+    
+      player.collisionBounds(10, 10)
+      # => {x: 48, y: 46, height: 28, width: 24}
+
+  @name collisionBounds
+  @methodOf Bounded#
+  @param {Number} xOffset the amount to shift the x position 
+  @param {Number} yOffset the amount to shift the y position
+  @returns {Object} The collision bounds
+  ###
+  collisionBounds: (xOffset, yOffset) ->
+    bounds = self.bounds(xOffset, yOffset)
+
+    bounds.x += I.collisionMargin.x
+    bounds.y += I.collisionMargin.y
+    bounds.width -= 2 * I.collisionMargin.x
+    bounds.height -= 2 * I.collisionMargin.y
+
+    return bounds
+
+  ###*
+  Returns infomation about the location of the object and its dimensions with optional offsets.
+
+      player = Core
+        x: 3
+        y: 6
+        width: 2
+        height: 2
+    
+      player.include(Bounded)
+    
+      player.bounds()
+      # => {x: 3, y: 6, width: 2, height: 2}
+    
+      player.bounds(7, 4)
+      # => {x: 10, y: 10, width: 2, height: 2}   
+
+  @name bounds
+  @methodOf Bounded#
+  @param {Number} xOffset the amount to shift the x position 
+  @param {Number} yOffset the amount to shift the y position
+  ### 
+  bounds: (xOffset, yOffset) ->
+    center = self.center()
+
+    x: center.x - I.width/2 + (xOffset || 0)
+    y: center.y - I.height/2 + (yOffset || 0)
+    width: I.width
+    height: I.height
+
+  ###*
+  The centeredBounds method returns infomation about the center
+  of the object along with the midpoint of the width and height.
+
+      player = Core
+        x: 3
+        y: 6
+        width: 2
+        height: 2
+    
+      player.include(Bounded)
+    
+      player.centeredBounds()
+      # => {x: 4, y: 7, xw: 1, yw: 1}
+
+  @name centeredBounds
+  @methodOf Bounded#
+  ###  
+  centeredBounds: () ->
+    center = self.center()
+
+    x: center.x
+    y: center.y
+    xw: I.width/2
+    yw: I.height/2
+
+  ###*
+  The center method returns the {@link Point} that is
+  the center of the object.
+
+      player = Core
+        x: 50
+        y: 40
+        width: 10
+        height: 30
+    
+      player.include(Bounded)  
+    
+      player.center()
+      # => {x: 30, y: 35}
+
+  @name center
+  @methodOf Bounded#
+  @returns {Point} The middle of the calling object
+  ###  
+  center: (newCenter) ->
+    self.position(newCenter)
+
+  ###*
+  Return the circular bounds of the object. The circle is
+  centered at the midpoint of the object.
+
+      player = Core
+        radius: 5
+        x: 50
+        y: 50
+        other: "stuff"
+    
+      player.include(Bounded)
+    
+      player.circle()
+      # => {radius: 5, x: 50, y: 50}
+
+  @name circle
+  @methodOf Bounded#
+  @returns {Object} An object with a position and a radius
+  ###
+  circle: () ->
+    circle = self.center()
+    circle.radius = I.radius || I.width/2 || I.height/2
+
+    return circle
+

data/source/camera.coffee

@@ -0,0 +1,138 @@
+oldCamera = Camera
+
+Camera = (I={}) ->
+  Object.reverseMerge I,
+    cameraBounds: Rectangle # World Coordinates
+      x: 0
+      y: 0
+      width: App.width
+      height: App.height
+    screen: Rectangle # Screen Coordinates
+      x: 0
+      y: 0
+      width: App.width
+      height: App.height
+    deadzone: Point(0, 0) # Screen Coordinates
+    zoom: 1
+    transform: Matrix()
+    x: App.width/2 # World Coordinates
+    y: App.height/2 # World Coordinates
+    velocity: Point.ZERO
+    maxSpeed: 25
+    t90: 2 # Time in seconds for camera to move 90% of the way to the target
+
+  currentType = "centered"
+  currentObject = null
+
+  objectFilters = []
+  transformFilters = []
+
+  focusOn = (object, elapsedTime) ->
+    dampingFactor = 2
+
+    #TODO: Different t90 value inside deadzone?
+
+    c = elapsedTime * 3.75 / I.t90
+    if c >= 1
+      # Spring is configured to be too intense, just snap to target
+      self.position(target)
+      I.velocity = Point.ZERO
+    else
+      objectCenter = object.center()
+
+      target = objectCenter
+
+      delta = target.subtract(self.position())
+
+      force = delta.subtract(I.velocity.scale(dampingFactor))
+      self.changePosition(I.velocity.scale(c).clamp(I.maxSpeed))
+      I.velocity = I.velocity.add(force.scale(c))
+
+  followTypes =
+    centered: (object, elapsedTime) ->
+      I.deadzone = Point(0, 0)
+
+      focusOn(object, elapsedTime)
+
+    topdown: (object, elapsedTime) ->
+      helper = Math.max(I.screen.width, I.screen.height) / 4
+
+      I.deadzone = Point(helper, helper)
+
+      focusOn(object, elapsedTime)
+
+    platformer: (object, elapsedTime) ->
+      width = I.screen.width / 8
+      height = I.screen.height / 3
+
+      I.deadzone = Point(width, height)
+
+      focusOn(object, elapsedTime)
+
+  self = Core(I).extend
+    follow: (object, type="centered") ->
+      currentObject = object
+      currentType = type
+
+    objectFilterChain: (fn) ->
+      objectFilters.push fn
+
+    transformFilterChain: (fn) ->
+      transformFilters.push fn
+
+    screenToWorld: (point) ->
+      self.transform().inverse().transformPoint(point)
+
+  self.attrAccessor "transform"
+
+  self.bind "afterUpdate", (elapsedTime) ->
+    if currentObject
+      followTypes[currentType](currentObject, elapsedTime)
+
+    # Hard clamp camera to world bounds
+    I.x = I.x.clamp(I.cameraBounds.left + I.screen.width/2, I.cameraBounds.right - I.screen.width/2)
+    I.y = I.y.clamp(I.cameraBounds.top + I.screen.height/2, I.cameraBounds.bottom - I.screen.height/2)
+
+    I.transform = Matrix.translate(I.screen.width/2 - I.x.floor(), I.screen.height/2 - I.y.floor())
+
+  self.bind "draw", (canvas, objects) ->
+    # Move to correct screen coordinates
+    canvas.withTransform Matrix.translate(I.screen.x, I.screen.y), (canvas) ->
+      canvas.clip(0, 0, I.screen.width, I.screen.height)
+
+      objects = objectFilters.pipeline(objects)
+      transform = transformFilters.pipeline(self.transform().copy())
+
+      canvas.withTransform transform, (canvas) ->
+        self.trigger "beforeDraw", canvas
+        objects.invoke "draw", canvas
+
+      self.trigger 'flash', canvas
+
+  self.bind "overlay", (canvas, objects) ->
+    canvas.withTransform Matrix.translate(I.screen.x, I.screen.y), (canvas) ->
+      canvas.clip(0, 0, I.screen.width, I.screen.height)
+      objects = objectFilters.pipeline(objects)
+
+      objects.invoke "trigger", "overlay", canvas
+
+  self.include "Bounded"
+
+  # The order of theses includes is important for
+  # the way in wich they modify the camera view transform
+
+  for moduleName in Camera.defaultModules
+    self.include "Camera.#{moduleName}"
+
+  return self
+
+Camera.defaultModules = [
+  "ZSort"
+  "Zoom"
+  "Rotate"
+  "Shake"
+  "Flash"
+  "Fade"
+]
+
+Object.extend Camera, oldCamera

data/source/camera.fade.coffee

@@ -0,0 +1,69 @@
+###*
+The <code>Fade</code> module provides convenience methods for accessing common Engine.Flash presets.
+
+@name Fade
+@fieldOf Camera
+@module
+@param {Object} I Instance variables
+@param {Object} self Reference to the engine
+@see Camera.Flash
+###
+Camera.Fade = (I, self) ->  
+  fadeInDefaults =
+    alpha: 0
+    color: 'black'
+    duration: 30
+
+  fadeOutDefaults =
+    alpha: 1
+    color: 'transparent'
+    duration: 30
+
+  configureFade = (duration, color, alpha) ->
+    I.flashDuration = duration
+    I.flashCooldown = duration
+    I.flashColor = Color(color)
+    I.flashTargetAlpha = alpha
+
+  ###*
+  A convenient way to set the flash effect instance variables. This provides a shorthand for fading the screen in 
+  from a given color over a specified duration.
+
+      engine.fadeIn()
+      # => Sets the effect variables to their default state. This will the screen to go from black to transparent over the next 30 frames.
+    
+      engine.fadeIn('blue', 50)
+      # => This effect will start off blue and fade to transparent over 50 frames.
+
+  @name fadeIn
+  @methodOf Camera#
+  @param {Number} [duration=30] How long the effect lasts
+  @param {Color} [color="black"] The color to fade from
+  ###
+  fadeIn: (options={}) ->
+    {alpha, color, duration} = Object.reverseMerge(options, fadeInDefaults)
+
+    configureFade(duration, color, alpha)
+
+  ###*
+  A convenient way to set the flash effect instance variables. This provides a shorthand for fading 
+  the screen to a given color over a specified duration.
+
+      camera.fadeOut()
+      # => Sets the effect variables to their default state. This will the screen to fade from ransparent to black over the next 30 frames.
+      
+      camera.fadeOut
+        color: blue
+        duration: 30
+      # => This effect will start off transparent and change to blue over 50 frames.
+
+  @name fadeOut
+  @methodOf Camera#
+  @param {Number} [duration=30] How long the effect lasts
+  @param {Color} [color="transparent"] The color to fade to
+  ###
+  fadeOut: (options={}) ->
+    {alpha, color, duration} = Object.reverseMerge(options, fadeOutDefaults)
+
+    configureFade(duration, color, alpha)
+

data/source/camera.flash.coffee

@@ -0,0 +1,69 @@
+###*
+The <code>Flash</code> module allows you to flash a color onscreen and then fade to transparent over a time period. 
+This is nice for lightning type effects or to accentuate major game events.
+
+@name Flash
+@fieldOf Camera
+@module
+@param {Object} I Instance variables
+@param {Object} self Reference to the camera
+###
+Camera.Flash = (I, self) ->
+  Object.reverseMerge I,
+    flashColor: Color(0, 0, 0, 0)
+    flashDuration: 12
+    flashCooldown: 0
+    flashTargetAlpha: 0
+
+  defaultParams =
+    color: 'white'
+    duration: 12
+    targetAlpha: 0
+
+  self.bind 'afterUpdate', ->
+    if I.flashCooldown > 0
+      I.flashColor.a = I.flashColor.a.approach(I.flashTargetAlpha, 1 / I.flashDuration).clamp(0, 1)      
+      I.flashColor.a = 0 if I.flashColor.a < 0.00001
+      I.flashColor.a = 1 if I.flashColor.a > 0.9999
+
+      I.flashCooldown = I.flashCooldown.approach(0, 1)
+
+  self.bind 'flash', (canvas) ->
+    canvas.fill I.flashColor      
+
+  ###*
+  A convenient way to set the flash effect instance variables. Alternatively, you can modify them by hand, but
+  using Camera#flash is the suggested approach.
+
+      camera.flash()
+      # => Sets the flash effect variables to their default state. This will cause a white flash that will turn transparent in the next 12 frames.
+    
+      camera.flash
+        color: 'green'
+        duration: 30
+      # => This flash effect will start off green and fade to transparent over 30 frames.
+    
+      camera.flash
+        color: Color(255, 0, 0, 0)
+        duration: 20
+        targetAlpha: 1
+      # => This flash effect will start off transparent and move toward red over 20 frames 
+
+  @name flash
+  @methodOf Camera#
+  @param {Color} [color="white"] The flash color
+  @param {Number} [duration=12] How long the effect lasts
+  @param {Number} [targetAlpha=0] The alpha value to fade to. By default, this is set to 0, which fades the color to transparent.
+  ###
+  flash: (options={}) ->
+    Object.reverseMerge(options, defaultParams)
+
+    {color, duration, targetAlpha} = options
+
+    I.flashColor = Color(color) 
+    I.flashTargetAlpha = targetAlpha
+    I.flashCooldown = duration
+    I.flashDuration = duration
+
+    self
+

data/source/camera.rotate.coffee

@@ -0,0 +1,11 @@
+Camera.Rotate = (I, self) ->
+  Object.reverseMerge I,
+    rotation: 0
+
+  self.transformFilterChain (transform) ->
+    transform.rotate(I.rotation, self.position())
+
+  self.attrAccessor "rotation"
+
+  rotate: (amount) ->
+    self.rotation(I.rotation + amount)