pixie_dust 0.0.1

data/source/sprite.coffee

@@ -0,0 +1,181 @@
+###*
+The Sprite class provides a way to load images for use in games.
+
+By default, images are loaded asynchronously. A proxy object is
+returned immediately. Even though it has a draw method it will not
+draw anything to the screen until the image has been loaded.
+
+@name Sprite
+@constructor
+###
+
+( ->
+  LoaderProxy = ->
+    draw: ->
+    fill: ->
+    frame: ->
+    update: ->
+    width: null
+    height: null
+    image: null
+
+  # Cache loaded images
+  spriteCache = {}
+
+  Sprite = (image, sourceX, sourceY, width, height) ->
+    sourceX ||= 0
+    sourceY ||= 0
+    width ||= image.width
+    height ||= image.height
+
+    ###*
+    Draw this sprite on the given canvas at the given position.
+
+    @name draw
+    @methodOf Sprite#
+    @param {PowerCanvas} canvas Reference to the canvas to draw the sprite on
+    @param {Number} x Position on the x axis to draw the sprite
+    @param {Number} y Position on the y axis to draw the sprite
+    ###
+    draw: (canvas, x, y) ->
+      canvas.drawImage(
+        image,
+        sourceX,
+        sourceY,
+        width,
+        height,
+        x,
+        y,
+        width,
+        height
+      )
+
+    ###*
+    Draw this sprite on the given canvas tiled to the x, y,
+    width, and height dimensions specified.
+
+    @name fill
+    @methodOf Sprite#
+    @param {PowerCanvas} canvas Reference to the canvas to draw the sprite on
+    @param {Number} x Position on the x axis to draw the sprite
+    @param {Number} y Position on the y axis to draw the sprite
+    @param {Number} width How far to tile the sprite on the x-axis
+    @param {Number} height How far to tile the sprite on the y-axis
+    @param {String} repeat Repeat options. Can be `repeat-x`, `repeat-y`, `no-repeat`, or `repeat`. Defaults to `repeat`
+    ###
+    fill: (canvas, x, y, width, height, repeat="repeat") ->
+      pattern = canvas.createPattern(image, repeat)
+      canvas.drawRect({x, y, width, height, color: pattern})
+
+    width: width
+    height: height
+    image: image
+
+  ###*
+  Loads all sprites from a sprite sheet found in
+  your images directory, specified by the name passed in.
+
+  @name loadSheet
+  @methodOf Sprite
+  @param {String} name Name of the spriteSheet image in your images directory
+  @param {Number} tileWidth Width of each sprite in the sheet
+  @param {Number} tileHeight Height of each sprite in the sheet
+  @returns {Array} An array of sprite objects
+  ###
+  Sprite.loadSheet = (name, tileWidth, tileHeight) ->
+    url = ResourceLoader.urlFor("images", name)
+
+    sprites = []
+    image = new Image()
+
+    image.onload = ->
+      imgElement = this
+      (image.height / tileHeight).times (row) ->
+        (image.width / tileWidth).times (col) ->
+          sprites.push(Sprite(imgElement, col * tileWidth, row * tileHeight, tileWidth, tileHeight))
+
+    image.src = url
+
+    return sprites
+
+  ###*
+  Loads a sprite from a given url.
+
+  @name load
+  @methodOf Sprite
+  @param {String} url
+  @param {Function} [loadedCallback]
+  @returns {Sprite} A sprite object
+  ###
+  Sprite.load = (url, loadedCallback) ->
+    if sprite = spriteCache[url]
+      loadedCallback?.defer(sprite)
+      return sprite
+
+    img = new Image()
+    proxy = LoaderProxy()
+
+    img.onload = ->
+      spriteCache[url] = Object.extend(proxy, Sprite(this))
+
+      loadedCallback?(proxy)
+
+    img.src = url
+
+    return proxy
+
+  ###*
+  Loads a sprite with the given pixie id.
+
+  @name fromPixieId
+  @methodOf Sprite
+  @param {Number} id Pixie Id of the sprite to load
+  @param {Function} [callback] Function to execute once the image is loaded. The sprite proxy data is passed to this as a parameter.
+  @returns {Sprite}
+  ###
+  Sprite.fromPixieId = (id, callback) ->
+    Sprite.load("http://pixieengine.com/s3/sprites/#{id}/original.png", callback)
+
+  ###*
+  A sprite that draws nothing.
+
+  @name EMPTY
+  @fieldOf Sprite
+  @constant
+  @returns {Sprite}
+  ###
+  ###*
+  A sprite that draws nothing.
+
+  @name NONE
+  @fieldOf Sprite
+  @constant
+  @returns {Sprite}
+  ###
+  Sprite.EMPTY = Sprite.NONE = LoaderProxy()
+
+  ###*
+  Loads a sprite from a given url.
+
+  @name fromURL
+  @methodOf Sprite
+  @param {String} url The url where the image to load is located
+  @param {Function} [callback] Function to execute once the image is loaded. The sprite proxy data is passed to this as a parameter.
+  @returns {Sprite}
+  ###
+  Sprite.fromURL = Sprite.load
+
+  ###*
+  Loads a sprite with the given name.
+
+  @name loadByName
+  @methodOf Sprite
+  @param {String} name The name of the image in your images directory
+  @param {Function} [callback] Function to execute once the image is loaded. The sprite proxy data is passed to this as a parameter.
+  @returns {Sprite}
+  ###
+  Sprite.loadByName = (name, callback) ->
+    Sprite.load(ResourceLoader.urlFor("images", name), callback)
+
+  (exports ? this)["Sprite"] = Sprite
+)()

