pixie_dust 0.0.1

data/source/game_object.meter.coffee

@@ -0,0 +1,191 @@
+###*
+The Metered module provides a simple drop-in
+meter ui to track arbitrary numeric attributes.
+
+    player = GameObject
+      health: 100
+      heathMax: 100
+    
+    enemy = GameObject
+      health: 500
+    
+    someOtherObject = GameObject
+    
+    player.meter 'health'
+    # => Sets up a health meter that will be drawn during the player overlay event
+    
+    enemy.meter 'health'
+    # => Sets up a health meter that will be drawn during the enemy overlay event. 
+    # Since healthMax wasn't provided, it is set to the value of I.health (500)
+    
+    someOtherObject.meter 'turbo'
+    # => Sets up a turbo meter that will be drawn during the someOtherObject overlay event. 
+    # Since neither turbo or turboMax were provided, they are both set to 100.
+
+Metered module
+@name Metered
+@module
+@constructor
+@param {Object} I Instance variables
+@param {GameObject} self Reference to including object
+###
+
+GameObject.Meter = (I={}, self) ->
+  Object.reverseMerge I,
+    meters: {}
+        
+  self.bind 'overlay', (canvas) ->
+    for name, meterData of I.meters
+      {
+        backgroundColor,
+        border: {color:borderColor, radius:borderRadius, width:borderWidth}
+        color,
+        height, 
+        show,
+        width,
+        x,
+        y
+      } = meterData
+      
+      {x, y} = meterData.position if meterData.position?
+
+      return unless show
+
+      ratio = (I[name] / I["#{name}Max"]).clamp(0, 1)
+
+      canvas.drawRoundRect
+        color: backgroundColor
+        radius: borderRadius
+        x: x
+        y: y
+        width: width
+        height: height
+      
+      canvas.drawRoundRect
+        color: color
+        x: x
+        y: y
+        radius: borderRadius
+        width: width * ratio
+        height: height
+        
+      canvas.drawRoundRect
+        x: x
+        y: y
+        width: width
+        height: height
+        radius: borderRadius
+        stroke:
+          color: borderColor
+          width: borderWidth
+  ###*
+  Configures a meter to be drawn each overlay event.
+
+      player = GameObject
+    
+      player.meter 'health',
+        border
+          color: 'brown'
+          radius: 3
+        color: 'pink'
+        height: 20
+        x: 5
+        y: 5
+        show: true
+        width: 150
+    
+      # => Sets up a health meter, using all the configuration options
+
+  @name meter
+  @methodOf Metered#
+  @param {String} name The name of the property to meter
+  @param {Object} options The meter configuration options
+  @param {String} border: color Color of the meter's border
+  @param {Number} border: width Width of the meter's border
+  @param {String} color Color of the meter's inner rectangle
+  @param {Number} height Height of the meter
+  @param {Object} position An x, y object representing the position of the meter
+  @param {Number} x x position of the meter
+  @param {Number} y y position of the meter
+  @param {Number} border: radius Border radius of the meter
+  @param {Boolean} show Boolean to toggle whether of not to display the meter
+  @param {Number} width How wide the meter is
+  ###          
+  meter: (name, options={}) ->
+    Object.reverseMerge options,
+      backgroundColor: 'black'
+      border:
+        color: 'white'
+        radius: 2
+        width: 1.5
+      color: 'green'
+      height: 10
+      x: 0
+      y: 0
+      show: true
+      width: 100 
+        
+    I[name] ?= 100
+    
+    if not I["#{name}Max"]
+      if I[name]
+        I["#{name}Max"] = I[name]
+      else
+        I["#{name}Max"] = 100
+    
+    I.meters[name] = options
+    
+  ###*
+  Shows the named meter
+
+      player = GameObject
+    
+      # creates a health meter but disables visibility
+      player.meter 'health'
+        show: false
+    
+      # enables visibility for the meter named 'health'
+      player.showMeter 'health'
+
+  @name showMeter
+  @methodOf Metered#
+  @param {String} name The name of the meter to show
+  ###      
+  showMeter: (name) ->
+    I.meters[name].show = true
+ 
+  ###*
+  Hides the named meter
+
+      player = GameObject
+    
+      # creates a health meter
+      player.meter 'health'
+    
+      # disables visibility for the meter named 'health'
+      player.hideMeter 'health'
+
+  @name hideMeter
+  @methodOf Metered#
+  @param {String} name The name of the meter to hide
+  ###          
+  hideMeter: (name) ->
+    I.meters[name].show = false
+
+  ###*
+  Toggles visibility of the named meter
+
+      player = GameObject
+    
+      # creates a health meter
+      player.meter 'health'
+    
+      # toggles visibility for the meter named 'health'
+      player.toggleMeter 'health'
+
+  @name toggleMeter
+  @methodOf Metered#
+  @param {String} name The name of the meter to toggle
+  ###    
+  toggleMeter: (name) ->
+    I.meters[name].show = not I.meters[name].show

