pixie_dust 0.0.1

data/source/engine.coffee

@@ -0,0 +1,274 @@
+( ->
+  ###*
+  The Engine controls the game world and manages game state. Once you
+  set it up and let it run it pretty much takes care of itself.
+
+  You can use the engine to add or remove objects from the game world.
+
+  There are several modules that can include to add additional capabilities
+  to the engine.
+
+  The engine fires events that you  may bind listeners to. Event listeners
+  may be bound with <code>engine.bind(eventName, callback)</code>
+
+  @name Engine
+  @constructor
+  @param {Object} I Instance variables of the engine
+  ###
+
+  ###*
+  Observe or modify the
+  entity data before it is added to the engine.
+  @name beforeAdd
+  @methodOf Engine#
+  @event
+  @param {Object} entityData
+  ###
+
+  ###*
+  Observe or configure a <code>gameObject</code> that has been added
+  to the engine.
+  @name afterAdd
+  @methodOf Engine#
+  @event
+  @param {GameObject} object The object that has just been added to the
+  engine.
+  ###
+
+  ###*
+  Called when the engine updates all the game objects.
+
+  @name update
+  @methodOf Engine#
+  @event
+  @param {Number} elapsedTime The time in seconds that has elapsed since the last update.
+  ###
+
+  ###*
+  Called after the engine completes an update. Here it is
+  safe to modify the game objects array.
+
+  @name afterUpdate
+  @methodOf Engine#
+  @event
+  ###
+
+  ###*
+  Called before the engine draws the game objects on the canvas. The current camera transform is applied.
+
+  @name beforeDraw
+  @methodOf Engine#
+  @event
+  @params {PixieCanvas} canvas A reference to the canvas to draw on.
+  ###
+
+  ###*
+  Called after the engine draws on the canvas. The current camera transform is applied.
+
+      engine.bind "draw", (canvas) ->
+        # print some directions for the player
+        canvas.drawText
+          text: "Go this way =>"
+          x: 200
+          y: 200
+
+  @name draw
+  @methodOf Engine#
+  @event
+  @params {PixieCanvas} canvas A reference to the canvas to draw on.
+  ###
+
+  ###*
+  Called after the engine draws.
+
+  The current camera transform is not applied. This is great for
+  adding overlays.
+
+      engine.bind "overlay", (canvas) ->
+        # print the player's health. This will be
+        # positioned absolutely according to the viewport.
+        canvas.drawText
+          text: "HEALTH:"
+          position: Point(20, 20)
+
+        canvas.drawText
+          text: player.health()
+          position: Point(50, 20)
+
+  @name overlay
+  @methodOf Engine#
+  @event
+  @params {PixieCanvas} canvas A reference to the canvas to draw on.
+  ###
+
+  Engine = (I={}) ->
+    Object.reverseMerge I,
+      FPS: 60
+      paused: false
+
+    frameAdvance = false
+
+    running = false
+    startTime = +new Date()
+    lastStepTime = -Infinity
+    animLoop = (timestamp) ->
+      timestamp ||= +new Date()
+      msPerFrame = (1000 / I.FPS)
+
+      delta = timestamp - lastStepTime
+      remainder = delta - msPerFrame
+
+      if remainder > 0
+        lastStepTime = timestamp - Math.min(remainder, msPerFrame)
+        step()
+
+      if running
+        window.requestAnimationFrame(animLoop)
+
+    update = (elapsedTime) ->
+      self.trigger "beforeUpdate", elapsedTime
+      self.trigger "update", elapsedTime
+      self.trigger "afterUpdate", elapsedTime
+
+    draw = ->
+      return unless canvas = I.canvas
+
+      self.trigger "beforeDraw", canvas
+      self.trigger "draw", canvas
+      self.trigger "overlay", canvas
+
+    step = ->
+      if !I.paused || frameAdvance
+        elapsedTime = (1 / I.FPS)
+        update(elapsedTime)
+
+      draw()
+
+    self = Core(I).extend {
+      ###*
+      Start the game simulation.
+
+          engine.start()
+
+      @methodOf Engine#
+      @name start
+      ###
+      start: ->
+        unless running
+          running = true
+          window.requestAnimationFrame(animLoop)
+
+      ###*
+      Stop the simulation.
+
+          engine.stop()
+
+      @methodOf Engine#
+      @name stop
+      ###
+      stop: ->
+        running = false
+
+      ###*
+      Pause the game and step through 1 update of the engine.
+
+          engine.frameAdvance()
+
+      @methodOf Engine#
+      @name frameAdvance
+      ###
+      frameAdvance: ->
+        I.paused = true
+        frameAdvance = true
+        step()
+        frameAdvance = false
+
+      ###*
+      Resume the game.
+
+          engine.play()
+
+      @methodOf Engine#
+      @name play
+      ###
+      play: ->
+        I.paused = false
+
+      ###*
+      Toggle the paused state of the simulation.
+
+          engine.pause()
+
+      @methodOf Engine#
+      @name pause
+      @param {Boolean} [setTo] Force to pause by passing true or unpause by passing false.
+      ###
+      pause: (setTo) ->
+        if setTo?
+          I.paused = setTo
+        else
+          I.paused = !I.paused
+
+      ###*
+      Query the engine to see if it is paused.
+
+          engine.pause()
+
+          engine.paused()
+          # true
+
+          engine.play()
+
+          engine.paused()
+          # false
+
+      @methodOf Engine#
+      @name paused
+      ###
+      paused: ->
+        I.paused
+
+      ###*
+      Change the framerate of the game. The default framerate is 30 fps.
+
+          engine.setFramerate(60)
+
+      @methodOf Engine#
+      @name setFramerate
+      ###
+      setFramerate: (newFPS) ->
+        I.FPS = newFPS
+        self.stop()
+        self.start()
+
+      update: update
+      draw: draw
+    }
+
+    self.include Ageable
+
+    Engine.defaultModules.each (moduleName) ->
+      fullModuleName = "Engine.#{moduleName}"
+      throw "##{fullModuleName} is not a valid engine module" unless Engine[moduleName]
+
+      self.include fullModuleName
+
+    self.trigger "init"
+
+    return self
+
+  Engine.defaultModules = [
+    "Data"
+    "Keyboard"
+    "Mouse"
+    "Background"
+    "Delay"
+    "GameState"
+    "Selector"
+    "Collision"
+    "Tilemap"
+    "Levels"
+  ]
+
+  (exports ? this)["Engine"] = Engine
+)()