data/source/text_effect.coffee

@@ -0,0 +1,74 @@
+###*
+The Text Effect class provides a method to display moving text onscreen, fading out the text over the effect duration.
+
+    # adds a TextEffect to the engine at (60, 100)
+    engine.add 'TextEffect'
+      x: 60
+      y: 100
+
+@name TextEffect
+@constructor
+###
+
+###*
+Updates the position of the text based on the effect velocity. Updates the 
+alpha based on the elapsed time since the effect creation.
+
+@name update
+@methodOf TextEffect#
+@event
+###
+
+###*
+Draws text from `I.textShadow` `I.text`.
+
+@name draw
+@methodOf TextEffect#
+@param {PixieCanvas} canvas
+@event
+###
+TextEffect = (I={}) ->
+  Object.reverseMerge I,
+    color: Color('green')
+    duration: -1
+    font: '20px Helvetica'
+    text: '100'
+    textShadow: Color('black')
+    alpha: 1
+    rotation: 0
+    velocity: Point(0, 0)
+    
+  self = GameObject(I)
+
+  self.bind "update", ->  
+    I.rotation += I.rotationalVelocity if I.rotationalVelocity?
+  
+    I.alpha = (1 - (I.age / I.duration)).clamp(0, 1)
+        
+  self.unbind "draw"
+  self.bind "draw", (canvas) ->      
+    unless I.color.channels
+      I.color = Color(I.color)
+    
+    unless I.textShadow.channels
+      I.textShadow = Color(I.textShadow)
+      
+    I.color.a = I.alpha
+    I.textShadow.a = I.alpha
+    
+    I.width = canvas.measureText(I.text)
+        
+    canvas.font I.font
+    canvas.drawText
+      color: I.textShadow
+      x: 1 - I.width
+      y: 1
+      text: I.text    
+
+    canvas.drawText
+      color: I.color
+      x: 0 - I.width
+      y: 0
+      text: I.text
+
+  return self

data/source/text_effect.floating.coffee

@@ -0,0 +1,22 @@
+###*
+`TextEffect.Floating` is a simple subclass of `TextEffect`. It provides some defaults
+to move the text upward and fade it out over 0.5 seconds.
+
+    # adds a FloatingTextEffect to the engine
+    # at (50, 50). This effect will float upward
+    # at 90 pixels/sec and will fadeOut over 0.5 seconds
+    engine.add 'TextEffect.Floating'
+      x: 50
+      y: 50
+
+@see TextEffect
+@name Floating
+@fieldOf TextEffect
+@constructor
+###
+TextEffect.Floating = (I={}) ->
+  Object.reverseMerge I,
+    duration: 0.5
+    velocity: Point(0, -90)
+
+  return TextEffect(I)

data/source/text_screen.coffee

