pixie_dust 0.0.1

data/source/controllable.coffee

@@ -0,0 +1,66 @@
+###*
+The Controllable module adds simple movement
+when up, down, left, or right are held.
+
+      # create a player and include Controllable
+      player = GameObject
+        width: 5
+        height: 17
+        x: 15
+        y: 30
+        speed:  2
+    
+      player.include Controllable
+    
+      # hold the left arrow key, then
+      # update the player
+      player.update()
+    
+      # the player is moved left according to his speed
+      player.I.x
+      # => 13
+    
+      # We keep track of the direction the object is
+      # facing in case you need that (eg. for attack direction)
+      player.I.facing
+      # => player.I.facing 
+      # => Point(-1, 0)
+
+@name Controllable
+@module
+@constructor
+@param {Object} I Instance variables
+@param {Core} self Reference to including object
+###
+Controllable = (I={}, self) ->
+  Object.reverseMerge I,
+    facing: Point(1, 0)
+    speed: 1
+    velocity: Point(0, 0)
+
+  self.bind "update", ->
+    self.movement()
+
+  movement: ->
+    I.velocity.x = 0
+    I.velocity.y = 0
+
+    if keydown.left
+      I.velocity.x = -1
+
+    if keydown.right
+      I.velocity.x = 1
+
+    if keydown.up
+      I.velocity.y = -1
+
+    if keydown.down
+      I.velocity.y = 1
+
+    I.velocity = I.velocity.norm()
+
+    unless I.velocity.equal(Point.ZERO)
+      I.facing = I.velocity    
+    
+    I.velocity = I.velocity.scale(I.speed)
+    

data/source/cooldown.coffee

@@ -0,0 +1,82 @@
+###*
+The Cooldown module provides a declarative way to manage cooldowns on
+GameObject's properties.
+
+    # Health regeneration
+    player = GameObject
+      health: 50
+    
+    # health will approach 
+    # 100 by 1 every second
+    player.cooldown "health",
+      target: 100
+    
+    elapsedTime = 1
+    player.update(elapsedTime)
+    
+    player.I.health
+    # => 51
+
+    # Shoot Timeout
+    player = GameObject()
+    
+    # by default the cooldown 
+    # approaches 0 by 1 each second
+    player.cooldown "shootTimer"
+    
+    player.I.shootTimer = 10 # => Pew! Pew!
+    
+    player.update(elapsedTime)
+    
+    player.I.shootTimer # => 9
+    
+    # Turbo Cooldown
+    player = GameObject()
+    
+    # turboTimer starts at 1000 
+    # and approaches 12 by 5 each second
+    player.cooldown "turboTimer",
+      approachBy: 5
+      value: 1000
+      target: 12
+    
+    player.I.turboTimer = 1000
+    
+    player.update(elapsedTime)
+    
+    player.I.turboTimer # => 995
+
+@name Cooldown
+@module
+@constructor
+@param {Object} I Instance variables
+@param {Core} self Reference to including object
+###
+Cooldown = (I, self) ->
+  Object.reverseMerge I,
+    cooldowns: {}
+
+  self.bind "update", (dt) ->
+    for name, cooldownOptions of I.cooldowns
+      {approachBy, target} = cooldownOptions
+
+      I[name] = I[name].approach(target, approachBy * dt)
+
+  cooldown: (name, options={}) ->
+    {target, approachBy, value} = options
+
+    target ||= 0
+    approachBy = 1 unless approachBy?
+
+    # Set the cooldown data
+    I.cooldowns[name] = {
+      target
+      approachBy
+    }
+
+    if value?
+      # Use the value given if any
+      I[name] = options.value
+    else
+      # Initialize field if it doesn't exist
+      I[name] = 0 unless I[name]

data/source/debuggable.coffee