data/source/engine.collision.coffee

@@ -0,0 +1,77 @@
+###*
+The <code>Collision</code> module provides some simple collision detection methods to engine.
+
+@name Collision
+@fieldOf Engine
+@module
+@param {Object} I Instance variables
+@param {Object} self Reference to the engine
+###
+Engine.Collision = (I, self) ->
+  ###*
+  Detects collisions between a bounds and the game objects.
+
+  @name collides
+  @methodOf Engine#
+  @param bounds The bounds to check collisions with.
+  @param [sourceObject] An object to exclude from the results.
+  @returns {Boolean} true if the bounds object collides with any of the game objects, false otherwise.
+  ###
+  collides: (bounds, sourceObject, selector=".solid") ->
+    self.find(selector).inject false, (collided, object) ->
+      collided or (object != sourceObject) and object.collides(bounds)
+
+  ###*
+  Detects collisions between a bounds and the game objects.
+  Returns an array of objects colliding with the bounds provided.
+
+  @name collidesWith
+  @methodOf Engine#
+  @param bounds The bounds to check collisions with.
+  @param [sourceObject] An object to exclude from the results.
+  @returns {Array} An array of objects that collide with the given bounds.
+  ###
+  collidesWith: (bounds, sourceObject, selector=".solid") ->
+    self.find(selector).select (object) ->
+      object != sourceObject and object.collides(bounds)
+
+  ###*
+  Detects collisions between a ray and the game objects.
+
+  @name rayCollides
+  @methodOf Engine#
+  @param source The origin point
+  @param direction A point representing the direction of the ray
+  @param [sourceObject] An object to exclude from the results.
+  @param [selector] A selector to choos which objects in the engine to collide with
+  ###
+  rayCollides: ({source, direction, sourceObject, selector}) ->
+    selector ?= ""
+
+    hits = self.find(selector).map (object) ->
+      hit = (object != sourceObject) and Collision.rayRectangle(source, direction, object.centeredBounds())
+      hit.object = object if hit
+
+      hit
+
+    nearestDistance = Infinity
+    nearestHit = null
+
+    hits.each (hit) ->
+      if hit && (d = hit.distance(source)) < nearestDistance
+        nearestDistance = d
+        nearestHit = hit
+
+    nearestHit
+
+  # TODO Allow specification of collision type (i.e. circular)
+  objectsUnderPoint: (point, selector="") ->
+    bounds = {
+      x: point.x
+      y: point.y
+      width: 0
+      height: 0
+    }
+
+    self.find(selector).select (object) ->
+      object.collides(bounds)

data/source/engine.data.coffee