@@ -0,0 +1,38 @@
+###*
+The Text Screen class is a GameState that provides convenience methods for drawing text to screen. 
+
+@name TextScreen
+@constructor
+###
+TextScreen = (I={}) ->
+  Object.reverseMerge I,
+    font: 'Helvetica'
+    fontSize: 24
+    fontColor: 'white'
+    yPosition: App.height / 2
+
+  self = GameState(I).extend
+    ###*
+    Draw center aligned text at the given y position.
+  
+        screen = TextScreen()
+        screen.centerText canvas, 'Centering text is easy'
+  
+    @name centerText
+    @methodOf TextScreen#
+    @param {PixieCanvas} canvas The canvas to draw on    
+    @param {String} text The text to draw
+    @param {Object} options These include font, size, color, and yPosition
+    ###   
+    centerText: (canvas, text, options={}) ->
+      font = options.font || I.font
+      size = options.size || I.fontSize
+      color = options.color || I.fontColor
+      yPosition = options.y || I.yPosition
+
+      canvas.font "#{size}px #{font}"
+
+      canvas.centerText
+        y: yPosition
+        text: text
+        color: color

data/source/tilemap.coffee

@@ -0,0 +1,56 @@
+( ->
+  Map = (data, entityCallback) ->
+    tileHeight = data.tileHeight
+    tileWidth = data.tileWidth
+
+    spriteLookup = {}
+
+    for uuid, entity of App.entities
+      spriteLookup[uuid] = Sprite.fromURL(entity.tileSrc)
+
+    loadEntities = () ->
+      return unless entityCallback
+
+      data.layers.each (layer, layerIndex) ->
+        if instances = layer.instances
+          for instance in instances
+            {x, y, uuid} = instance
+
+            instanceData = Object.extend(
+              layer: layerIndex
+              sprite: spriteLookup[uuid]
+              x: x + tileWidth/2 # Centered Coordinates
+              y: y + tileHeight/2 # Centered Coordinates
+            , App.entities[uuid] # Global entity properties
+            #TODO: Maybe map specific properties?
+            , instance.properties) # Instance properties
+
+            entityCallback(instanceData)
+
+    loadEntities()
+
+    data
+
+  Tilemap = (name, callback, entityCallback) ->
+    fromPixieId(App.Tilemaps[name], callback, entityCallback)
+
+  loadByName = (name, callback, entityCallback) ->
+    url = ResourceLoader.urlFor("tilemaps", name)
+
+    proxy = {}
+
+    $.getJSON url, (data) ->
+      Object.extend(proxy, Map(data, entityCallback))
+
+      callback? proxy
+
+    return proxy
+
+  Tilemap.load = (options) ->
+    if options.pixieId
+      fromPixieId options.pixieId, options.complete, options.entity
+    else if options.name
+      loadByName options.name, options.complete, options.entity
+
+  (exports ? this)["Tilemap"] = Tilemap
+)()

data/source/timed_events.coffee

@@ -0,0 +1,78 @@
+###*
+The TimedEvents module allows arbitrary code to be executed at set intervals. <code>GameObject</code> includes this module by default
+
+TimedEvents module
+@name TimedEvents
+@module
+@constructor
+@param {Object} I Instance variables
+###
+TimedEvents = (I={}, self) ->
+  Object.reverseMerge I,
+    everyEvents: []
+    delayEvents: []
+
+  self.bind "update", (elapsedTime) ->
+    for event in I.everyEvents
+      {fn, period} = event
+      while event.lastFired < I.age + elapsedTime
+        self.sendOrApply(fn)
+        event.lastFired += period
+
+    [I.delayEvents, firingEvents] = I.delayEvents.partition (event) ->
+      (event.delay -= elapsedTime) >= 0
+
+    firingEvents.each (event) ->
+      self.sendOrApply(event.fn)
+
+  ###*
+  Execute <code>fn</code> every <code>n</code> frames.
+
+      player = GameObject()
+      
+      player.include TimedEvents
+      
+      # doSomething is called every 4 seconds
+      player.every 4, ->
+        doSomething()
+
+  @name every
+  @methodOf TimedEvents#
+  @param {Number} n Number of frames to wait before executing the callback
+  @param {Function} fn Code to execute after <code>n</code> frames has passed
+  ###
+  every: (period, fn) ->
+    return unless period > 0
+
+    I.everyEvents.push
+      fn: fn
+      period: period
+      lastFired: I.age
+      
+    ###*
+  Execute a callback after a number of seconds have passed.
+
+      self.delay 5, ->
+        engine.add
+          class: "Ghost"
+
+  @name delay
+  @methodOf TimedEvents#
+  @param {Number} steps The number of steps to wait before executing the callback
+  @param {Function} callback The callback to be executed.
+
+  @returns {Engine} self
+  ###
+  delay: (seconds, fn) ->
+    I.delayEvents.push
+      delay: seconds
+      fn: fn
+
+    return self
+
+  # TODO: Move this into a more core module
+  sendOrApply: (fn, args...) ->
+    if typeof fn is "function"
+      fn.apply(self, args)
+    else
+      self.send(fn, args...)