@@ -0,0 +1,253 @@
+###*
+The Debuggable Module provides a simple API to easily display
+an object's properties onscreen. This mixin comes with predefined
+attribute filters so that you can exclude irrelevant data.
+
+    player = GameObject
+      x: 40
+      y: 14
+      spriteName: null
+      numericErrorProperty: NaN
+    
+    player.include Debuggable
+    
+    # sets up debug output for all player's properties
+    # at the starting position (0, 0)
+    player.debug
+      filter: 'all'
+
+@name Debuggable
+@module
+@constructor
+@param {Object} I Instance variables
+@param {Core} self Reference to including object
+###
+Debuggable = (I={}, self) ->
+  COL_HEIGHT = 175
+  ROW_HEIGHT = 9
+  FONT_SIZE = 9
+
+  debugX = 0
+  debugY = 0
+
+  Object.reverseMerge I,
+    debug:
+      enabled: false
+      color: 'black'
+      filter: 'all'
+      bounds: true
+      velocity: true
+      position:
+        x: 0
+        y: 0
+  
+  initialI = Object.extend({}, I)
+  
+  debugBounds = (canvas) ->
+    canvas.drawRect
+      color: 'rgba(255, 0, 255, 0.4)'
+      bounds: self.bounds()  
+  
+  debugVelocity = (canvas) ->
+    if I.velocity?
+      canvas.withTransform Matrix.translation(I.x, I.y), (canvas) ->  
+        thickness = 4
+        
+        color = 'rgba(255, 0, 0, 0.5)'
+        
+        canvas.drawRect
+          x: 0
+          y: -thickness / 2
+          width: I.velocity.x
+          height: thickness
+          color: color
+
+        canvas.drawRect
+          x: -thickness / 2
+          y: 0
+          width: thickness
+          height: I.velocity.y
+          color: color
+
+  filterProperties = (properties) ->
+    results = {}
+    
+    switch I.debug.filter
+      when 'all'
+        results = properties
+      when 'undefined'
+        for key, value of properties
+          results[key] = value if not value? or nan(value)
+      when 'changed'
+        for key, value of properties
+          results[key] = value if initialI[key] isnt value
+      
+    return results          
+          
+  sortedKeys = ->
+    keys = []
+      
+    for key, value of filterProperties(I)
+      keys.push key
+        
+    keys.sort()
+  
+  nan = (value) ->
+    typeof value is 'number' and isNaN(value)
+    
+  drawDebugLine = (text, canvas, x, y) ->    
+    canvas.drawText
+      color: I.debug.color
+      x: x + I.debug.position.x
+      y: y + I.debug.position.y
+      text: text
+
+    debugY += ROW_HEIGHT
+
+  getPropertyRow = (key, value, canvas) ->
+    # exclude functions returned by iterating over 
+    # objects like Color, Point, etc.
+    if typeof value is 'function'
+      return
+    else if Object.isObject(value)
+      drawDebugLine(key, canvas, debugX, debugY)
+
+      debugX += 8
+
+      for k, v of value
+        getPropertyRow(k, v, canvas)
+
+      debugX -= 8
+    else if Object.isArray(value)
+      toStringArray = (for v in value
+        if Object.isObject(v) 
+          v.I.class || v.toString()
+        else
+          v
+      )
+
+      drawDebugLine("#{key}(#{value.length}): #{toStringArray}", canvas, debugX, debugY)
+    else
+      value = processValue(value)
+
+      drawDebugLine("#{key}: #{value}", canvas, debugX, debugY)
+
+  processValue = (value) ->
+    output = value
+
+    try 
+      parsedNumber = parseFloat(value)      
+
+    if parsedNumber
+      if typeof value isnt 'string' and parsedNumber isnt parseInt(value)
+        output = value.toFixed(3)   
+
+    return output
+  
+  self.bind "update", ->
+    if justPressed['0']
+      self.toggleDebug()
+
+  self.bind "overlay", (canvas) ->   
+    if I.debug.enabled
+      canvas.font "#{FONT_SIZE}px Monaco"
+
+      debugX = 0
+      debugY = ROW_HEIGHT
+      
+      for key in sortedKeys()
+        getPropertyRow(key, I[key], canvas) 
+
+      debugX += COL_HEIGHT
+      debugY = ROW_HEIGHT 
+      
+      debugBounds(canvas) if I.debug.bounds
+      debugVelocity(canvas) if I.debug.velocity
+
+  ###*
+  Enable debugging display for the calling GameObject.
+
+      player = GameObject
+        x: 40
+        y: 14
+        spriteName: null
+        numericErrorProperty: NaN
+      
+      player.include Debuggable
+    
+      # sets up debug output for all player's properties
+      # at the starting position (0, 0)
+      player.debug
+        filter: 'all'
+      
+      player.I.y = 45
+      
+      # sets up debug output for only properties that have
+      # changed since initialization. In this case only y
+      # would be displayed.
+      player.debug
+        filter: 'changed'
+      
+      # sets up debug output for properties that are <code>undefined</code>, 
+      # <code>null</code>, or <code>NaN</code>. In this case spriteName and
+      # numericErrorProperty would be displayed.
+      player.debug
+        filter: 'undefined'
+      
+      # sets up debug output using all possible configuration options
+      player.debug
+        bounds: true # set this to false to disable visual debugging of the object's bounding box
+        color: 'red' # color of debug text
+        filter: 'all'
+        x: 30 # x position to start printing debug information
+        y: 50 # y position to start printing debug information
+        velocity: true # set this to false to disable visual debugging of the object's velocity
+
+  @name debug
+  @methodOf Debuggable#
+  @param {Object} Options to configure debug output
+  @param {Boolean} bounds Whether or not to visually debug the object's bounds
+  @param {Color|String} color The color of the debug text
+  @param {String} filter Choices include 'all', 'changed', and 'undefined'
+  @param {Number} x The x position to start drawing the debug information
+  @param {Number} y The y position to start drawing the debug information
+  @param {Boolean} velocity Whether or not to visually debug the object's velocity
+  ###         
+  debug: (options={}) ->
+    {x, y} = options
+    
+    I.debug.position.x = x if x?
+    I.debug.position.y = y if y?
+      
+    Object.extend I.debug, options
+
+    I.debug.enabled = true
+
+  ###*
+  Toggle display of debug information.
+
+      player = GameObject()
+    
+      player.include Debuggable
+    
+      # enables debug display
+      player.debug()
+      
+      # disables debug display
+      player.toggleDisable()
+      
+      # if false is passed to toggleDisplay, then debugging is disabled.  
+      player.toggleDisplay(false)
+    
+      # if true is passed to toggleDisplay, then debugging is enabled.
+      player.toggleDisplay(true)
+
+  @name toggleDebug
+  @methodOf Debuggable#
+  @param {Boolean} newVal If true is passed then debugging is enabled, if false is passed then debugging is disabled, if nothing is passed, then debug state is toggled.
+  ###    
+  toggleDebug: (newVal) ->
+    if newVal?
+      I.debug.enabled = newVal
+    else
+      I.debug.enabled = not I.debug.enabled