@@ -0,0 +1,23 @@
+###*
+The <code>Data</code> module provides methods to store global and persistent data in the engine.
+
+    engine.data.score = 0
+    engine.data.score += 10
+    
+    engine.data.score # => 10
+
+@name Data
+@fieldOf Engine
+@module
+@param {Object} I Instance variables
+@param {Object} self Reference to the engine
+###
+Engine.Data = (I={}, self) ->
+  Object.reverseMerge I,
+    data: {}
+
+  Object.defineProperty self, 'data',
+    get: ->
+      I.data
+
+  {}

data/source/engine.delay.coffee

@@ -0,0 +1,41 @@
+###*
+The <code>Delay</code> module provides methods to trigger events after a number of steps have passed.
+
+@name Delay
+@fieldOf Engine
+@module
+@param {Object} I Instance variables
+@param {Object} self Reference to the engine
+###
+Engine.Delay = (I, self) ->
+  delayedEvents = []
+
+  self.bind 'afterUpdate', (elapsedTime) ->
+    [delayedEvents, firingEvents] = delayedEvents.partition (event) ->
+      (event.delay -= elapsedTime) >= 0
+
+    firingEvents.each (event) ->
+      event.callback()
+
+    return
+
+  ###*
+  Execute a callback after a number of seconds have passed.
+
+      engine.delay 5, ->
+        engine.add
+          class: "Ghost"
+
+  @name delay
+  @methodOf Engine#
+  @param {Number} seconds The number of steps to wait before executing the callback
+  @param {Function} callback The callback to be executed.
+
+  @returns {Engine} self
+  ###
+  delay: (seconds, callback) ->
+    delayedEvents.push
+      delay: seconds
+      callback: callback
+
+    return self

data/source/engine.fps_counter.coffee

@@ -0,0 +1,32 @@
+###*
+The <code>FPSCounter</code> module tracks and displays the framerate.
+
+    window.engine = Engine
+      ...
+      includedModules: ["FPSCounter"]
+      FPSColor: "#080"
+
+@name FPSCounter
+@fieldOf Engine
+@module
+
+@param {Object} I Instance variables
+@param {Object} self Reference to the engine
+###
+Engine.FPSCounter = (I, self) ->
+  Object.reverseMerge I,
+    showFPS: true
+    FPSColor: "#FFF"
+
+  framerate = Framerate()
+
+  self.bind "overlay", (canvas) ->
+    if I.showFPS
+      canvas.font("bold 9pt consolas, 'Courier New', 'andale mono', 'lucida console', monospace")
+
+      canvas.drawText
+        color: I.FPSColor
+        position: Point(6, 18)
+        text: "fps: #{framerate.fps}"
+
+    framerate.rendered()

data/source/engine.game_state.coffee

@@ -0,0 +1,86 @@
+Engine.GameState = (I, self) ->
+  Object.reverseMerge I,
+    currentState: GameState()
+
+  requestedState = null
+
+  # The idea is that all the engine#beforeUpdate triggers happen
+  # before the state beforeUpdate triggers, then the state update
+  # then the state after update, then the engine after update
+  # like a layered cake with states in the middle.
+  self.bind "update", (elapsedTime) ->
+    I.currentState.trigger "beforeUpdate", elapsedTime
+    I.currentState.trigger "update", elapsedTime
+    I.currentState.trigger "afterUpdate", elapsedTime
+
+  self.bind "afterUpdate", ->
+    # Handle state change
+    if requestedState?
+      I.currentState.trigger "exit", requestedState
+      self.trigger 'stateExited', I.currentState
+
+      previousState = I.currentState
+      I.currentState = requestedState
+
+      I.currentState.trigger "enter", previousState
+      self.trigger 'stateEntered', I.currentState
+
+      requestedState = null
+
+  self.bind "draw", (canvas) ->
+    I.currentState.trigger "beforeDraw", canvas
+    I.currentState.trigger "draw", canvas
+    I.currentState.trigger "overlay", canvas
+
+
+  # Just pass through to the current state
+  add: (classNameOrEntityData, entityData={}) ->
+    # Allow optional add "Class", data form
+    if classNameOrEntityData.isString?()
+      entityData.class = classNameOrEntityData
+    else
+      entityData = classNameOrEntityData
+
+    self.trigger "beforeAdd", entityData
+    object = I.currentState.add(entityData)
+    self.trigger "afterAdd", object
+
+    return object
+
+  camera: (n=0) ->
+    self.cameras()[n]
+
+  cameras: (newCameras) ->
+    if newCameras?
+      I.currentState.cameras(newCameras)
+
+      return self
+    else
+      I.currentState.cameras()
+
+  fadeIn: (options={}) ->
+    self.cameras().invoke('fadeIn', options)
+
+  fadeOut: (options={}) ->
+    self.cameras().invoke('fadeOut', options)
+
+  flash: (options={}) ->
+    self.camera(options.camera).flash(options)
+
+  objects: ->
+    I.currentState.objects()
+
+  setState: (newState) ->
+    requestedState = newState
+
+  shake: (options={}) ->
+    self.camera(options.camera).shake(options)
+
+  saveState: ->
+    I.currentState.saveState()
+
+  loadState: (newState) ->
+    I.currentState.loadState(newState)
+
+  reload: ->
+    I.currentState.reload()