data/source/game_over.coffee

@@ -0,0 +1,40 @@
+###*
+The Game Over class sets up a simple game state with restart instructions.
+
+@see TextScreen
+@name GameOver
+@constructor
+###
+
+###*
+Transitions to the title state on user input.
+
+@name update
+@methodOf GameOver#
+@event
+###
+
+###*
+Draws Game Over screen and reset instructions.
+
+@name overlay
+@methodOf GameOver#
+@param {PixieCanvas} canvas
+@event
+###
+GameOver = (I={}) ->
+  self = TextScreen(I)
+
+  self.bind 'update', ->
+    if justPressed.any
+      engine.delay 15, ->
+        engine.setState TitleScreen()
+
+  self.bind "overlay", (canvas) ->
+    self.centerText canvas, "Game Over"
+
+    self.centerText canvas, "Press any key to restart",
+      size: 12
+      y: App.height / 2 + 30
+
+  return self

data/source/game_state.coffee

@@ -0,0 +1,67 @@
+GameState = (I={}) ->
+  Object.reverseMerge I,
+    objects: []
+
+  queuedObjects = []
+
+  self = Core(I).extend {
+    ###*
+    The add method creates and adds an object to the game world. Two
+    other events are triggered around this one: beforeAdd and afterAdd.
+
+        # you can add arbitrary entityData and
+        # the engine will make it into a GameObject
+        engine.add 
+          x: 50
+          y: 30
+          color: "red"
+    
+        player = engine.add
+          class: "Player"
+
+    @name add
+    @methodOf Engine#
+    @param {Object} entityData The data used to create the game object.
+    @returns {GameObject}
+    ###
+    add: (entityData) ->
+      self.trigger "beforeAdd", entityData
+
+      object = GameObject.construct entityData
+      object.create()
+
+      self.trigger "afterAdd", object
+
+      if I.updating
+        queuedObjects.push object
+      else
+        I.objects.push object
+
+      return object
+
+    objects: ->
+      I.objects.copy()
+  }
+
+  # Add events and methods here
+  self.bind "update", (elapsedTime) ->
+    I.updating = true
+
+    I.objects.invoke "trigger", "beforeUpdate", elapsedTime
+
+    [toKeep, toRemove] = I.objects.partition (object) ->
+      object.update(elapsedTime)
+
+    I.objects.invoke "trigger", "afterUpdate", elapsedTime
+
+    toRemove.invoke "trigger", "remove"
+
+    I.objects = toKeep.concat(queuedObjects)
+    queuedObjects = []
+
+    I.updating = false
+
+  self.include "GameState.Cameras"
+  self.include "GameState.SaveState"
+
+  return self

data/source/game_state.save_state.coffee

@@ -0,0 +1,76 @@
+###*
+The <code>SaveState</code> module provides methods to save and restore the current game state.
+
+@name SaveState
+@fieldOf GameState
+@module
+@param {Object} I Instance variables
+@param {Object} self Reference to the game state
+###
+GameState.SaveState = (I, self) ->
+  savedState = null
+
+  ###*
+  Save the current game state and returns a JSON object representing that state.
+
+      engine.bind 'update', ->
+        if justPressed.s
+          engine.saveState()
+
+  @name saveState
+  @methodOf GameState#
+  @returns {Array} An array of the instance data of all objects in the game state
+  ###
+  saveState: ->
+    savedState = I.objects.map (object) ->
+      Object.extend({}, object.I)
+
+  ###*
+  Loads the game state passed in, or the last saved state, if any.
+
+      engine.bind 'update', ->
+        if justPressed.l
+          # loads the last saved state
+          engine.loadState()
+    
+        if justPressed.o
+          # removes all game objects, then reinstantiates 
+          # them with the entityData passed in
+          engine.loadState([{x: 40, y: 50, class: "Player"}, {x: 0, y: 0, class: "Enemy"}, {x: 500, y: 400, class: "Boss"}])
+
+  @name loadState
+  @methodOf GameState#
+  @param [newState] An arraf of object instance data to load.
+  ###
+  loadState: (newState) ->
+    if newState ||= savedState
+      I.objects.invoke "trigger", "remove"
+      I.objects = []
+
+      newState.each (objectData) ->
+        self.add Object.extend({}, objectData)
+
+  ###*
+  Reloads the current game state, useful for hotswapping code.
+
+      engine.I.objects.each (object) ->
+        # bring all objects to (0, 0) for some reason
+        object.I.x = 0
+        object.I.y = 0
+    
+      # reload all objects to make sure
+      # they are at (0, 0)  
+      engine.reload()
+
+  @name reload
+  @methodOf GameState#
+  ###
+  reload: ->
+    oldObjects = I.objects
+    I.objects = []
+
+    oldObjects.each (object) ->
+      object.trigger "remove"
+
+      self.add object.I
+