data/source/drawable.coffee

@@ -0,0 +1,167 @@
+###*
+The Drawable module is used to provide a simple draw method to the including
+object.
+
+Binds a default draw listener to draw a rectangle or a sprite, if one exists.
+
+Binds a step listener to update the transform of the object.
+
+Autoloads the sprite specified in I.sprite, if any.
+
+    player = Core
+      x: 15
+      y: 30
+      width: 5
+      height: 5
+      sprite: "my_cool_sprite"
+
+    engine.bind 'draw', (canvas) ->
+      player.draw(canvas)
+    # => Uncaught TypeError: Object has no method 'draw'
+
+    player.include(Drawable)
+
+    engine.bind 'draw', (canvas) ->
+      player.draw(canvas)
+    # => if you have a sprite named "my_cool_sprite" in your images folder
+    # then it will be drawn. Otherwise, a rectangle positioned at x: 15 and
+    # y: 30 with width and height 5 will be drawn.
+
+@name Drawable
+@module
+@constructor
+@param {Object} I Instance variables
+@param {Core} self Reference to including object
+###
+
+###*
+Triggered every time the object should be drawn. A canvas is passed as
+the first argument.
+
+    player = Core
+      x: 0
+      y: 10
+      width: 5
+      height: 5
+
+    player.bind "draw", (canvas) ->
+      # Text will be drawn positioned relatively to the object.
+      canvas.drawText
+        text: "Hey, drawing stuff is pretty easy."
+        color: "white"
+        x: 5
+        y: 5
+
+@name draw
+@methodOf Drawable#
+@event
+@param {PowerCanvas} canvas A reference to the canvas to draw on.
+###
+
+###*
+Triggered before the object should be drawn. A canvas is passed as
+the first argument. This does not apply the current transform.
+
+@name beforeTransform
+@methodOf Drawable#
+@event
+@param {PowerCanvas} canvas A reference to the canvas to draw on.
+###
+
+###*
+Triggered after the object should be drawn. A canvas is passed as
+the first argument. This applies the current transform.
+
+@name afterTransform
+@methodOf Drawable#
+@event
+@param {PowerCanvas} canvas A reference to the canvas to draw on.
+###
+
+Drawable = (I={}, self) ->
+  Object.reverseMerge I,
+    alpha: 1
+    color: "#196"
+    scale: 1
+    scaleX: 1
+    scaleY: 1
+    zIndex: 0
+
+  cachedSprite = null
+
+  self.unbind ".Drawable"
+
+  self.bind 'draw.Drawable', (canvas) ->
+    if I.alpha? and I.alpha != 1
+      previousAlpha = canvas.context().globalAlpha
+      canvas.context().globalAlpha = I.alpha
+
+    if sprite = self.sprite()
+      if sprite.draw?
+        sprite.draw(canvas, -sprite.width / 2, -sprite.height / 2)
+      else
+        warn?("Sprite has no draw method!")
+    else
+      if I.radius?
+        canvas.drawCircle
+          x: 0
+          y: 0
+          radius: I.radius
+          color: I.color
+      else
+        canvas.drawRect
+          x: -I.width/2
+          y: -I.height/2
+          width: I.width
+          height: I.height
+          color: I.color
+
+    if I.alpha? and I.alpha != 1
+      canvas.context().globalAlpha = previousAlpha
+
+  ###*
+  Draw does not actually do any drawing itself, instead it triggers all of the draw events.
+  Listeners on the events do the actual drawing.
+
+  @name draw
+  @methodOf Drawable#
+  @returns self
+  ###
+  draw: (canvas) ->
+    self.trigger 'beforeTransform', canvas
+
+    canvas.withTransform self.transform(), (canvas) ->
+      self.trigger 'beforeDraw', canvas
+      self.trigger 'draw', canvas
+      self.trigger 'afterDraw', canvas
+
+    self.trigger 'afterTransform', canvas
+
+    return self
+
+  sprite: (newSprite) ->
+    if newSprite?
+      cachedSprite = newSprite
+    else
+      if I.sprite
+        Sprite.loadByName(I.sprite)
+
+  ###*
+  Returns the current transform, with translation, rotation, and flipping applied.
+
+  @name transform
+  @methodOf Drawable#
+  @returns {Matrix} The current transform
+  ###
+  transform: ->
+    center = self.center()
+
+    transform = Matrix.translation(center.x.floor(), center.y.floor())
+
+    transform = transform.concat(Matrix.scale(I.scale * I.scaleX, I.scale * I.scaleY))
+    transform = transform.concat(Matrix.rotation(I.rotation)) if I.rotation
+
+    if I.spriteOffset
+      transform = transform.concat(Matrix.translation(I.spriteOffset.x, I.spriteOffset.y))
+
+    return transform