data/source/engine.joysticks.coffee

@@ -0,0 +1,47 @@
+###*
+The <code>Joysticks</code> module gives the engine access to joysticks.
+
+    # First you need to add the joysticks module to the engine
+    window.engine = Engine
+      ...
+      includedModules: ["Joysticks"]
+    # Then you need to get a controller reference
+    # id = 0 for player 1, etc.
+    controller = engine.controller(id)
+    
+    # Point indicating direction primary axis is held
+    direction = controller.position()
+    
+    # Check if buttons are held
+    controller.actionDown("A")
+    controller.actionDown("B")
+    controller.actionDown("X")
+    controller.actionDown("Y")
+
+@name Joysticks
+@fieldOf Engine
+@module
+
+@param {Object} I Instance variables
+@param {Object} self Reference to the engine
+###
+Engine.Joysticks = (I, self) ->
+  Joysticks.init()
+
+  self.bind "update", ->
+    # Handle hotswapping, does nothing if already initialized
+    Joysticks.init()
+
+    # Update the joysticks, this also fires joystick events to listeners
+    Joysticks.update()
+
+  ###*
+  Get a controller for a given joystick id.
+
+  @name controller
+  @methodOf Engine.Joysticks#
+
+  @param {Number} i The joystick id to get the controller of.
+  ###
+  controller: (i) ->
+    Joysticks.getController(i)

data/source/engine.keyboard.coffee

@@ -0,0 +1,17 @@
+###*
+This module sets up the keyboard inputs for each engine update.
+
+@name Keyboard
+@fieldOf Engine
+@module
+@param {Object} I Instance variables
+@param {Object} self Reference to the engine
+###
+Engine.Keyboard = (I, self) ->
+  self.bind "beforeUpdate", ->
+    # TODO: Make a Gamepad/Keyboard input module that has web and XNA
+    # implementations
+    updateKeys?()
+
+  return {}
+

data/source/engine.levels.coffee

@@ -0,0 +1,69 @@
+###*
+This module provides methods for transitioning between levels.
+
+@name Levels
+@fieldOf Engine
+@module
+@param {Object} I Instance variables
+@param {Object} self Reference to the engine
+###
+Engine.Levels = (I, self) ->
+  Object.reverseMerge I,
+    levels: []
+    currentLevel: -1
+    currentLevelName: null
+
+  I.transitioning = false
+
+  loadLevel = (level) ->
+    unless I.transitioning
+      I.transitioning = true
+
+      levelState = LevelState
+        level: level
+
+      I.currentLevelName = level
+      engine.setState levelState
+
+  ###*
+  Load map for the next level.
+
+      engine.nextLevel()
+
+  @name nextLevel
+  @methodOf Engine#
+  ###      
+  nextLevel: ->
+    unless I.transitioning
+      I.currentLevel += 1
+
+      if level = I.levels[I.currentLevel]
+        loadLevel level
+      else
+        engine.setState GameOver()
+
+  ###*
+  Load map named <code>level</code>
+
+      engine.goToLevel 'bossFight'
+
+  @name goToLevel
+  @methodOf Engine#
+  ###          
+  goToLevel: (level) ->
+    #TODO Handle integer levels?
+    loadLevel level
+
+  ###*
+  Reload the current level. Useful for retrying after a player dies.
+
+      engine.reloadLevel()
+
+  @name reloadLevel
+  @methodOf Engine#
+  ###     
+  restartLevel: ->
+    loadLevel I.currentLevelName
+
+  reloadLevel: ->
+    self.restartLevel()

data/source/engine.mouse.coffee

@@ -0,0 +1,16 @@
+###*
+This module sets up the mouse inputs for each engine update.
+
+@name Mouse
+@fieldOf Engine
+@module
+@param {Object} I Instance variables
+@param {Object} self Reference to the engine
+###
+Engine.Mouse = (I, self) ->
+  self.bind "beforeUpdate", ->
+    # TODO: Make a Gamepad/Keyboard/Mouse input module that has web and XNA
+    # implementations
+    updateMouse?()
+
+  return {}