data/source/game_state.single_camera.coffee

@@ -0,0 +1,40 @@
+###*
+The <code>SingleCamera</code> module provides provides a single camera view of the game.
+Its transform can be adjusted to view different areas and provide various camera effects.
+
+@name SingleCamera
+@fieldOf GameState
+@module
+@param {Object} I Instance variables
+@param {Object} self Reference to the game state
+###
+GameState.SingleCamera = (I, self) ->
+  # Set some default properties
+  Object.reverseMerge I,
+    cameraTransform: Matrix.IDENTITY
+    zSort: true
+
+  self.attrAccessor "cameraTransform"
+
+  # Add events and methods here
+  self.bind "draw", (canvas) ->
+    canvas.withTransform I.cameraTransform, (canvas) ->
+      drawObjects = self.objects()
+
+      # TODO Turn this zSort into a per camera object stream filter
+      # This will also enable filters like clipping region tests
+      if I.zSort
+        drawObjects.sort (a, b) ->
+          a.I.zIndex - b.I.zIndex
+
+      drawObjects.invoke("draw", canvas)
+
+      # TODO This should be triggering a camera draw
+      # camera.trigger "draw", I.canvas
+      # possibly even with before and after.
+      # This is where per camera effects like shake, 
+      # flash and fade will come in.
+
+  # No public methods
+  return {}
+

data/source/game_state_cameras.coffee

@@ -0,0 +1,33 @@
+GameState.Cameras = (I, self) ->
+  cameras = [Camera()]
+
+  self.bind 'update', (elapsedTime) ->
+    self.cameras().invoke 'trigger', 'update', elapsedTime
+
+  self.bind 'afterUpdate', (elapsedTime) ->
+    self.cameras().invoke 'trigger', 'afterUpdate', elapsedTime
+
+  self.bind 'draw', (canvas) ->
+    self.cameras().invoke 'trigger', 'draw', canvas, self.objects()
+
+  self.bind 'overlay', (canvas) ->
+    self.cameras().invoke 'trigger', 'overlay', canvas, self.objects()
+
+  return {
+    addCamera: (data) ->
+      cameras.push(Camera(data))
+    ###*
+    Returns the array of camera objects.
+
+    @name cameras
+    @methodOf Engine#
+    @returns {Array}
+    ###
+    cameras: (newCameras) ->
+      if newCameras
+        cameras = newCameras
+
+        return self
+      else
+        return cameras
+  }

data/source/level_state.coffee

@@ -0,0 +1,32 @@
+###*
+A Game State that loads the map for a given level and transitions into the level.
+
+@see GameState
+@name LevelState
+@constructor
+@param {Number} duration Amount of time in frames it takes to fade into the level
+@param {String} level name of the map to load
+###
+
+###*
+Fades in the current level and loads the map.
+
+@name enter
+@methodOf LevelState#
+@event
+###
+LevelState = (I={}) ->
+  Object.reverseMerge I,
+    duration: 10
+    level: 'level1'
+
+  self = GameState(I)
+
+  self.bind "enter", ->
+    engine.fadeIn
+      duration: I.duration
+
+    engine.loadMap I.level, ->
+      engine.I.transitioning = false
+
+  return self

data/source/movable.coffee

