pixie_dust 0.0.1

data/source/engine.selector.coffee

@@ -0,0 +1,166 @@
+###*
+The <code>Selector</code> module provides methods to query the engine to find game objects.
+
+@name Selector
+@fieldOf Engine
+@module
+@param {Object} I Instance variables
+@param {Object} self Reference to the engine
+###
+Engine.Selector = (I, self) ->
+
+  instanceMethods =
+    set: (attr, value) ->
+      this.each (item) ->
+        item.I[attr] = value
+
+  ###*
+  Get the game object matching the given selector that is closest to the given position.
+
+      player = engine.add
+        x: 0
+        y: 0
+    
+      enemy1 = engine.add
+        enemy: true
+        x: 10
+        y: 0
+    
+      enemy2 = engine.add
+        enemy: true
+        x: 0
+        y: 15
+    
+      player2 = engine.add
+        x: 0
+        y: 10
+    
+      equals engine.closest(".enemy", player.position()), enemy1
+      equals engine.closest(".enemy", player2.position()), enemy2
+
+  @name closest
+  @methodOf Engine.selector
+  @param {String} selector
+  @param {Point} position
+  ###
+  closest: (selector, position) ->
+    self.find(selector).sort (a, b) ->
+      Point.distanceSquared(position, a.position()) - Point.distanceSquared(position, b.position())
+    .first()
+
+  ###*
+  Get a selection of GameObjects that match the specified selector criteria. The selector language
+  can select objects by id, class, or attributes. Note that this method always returns an Array,
+  so if you are trying to find only one object you will need something like <code>engine.find("Enemy").first()</code>.
+
+      player = engine.add
+        class: "Player"
+    
+      enemy = engine.add
+        class: "Enemy"
+        speed: 5
+        x: 0
+    
+      distantEnemy = engine.add
+        class "Enemy"
+        x: 500
+    
+      boss = engine.add
+        class: "Enemy"
+        id: "Boss"
+        x: 0
+    
+      # to select an object by id use "#anId"
+      engine.find "#Boss"
+      # => [boss]
+    
+      # to select an object by class use "MyClass"
+      engine.find "Enemy"
+      # => [enemy, distantEnemy, boss]
+    
+      # to select an object by properties use ".someProperty" or ".someProperty=someValue"
+      engine.find ".speed=5"
+      # => [enemy]
+    
+      # You may mix and match selectors.
+      engine.find "Enemy.x=0"
+      # => [enemy, boss] # doesn't return distantEnemy
+
+  @name find
+  @methodOf Engine#
+  @param {String} selector
+  @returns {Array} An array of the objects found
+  ### 
+  each: (selector, fn) ->
+    self.find(selector).each (obj, index) ->
+      fn(obj, index)
+
+  ###*
+  Find all game objects that match the given selector.
+
+  @name find
+  @methodOf Engine.selector
+
+  @param {String} selector
+  ###
+  find: (selector) ->
+    results = []
+
+    matcher = Engine.Selector.generate(selector)
+
+    self.objects().each (object) ->
+      results.push object if matcher.match object
+
+    Object.extend results, instanceMethods
+
+  ###*
+  Find the first game object that matches the given selector.
+
+  @name find
+  @methodOf Engine.selector
+
+  @param {String} selector
+  ###
+  first: (selector) ->
+    self.find(selector).first()
+
+Object.extend Engine.Selector,
+  parse: (selector) ->
+    selector.split(",").invoke("trim")
+
+  process: (item) ->
+    result = /^(\w+)?#?([\w\-]+)?\.?([\w\-]+)?=?([\w\-]+)?/.exec(item)
+
+    if result
+      result[4] = result[4].parse() if result[4]
+
+      result.splice(1)
+    else
+      []
+
+  generate: (selector) ->
+    components = Engine.Selector.parse(selector).map (piece) ->
+      Engine.Selector.process(piece)
+
+    TYPE = 0
+    ID = 1
+    ATTR = 2
+    ATTR_VALUE = 3
+
+    match: (object) ->
+      for component in components
+        idMatch = (component[ID] == object.I.id) || !component[ID]
+        typeMatch = (component[TYPE] == object.I.class) || !component[TYPE]
+
+        if attr = component[ATTR]
+          if (value = component[ATTR_VALUE])? 
+            attrMatch = (object.I[attr] == value)
+          else
+            attrMatch = object.I[attr]
+        else
+          attrMatch = true
+
+        return true if idMatch && typeMatch && attrMatch
+
+      return false
+

data/source/engine.stats.coffee