data/source/dust_emitter.coffee

@@ -0,0 +1,36 @@
+DustParticle = (I={}, self) ->
+  Object.extend I,
+    color: 'rgb(100, 100, 100)'
+    duration: 0.2
+    fadeOut: true
+    maxSpeed: 90
+    
+  I.velocity = [
+    Point(-60, -30)
+    Point(40, -15)
+    Point(-20, -7)
+    Point(60, -30)
+    Point(40, -15)
+    Point(20, -7)
+  ].rand()
+  
+  I.acceleration = Point(0, 60)
+         
+  return {}
+
+DustEmitter = (I={}) ->
+  Object.reverseMerge I,
+    duration: 3
+    particleCount: 20
+    batchSize: 5
+    x: 0
+    y: 0
+    zIndex: 50
+    generator:
+      includedModules: ["DustParticle"]
+      radius: (n) ->
+        [2, 3, 1].wrap(n)
+
+  self = Emitter(I)
+
+  return self

data/source/easing.coffee

@@ -0,0 +1,38 @@
+( ->
+  Easing =
+    sinusoidal: (begin, end) ->
+      change = end - begin
+      (t) -> begin + change * (1 - Math.cos(t * Math.TAU / 4))
+
+    sinusoidalOut: (begin, end) ->
+      change = end - begin
+      (t) -> begin + change * (0 + Math.sin(t * Math.TAU / 4))
+
+  polynomialEasings = ["linear", "quadratic", "cubic", "quartic", "quintic"]
+
+  polynomialEasings.each (easing, i) ->
+    exponent = i + 1
+    sign = if exponent % 2 then 1 else -1
+
+    Easing[easing] = (begin, end) ->
+      change = (end - begin)
+      (t) -> begin + change * Math.pow(t, exponent)
+
+    Easing["#{easing}Out"] = (begin, end) ->
+      change = end - begin
+      (t) -> begin + change * (1 + sign * Math.pow(t - 1, exponent))
+
+  ["sinusoidal"].concat(polynomialEasings).each (easing) ->
+    Easing["#{easing}InOut"] = (begin, end) ->
+      midpoint = (begin + end)/2
+      easeIn = Easing[easing](begin, midpoint)
+      easeOut = Easing["#{easing}Out"](midpoint, end)
+
+      (t) ->
+        if t < 0.5
+          easeIn(2 * t)
+        else
+          easeOut(2 * t - 1)
+
+  (exports ? this)["Easing"] = Easing
+)()