@@ -0,0 +1,57 @@
+###*
+The Movable module automatically updates the position and velocity of
+GameObjects based on the velocity and acceleration. It does not check
+collisions so is probably best suited to particle effect like things.
+
+    player = GameObject
+      x: 0
+      y: 0
+      velocity: Point(0, 0)
+      acceleration: Point(1, 0)
+      maxSpeed: 2
+
+    player.include(Movable)
+
+    # => `velocity is {x: 0, y: 0} and position is {x: 0, y: 0}`
+
+    player.update(1)
+    # => `velocity is {x: 1, y: 0} and position is {x: 1, y: 0}`
+
+    player.update(1)
+    # => `velocity is {x: 2, y: 0} and position is {x: 3, y: 0}`
+
+    # we've hit our maxSpeed so our velocity won't increase
+    player.update(1)
+    # => `velocity is {x: 2, y: 0} and position is {x: 5, y: 0}`
+
+@name Movable
+@module
+@constructor
+@param {Object} I Instance variables
+@param {Core} self Reference to including object
+###
+Movable = (I={}, self) ->
+  Object.reverseMerge I,
+    acceleration: Point(0, 0)
+    velocity: Point(0, 0)
+
+  # Force acceleration and velocity to be Points
+  # Useful when reloading data from JSON
+  I.acceleration = Point(I.acceleration.x, I.acceleration.y)
+  I.velocity = Point(I.velocity.x, I.velocity.y)
+
+  self.attrReader "velocity", "acceleration"
+
+  # Handle multi-include
+  self.unbind ".Movable"
+
+  self.bind 'update.Movable', (dt) ->
+    I.velocity = I.velocity.add(I.acceleration.scale(dt))
+
+    if I.maxSpeed?
+      currentSpeed = I.velocity.magnitude()
+      if currentSpeed > I.maxSpeed
+        I.velocity = I.velocity.scale(I.maxSpeed / currentSpeed)
+
+    I.x += I.velocity.x * dt
+    I.y += I.velocity.y * dt

data/source/oscillator.coffee

@@ -0,0 +1,18 @@
+###*
+Creates an oscillator function with the given parameters.
+
+@name Oscillator
+@constructor
+@param {Number} amplitude How much to scale the oscillator function value
+@param {Number} period How fast the osciallator function repeats
+@param {Number} offset How much to offset the created oscillator function. Useful for translating between sin and cosine functions.
+###
+Oscillator = (options={}) ->
+  {amplitude, period, offset} = options
+
+  amplitude = 1 unless amplitude?
+  period = 1 unless period?
+  offset = 0 unless offset?
+
+  return (t) ->
+    amplitude * Math.cos(Math.TAU * t / period + offset)

data/source/pixie_dust.coffee

@@ -0,0 +1,2 @@
+#= require cornerstone
+#= require_tree .

data/source/resource_loader.coffee

@@ -0,0 +1,35 @@
+###*
+@name ResourceLoader
+@namespace
+
+Helps access the assets in your game.
+###
+(->
+  typeTable =
+    images: "png"
+    data: "json"
+    tilemaps: "tilemap"
+
+  ResourceLoader =
+    ###*
+    Return the url for a particular asset.
+
+        ResourceLoader.urlFor("images", "player")
+        # => This returns the url for the file "player.png" in your images directory.
+
+    @name urlFor
+    @methodOf ResourceLoader#
+    @param {String} directory The directory your file is in.
+    @param {String} name The name of the file.
+    @returns {String} The full url of your asset
+
+    ###
+    urlFor: (directory, name) ->
+      directory = App?.directories?[directory] || directory
+
+      type = typeTable[directory]
+
+      "#{BASE_URL}/#{directory}/#{name}.#{type}?#{MTIME}"
+
+  (exports ? this)["ResourceLoader"] = ResourceLoader
+)()

data/source/rotatable.coffee

@@ -0,0 +1,38 @@
+###*
+The Rotatable module rotates the object
+based on its rotational velocity.
+
+    player = GameObject
+      x: 0
+      y: 0
+      rotationalVelocity: Math.PI / 64
+    
+    player.I.rotation
+    # => 0
+    
+    player.update(1)
+    
+    player.I.rotation
+    # => 0.04908738521234052 # Math.PI / 64
+    
+    player.update(1)
+    
+    player.I.rotation
+    # => 0.09817477042468103 # 2 * (Math.PI / 64)
+
+@name Rotatable
+@module
+@constructor
+@param {Object} I Instance variables
+@param {Core} self Reference to including object
+###
+Rotatable = (I={}, self) ->
+  Object.reverseMerge I,
+    rotation: 0
+    rotationalVelocity: 0
+
+  self.bind 'update', (dt) ->
+    I.rotation += I.rotationalVelocity * dt
+
+  return {}
+