@@ -0,0 +1,16 @@
+###*
+The <code>Stats</code> module provides methods to query the engine to find game objects.
+
+@name Stats
+@fieldOf Engine
+@module
+@param {Object} I Instance variables
+@param {Object} self Reference to the engine
+###
+Engine.Stats = (I, self) ->
+  measure: (objects, field, frequency=30) ->
+    ; #TODO
+
+  gatherData: ->
+    self.find()
+

data/source/engine.tilemap.coffee

@@ -0,0 +1,41 @@
+###*
+The <code>Tilemap</code> module provides a way to load tilemaps in the engine.
+
+@name Tilemap
+@fieldOf Engine
+@module
+
+@param {Object} I Instance variables
+@param {Object} self Reference to the engine
+###
+Engine.Tilemap = (I, self) ->
+  Object.extend I,
+    map: null
+
+  updating = false
+  clearObjects = false
+
+  self.bind "update", ->
+    updating = true
+
+  self.bind "afterUpdate", ->
+    updating = false
+
+    if clearObjects
+      #TODO: Clear these out in a more graceful way, triggering unload events
+      self.objects().clear()
+      clearObjects = false
+
+  ###*
+  Loads a new may and unloads any existing map or entities.
+
+  @name loadMap
+  @methodOf Engine#
+  ###
+  loadMap: (name, complete) ->
+    clearObjects = updating
+
+    I.map = Tilemap.load
+      name: name
+      complete: complete
+      entity: self.add

data/source/engine_background.coffee

@@ -0,0 +1,32 @@
+###*
+This module clears or fills the canvas before drawing the scene.
+
+@name Clear
+@fieldOf Engine
+@module
+@param {Object} I Instance variables
+@param {Object} self Reference to the engine
+###
+
+Engine.Background = (I, self) ->
+  Object.reverseMerge I,
+    background: null
+    backgroundColor: "#00010D"
+    clear: false
+
+  self.attrAccessor "clear", "backgroundColor"
+
+  self.bind "init", ->
+    if I.background?.isString?()
+      I.background = Sprite.loadByName I.background
+
+  self.bind "beforeDraw", ->
+    if I.clear
+      I.canvas.clear()
+    else if I.background
+      I.background.fill(I.canvas, 0, 0, App.width, App.height)
+    else if I.backgroundColor
+      I.canvas.fill(I.backgroundColor)
+
+  # No public methods
+  return {}

data/source/expirable.coffee

@@ -0,0 +1,47 @@
+###*
+The Expirable module deactivates a <code>GameObject</code> after a specified duration.
+If a duration is specified the object will update that many times. If -1 is
+specified the object will have an unlimited duration.
+
+This module is included by default in <code>GameObjects</code>
+
+    enemy = GameObject
+      x: 50
+      y: 30
+      duration: 5
+    
+    enemy.include Expirable
+    
+    enemy.I.active
+    # => true
+    
+    5.times ->
+      enemy.update(1)
+    
+    enemy.I.active
+    # => false
+
+@name Expirable
+@module
+@constructor
+@param {Object} I Instance variables
+@param {Core} self Reference to including object
+###
+Expirable = (I={}, self) ->
+  Object.reverseMerge I,
+    duration: -1
+    alpha: 1
+    fadeOut: false
+
+  startingAlpha = I.alpha
+
+  self.bind "update", (dt) ->
+    if I.fadeOut
+      I.alpha = startingAlpha * (1 - (I.age / I.duration))
+
+    if I.duration != -1 && I.age >= I.duration
+      I.active = false
+      
+    I.alpha = I.alpha.clamp(0, 1)
+
+  return {}

data/source/flickerable.coffee