data/source/title_screen.coffee

@@ -0,0 +1,38 @@
+###*
+The Title Screen class sets up a simple game title screen using <code>App.name</code>
+
+@see TextScreen
+@name TitleScreen
+@constructor
+###
+
+###*
+Goes to the next level on any user input.
+
+@name update
+@methodOf TitleScreen#
+@event
+###
+
+###*
+Overlays the title text in the middle of the screen. Uses <code>App.name</code> 
+
+@name overlay
+@methodOf TitleScreen#
+@param {PixieCanvas} canvas
+@event
+###
+TitleScreen = (I={}) ->
+  self = TextScreen(I)
+
+  self.bind 'update', ->
+    engine.nextLevel() if justPressed.any
+
+  self.bind "overlay", (canvas) ->
+    self.centerText canvas, App.name
+
+    self.centerText canvas, "Press any key to start",
+      size: 12
+      y: App.height / 2 + 30
+
+  return self

data/source/tween.coffee

@@ -0,0 +1,70 @@
+###*
+The <code>Tween</code> module provides a method to tween object properties. 
+
+@name Tween
+@module
+@constructor
+@param {Object} I Instance variables
+@param {Core} self Reference to including object
+###
+Tween = (I={}, self) ->
+  Object.reverseMerge I,
+    activeTweens: {}
+
+  # Add events and methods here
+  self.bind "update", (elapsedTime) ->
+    t = I.age + elapsedTime
+    for property, data of I.activeTweens
+      if t >= data.endTime
+        I[property] = data.end
+        I.activeTweens[property].complete?()
+        delete I.activeTweens[property]
+      else
+        if data.easing.isString?()
+          easingFunction = Easing[data.easing](data.start, data.end)
+        else
+          easingFunction = data.easing
+
+        I[property] = easingFunction((t - data.startTime) / data.duration)
+
+  ###*
+  Modify the object's properties over time.
+
+      player = GameObject()
+    
+      player.tween 30,
+        x: 50
+        y: 50
+        easing: "quadratic"
+
+      player = GameObject()
+    
+      player.tween 30,
+        x: 150
+        y: 150
+        complete: ->
+          player.dance()
+
+  @name tween
+  @methodOf Tween#
+  @param {Number} duration How long (in frames) until the object's properties reach their final values.
+  @param {Object} properties Which properties to tween. Set the `easing` property to specify the easing function.
+  ###
+  tween: (duration, properties) ->
+    properties = Object.extend({}, properties) # Make a local copy
+
+    easing = properties.easing || "linear"
+    complete = properties.complete
+
+    delete properties.easing
+    delete properties.complete
+
+    for property, target of properties
+      I.activeTweens[property] =
+        complete: complete
+        end: target
+        start: I[property]
+        easing: easing
+        duration: duration
+        startTime: I.age
+        endTime: I.age + duration

data/test/active_bounds.coffee

@@ -0,0 +1,67 @@
+module "ActiveBounds"
+
+window.App ||= {}
+
+App.width = 640
+App.height = 480
+
+test "shouldn't remove object inside activeBounds", ->  
+  obj = GameObject
+    x: 50
+    y: 50
+    width: 32
+    height: 32
+    
+  obj.include ActiveBounds
+  
+  destroySpy = false
+  
+  obj.bind 'destroy', ->
+    destroySpy = true
+    
+  obj.update(1)
+  
+  equals destroySpy, false
+
+test "should remove objects outside of activeBounds", 2, ->
+  obj = GameObject
+    x: 50
+    y: 50
+    width: 32
+    height: 32
+
+  obj.include ActiveBounds
+
+  destroySpy = false
+
+  obj.bind 'destroy', ->
+    destroySpy = true
+
+  obj.I.x = 10000
+  obj.I.y = 50
+
+  obj.update(1)
+
+  ok destroySpy, 'obj should be destroyed when it goes outside the x bounds'
+
+  obj2 = GameObject
+    x: 100
+    y: 250
+    width: 16
+    height: 26
+
+  obj2.include ActiveBounds
+
+  destroySpy = false
+
+  obj2.bind 'destroy', ->
+    destroySpy = true
+
+  obj2.I.x = 100
+  obj2.I.y = 50000
+
+  obj2.update(1)
+
+  ok destroySpy, 'obj2 should be destroyed when it goes outside the y bounds'
+
+module()