data/source/emitter.coffee

@@ -0,0 +1,7 @@
+# Just a placeholder class if you don't want to include the module yourself.
+Emitter = (I={}) ->
+  self = GameObject(I)
+  
+  self.include "Emitterable"
+
+  return self

data/source/emitterable.coffee

@@ -0,0 +1,68 @@
+# TODO: LOL at name
+Emitterable = (I={}, self) ->
+  Object.reverseMerge I,
+    batchSize: 1
+    emissionRate: 1
+    width: 0
+    height: 0
+    sprite: Sprite.EMPTY
+    generator: {}
+    particles: []
+    particleCount: Infinity
+    x: I.x
+    y: I.y
+    particleData:
+      acceleration: Point(0, 0.1)
+      age: 0
+      color: "blue"
+      duration: 1.5
+      height: 2
+      maxSpeed: 120
+      offset: Point(0, 0)
+      sprite: false
+      spriteName: false
+      velocity: Point(-0.25, 1)
+      width: 2
+      x: 0
+      y: 0
+
+  n = 0
+
+  self.bind 'draw', (canvas) ->
+    I.particles.invoke "draw", canvas
+
+  self.bind 'overlay', (canvas) ->
+    I.particles.invoke "trigger", "overlay", canvas
+
+  self.bind 'beforeUpdate', (dt) ->
+    I.particles.invoke "trigger", "beforeUpdate", dt
+
+  self.bind 'afterUpdate', (dt) ->
+    I.particles.invoke "trigger", "afterUpdate", dt
+
+  self.bind 'update', (dt) ->
+    I.batchSize.times ->
+      if n < I.particleCount && rand() < I.emissionRate
+        particleProperties = Object.extend {}, I.particleData
+
+        for key, value of I.generator
+          if I.generator[key].call
+            particleProperties[key] = I.generator[key](n, I)
+          else
+            particleProperties[key] = I.generator[key]
+
+        particleProperties.x += particleProperties.offset.x
+        particleProperties.y += particleProperties.offset.y
+
+        I.particles.push(GameObject(particleProperties))
+
+        n += 1
+
+    I.particles = I.particles.select (particle) ->
+      particle.update(dt)
+
+    if n == I.particleCount && !I.particles.length
+      I.active = false
+
+  return {}
+