@@ -0,0 +1,78 @@
+###*
+The `Flickerable` module provides a method to flicker a sprite between its current opacity (alpha) and a given opacity. 
+
+    player = GameObject
+      alpha: 0.9
+
+    player.include 'Flickerable'
+
+    # called with no arguments, flicker will toggle the player's alpha 
+    # value between 0.9 (value provided above) and 0.5 (flickerable default) 
+    # every 0.1 second, for a total of 2 seconds
+    player.flicker()
+
+@name Flickerable
+@module
+@constructor
+@param {Object} I Instance variables
+@param {Core} self Reference to including object
+###
+Flickerable = (I={}, self) ->
+  Object.reverseMerge I,
+    flickerAlpha: 0.5
+    flickerDuration: 0
+    flickerFrequency: 0.1
+
+  originalAlpha = I.alpha
+  frequencyLength = 0
+
+  self.bind 'update', (elapsedTime) ->
+    I.flickerDuration = I.flickerDuration.approach(0, elapsedTime)
+
+    frequencyLength += elapsedTime
+    
+    if I.flickerDuration > 0
+      if frequencyLength >= I.flickerFrequency
+        frequencyLength = 0
+        
+        if I.alpha is I.flickerAlpha
+          I.alpha = originalAlpha
+        else
+          I.alpha = I.flickerAlpha
+    else
+      I.alpha = originalAlpha
+
+  ###*
+  A convenient way to set the flicker instance variables on a sprite. You can modify the
+  instance variables by hand but the suggested way to do it is through this method.
+
+      player = GameObject()
+    
+      player.include(Flickerable)
+        
+      player.flicker
+        duration: 5
+        frequency: 0.2
+        alpha: 0.3
+
+      # => This causes the sprite to flicker between full opacity
+      # => and 30% opacity every 0.2 seconds for 5 seconds
+
+  @name flicker
+  @methodOf Flickerable#
+  @param {Number} [duration=2] How long the effect lasts in seconds
+  @param {Number} [frequency=0.1] Number of seconds in between opacity changes
+  @param {Number} [alpha=0.5] Alpha value to toggle between
+  @returns {GameObject} The calling object
+  ###
+  flicker: (options={}) ->
+    Object.reverseMerge options, 
+      duration: 2
+      frequency: 0.1
+      alpha: 0.5
+    
+    I.flickerDuration = options.duration
+    I.flickerFrequency = options.frequency
+    I.flickerAlpha = options.alpha
+
+    return self

data/source/follow.coffee

@@ -0,0 +1,65 @@
+###*
+The Follow module provides a simple method to set an object's
+direction so that it is pointed at another object.
+
+The calculated direction is based on the center point of 
+each object.
+
+This method relies on both objects having <code>position</code> methods. 
+
+Include this module by calling <code>self.include Follow</code>
+
+    player = GameObject
+      x: 50
+      y: 50
+      width: 10
+      height: 10
+    
+    enemy = GameObject
+      x: 100
+      y: 50
+      width: 10
+      height: 10
+      velocity: Point(0, 0)
+      speed: 2
+    
+    enemy.include Follow
+    
+    # Make an enemy follow the player
+    enemy.follow(player)
+    
+    # now the enemy's direction will point toward the player
+    enemy.I.direction
+    # => Point(-1, 0)
+    
+    # you can use this direction to set a velocity for your object.
+    enemy.I.velocity = enemy.I.direction.scale(I.speed)
+    
+
+@name Follow
+@module
+@constructor
+@param {Object} I Instance variables
+@param {Core} self Reference to including object
+###
+Follow = (I={}, self) ->
+  Object.reverseMerge I,
+    velocity: Point(0, 0)
+    speed: 1
+
+  ###*
+  Set your velocity to follow another object.
+
+      enemy.follow(player)
+    
+      # => The enemy now has it's velocity attribute set in
+      # the direction of the player, with magnitude equal to
+      # the enemy's speed
+
+  @name follow
+  @methodOf Follow#
+  @param {GameObject} obj The object you want to follow
+  ###    
+  follow: (obj) ->
+    if obj
+      I.velocity = obj.position().subtract(self.position()).norm(I.speed)

data/source/framerate.coffee

@@ -0,0 +1,42 @@
+###*
+This object keeps track of framerate and displays it by creating and appending an
+html element to the DOM.
+
+Once created you call snapshot at the end of every rendering cycle.
+
+@name Framerate
+@constructor
+###
+Framerate = (options={}) ->
+  numFramerates = 15
+  framerateUpdateInterval = 250
+
+  renderTime = -1
+  framerates = [ ]
+
+  updateFramerate = ->
+    self.fps = framerates.average().round()
+
+  setInterval(updateFramerate, framerateUpdateInterval)
+
+  ###*
+  Call this method everytime you render.
+
+  @name rendered
+  @methodOf Framerate#
+  ###
+  self =
+    rendered: ->
+      if renderTime < 0
+        renderTime = new Date().getTime()
+      else
+        newTime = new Date().getTime()
+        t = newTime - renderTime
+
+        framerate = 1000 / t
+        framerates.push(framerate)
+
+        while (framerates.length > numFramerates)
+            framerates.shift()
+
+        renderTime = newTime

data/source/game_object.coffee

@@ -0,0 +1,181 @@
+###*
+The default base class for all objects you can add to the engine.
+
+GameObjects fire events that you may bind listeners to. Event listeners 
+may be bound with <code>object.bind(eventName, callback)</code>
+
+@name GameObject
+@extends Core
+@constructor
+@instanceVariables age, active, created, destroyed, solid, includedModules, excludedModules
+###
+
+###*
+Triggered when the object is created.
+
+    enemyCount = 0
+    
+    enemy = engine.add
+      class: "Enemy"
+    
+    enemy.bind 'create', ->
+      enemyCount++
+
+@name create
+@methodOf GameObject#
+@event
+###
+
+###*
+Triggered when object is destroyed. Use 
+the destroy event to add particle effects, play sounds, etc.
+
+    bomb = GameObject()
+    
+    bomb.bind 'destroy', ->
+      bomb.explode()
+      Sound.play "Kaboom"
+
+@name destroy
+@methodOf GameObject#
+@event
+###
+
+###*
+Triggered during every update step.
+
+    player = GameObject()
+    
+    player.bind 'step', ->
+      # check to see if keys are being pressed and 
+      # change the player's velocity
+      if keydown.left
+        player.velocity(Point(-1, 0))
+      else if keydown.right
+        player.velocity(Point(1, 0))
+      else
+        player.velocity(Point(0, 0))
+
+@name step
+@methodOf GameObject#
+@event
+###
+
+###*
+Triggered every update after the <code>step</code> event is triggered.
+
+    player = GameObject()
+    
+    # we can really use the update and 
+    # step events almost interchangebly
+    player.bind 'update', ->
+      # check to see if keys are being pressed and 
+      # change the player's velocity
+      if keydown.left
+        player.velocity(Point(-1, 0))
+      else if keydown.right
+        player.velocity(Point(1, 0))
+      else
+        player.velocity(Point(0, 0))
+
+@name update
+@methodOf GameObject#
+@event
+###
+
+###*
+Triggered when the object is removed from
+the engine. Use the remove event to handle any clean up.
+
+    boss = GameObject()
+    
+    boss.bind 'remove', ->
+      unlockDoorToLevel2()
+
+@name remove
+@methodOf GameObject#
+@event
+###
+
+GameObject = (I) ->
+  I ||= {}
+
+  ###*
+  @name {Object} I Instance variables 
+  @memberOf GameObject#
+  ###
+  Object.reverseMerge I,
+    active: true
+    created: false
+    destroyed: false
+
+  self = Core(I).extend {
+    ###*
+    Update the game object. This is generally called by the engine.
+
+    @name update
+    @methodOf GameObject#
+    ###
+    update: (elapsedTime) ->
+      #TODO Extract this I.active check out into an engine gameObject remove processor or something
+      if I.active
+        self.trigger 'update', elapsedTime
+
+      I.active
+
+    ###*
+    Triggers the create event if the object has not already been created.
+
+    @name create
+    @methodOf GameObject#
+    ###
+    create: ->
+      self.trigger('create') unless I.created
+      I.created = true
+
+    ###*
+    Destroys the object and triggers the destroyed event.
+
+    @name destroy
+    @methodOf GameObject#
+    ###
+    destroy: ->
+      self.trigger('destroy') unless I.destroyed
+
+      I.destroyed = true
+      I.active = false
+  }
+
+  GameObject.defaultModules.each (moduleName) ->
+    self.include moduleName
+
+  self
+
+GameObject.defaultModules = [
+  "Ageable"
+  "Bounded"
+  "Clampable"
+  "Cooldown"
+  "Drawable"
+  "Expirable"
+  "Follow"
+  "GameObject.Meter"
+  "Movable"
+  "Rotatable"
+  "TimedEvents"
+  "Tween"
+  "GameObject.Effect"
+]
+
+###*
+Construct an object instance from the given entity data.
+@name construct
+@memberOf GameObject
+@param {Object} entityData
+###
+GameObject.construct = (entityData) ->
+  if entityData.class
+    entityData.class.constantize()(entityData)
+  else
+    GameObject(entityData)
+

data/source/game_object.effect.coffee

@@ -0,0 +1,33 @@
+###*
+A collection of effects to make your game juicy.
+
+@name Effect
+@fieldOf GameObject
+@module
+@constructor
+@param {Object} I Instance variables
+@param {Core} self Reference to including object
+###
+GameObject.Effect = (I={}, self) ->
+
+  ###*
+  A convenient way to fade out this object over time.
+
+      player = GameObject()
+
+      # Fade the player object out over the next 2 seconds. 
+      player.fadeOut 2
+
+      # Fade out and then destroy
+      player.fadeOut, 0.25, ->
+        self.destroy()
+
+  @name fadeOut
+  @methodOf GameObject#
+  @param {Number} [duration=1] Time to fade out in seconds
+  @param {Function} [complete=null] The function to execute when fade out completes.
+  ###
+  fadeOut: (duration=1, complete) ->
+    self.tween duration,
+      alpha: 0
+      complete: complete