pixie_dust 0.0.1

data/source/camera.shake.coffee

@@ -0,0 +1,27 @@
+Camera.Shake = (I, self) ->
+  Object.reverseMerge I,
+    shakeIntensity: 20
+    shakeCooldown: 0
+
+  defaultParams =
+    duration: 10
+    intensity: 20
+
+  self.bind "afterUpdate", ->
+    I.shakeCooldown = I.shakeCooldown.approach(0, 1)
+
+  self.transformFilterChain (transform) ->
+    if I.shakeCooldown > 0
+      transform.tx += signedRand(I.shakeIntensity)
+      transform.ty += signedRand(I.shakeIntensity)
+
+    return transform
+
+  shake: (options={}) ->
+    {duration, intensity} = Object.reverseMerge(options, defaultParams)
+
+    I.shakeCooldown = duration * I.zoom
+    I.shakeIntensity = intensity * I.zoom
+
+    self
+

data/source/camera.zoom.coffee

@@ -0,0 +1,25 @@
+Camera.Zoom = (I, self) ->
+  Object.reverseMerge I,
+    maxZoom: 10
+    minZoom: 0.1
+    zoom: 1
+
+  self.transformFilterChain (transform) ->
+    transform.scale(I.zoom, I.zoom, self.position())
+
+  clampZoom = (value) ->
+    value.clamp(I.minZoom, I.maxZoom) 
+
+  zoomIn: (percentage) ->
+    self.zoom clampZoom(I.zoom * (1 + percentage)) 
+
+  zoomOut: (percentage) ->
+    self.zoom clampZoom(I.zoom * (1 - percentage))
+
+  zoom: (value) ->
+    if value?
+      I.zoom = clampZoom(value)
+
+      return self
+    else
+      return I.zoom

data/source/camera.zsort.coffee

@@ -0,0 +1,13 @@
+Camera.ZSort = (I, self) ->
+  Object.reverseMerge I,
+    zSort: true
+
+  self.objectFilterChain (objects) ->
+    if I.zSort
+      objects.sort (a, b) ->
+        a.I.zIndex - b.I.zIndex
+
+    objects
+
+  return {}
+

data/source/clampable.coffee

@@ -0,0 +1,61 @@
+###*
+The `Clampable` module provides helper methods to clamp object properties. This module is included by default in `GameObject`
+
+    player = GameObject
+      x: 40
+      y: 30
+
+    player.include Clampable
+
+@name Clampable
+@module
+@constructor
+@param {Object} I Instance variables
+@param {Core} self Reference to including object
+###
+Clampable = (I={}, self) ->
+  Object.reverseMerge I,
+    clampData: {}
+
+  self.bind "afterUpdate", ->
+    for property, data of I.clampData
+      I[property] = I[property].clamp(data.min, data.max)
+
+  ###*
+  Keep an objects attributes within a given range.
+
+      # Player's health will be within [0, 100] at the end of every update
+      player.clamp
+        health:
+          min: 0
+          max: 100
+    
+      # Score can only be positive
+      player.clamp
+        score:
+          min: 0
+
+  @name clamp
+  @methodOf Clampable#
+  @param {Object} data
+  ###
+  clamp: (data) ->
+    Object.extend(I.clampData, data)
+
+  ###*
+  Helper to clamp the `x` and `y` properties of the object to be within a given bounds.
+
+  @name clampToBounds
+  @methodOf Clampable#
+  @param {Rectangle} [bounds] The bounds to clamp the object's position within. Defaults to the app size if none given. 
+  ###
+  clampToBounds: (bounds) ->
+    bounds ||= Rectangle x: 0, y: 0, width: App.width, height: App.height
+    
+    self.clamp
+      x:
+        min: bounds.x + I.width/2
+        max: bounds.width - I.width/2
+      y:
+        min: bounds.y + I.height/2
+        max: bounds.height - I.height/2

data/source/collidable.coffee

@@ -0,0 +1,126 @@
+( ->
+  Collidable = (I, self) ->
+    # Set some default properties
+    Object.reverseMerge I,
+      allowCollisions: ANY
+      immovable: false
+      touching: NONE
+      velocity: Point(0, 0)
+      mass: 1
+      elasticity: 0
+
+    self.attrAccessor(
+      "immovable",
+      "velocity",
+      "mass",
+      "elasticity",
+    )
+
+    solid: (newSolid) ->
+      if newSolid?
+        if newSolid
+          I.allowCollisions = ANY
+        else
+          I.allowCollisions = NONE
+      else
+        I.allowCollisions
+
+  (exports ? this)["Collidable"] = Collidable
+
+  {NONE, LEFT, RIGHT, UP, DOWN} = Object.extend Collidable,
+    NONE:  0x0000
+    LEFT:  0x0001
+    RIGHT: 0x0010
+    UP:    0x0100
+    DOWN:  0x1000
+
+  {ANY, FLOOR, WALL, CEILING} = Object.extend Collidable,
+    FLOOR: DOWN
+    WALL: LEFT | RIGHT
+    CEILING: UP
+    ANY: LEFT | RIGHT | UP | DOWN
+
+  Object.extend Collidable,
+    separate: (a, b) ->
+      return if a.immovable() && b.immovable()
+
+      aBounds = a.bounds()
+      bBounds = b.bounds()
+
+      aVelocity = a.velocity()
+      bVelocity = b.velocity()
+
+      deltaVelocity = aVelocity.subtract(bVelocity)
+
+      overlap = Point(0, 0)
+
+      if Collision.rectangular(aBounds, bBounds)
+        if deltaVelocity.x > 0
+          overlap.x = aBounds.x + aBounds.width - bBounds.x
+          if !(a.I.allowCollisions & RIGHT) || !(b.I.allowCollisions & LEFT)
+            overlap.x = 0
+          else
+            a.I.touching |= RIGHT
+            b.I.touching |= LEFT
+
+        else if deltaVelocity.x < 0
+          overlap.x = aBounds.x - bBounds.width - bBounds.x
+          if !(a.I.allowCollisions & LEFT) || !(b.I.allowCollisions & RIGHT)
+            overlap.x = 0
+          else
+            a.I.touching |= LEFT
+            b.I.touching |= RIGHT
+
+        if deltaVelocity.y > 0
+          overlap.y = aBounds.y + aBounds.height - bBounds.y
+          if !(a.I.allowCollisions & DOWN) || !(b.I.allowCollisions & UP)
+            overlap.y = 0
+          else
+            a.I.touching |= DOWN
+            b.I.touching |= UP
+
+        else if deltaVelocity.y < 0
+          overlap.y = aBounds.y - bBounds.height - bBounds.y
+          if !(a.I.allowCollisions & UP) || !(b.I.allowCollisions & DOWN)
+            overlap.y = 0
+          else
+            a.I.touching |= UP
+            b.I.touching |= DOWN
+
+      unless overlap.equal(Point.ZERO)
+        if !a.immovable() and !b.immovable()
+          a.changePosition(overlap.scale(-0.5))
+          b.changePosition(overlap.scale(+0.5))
+
+          # Elastic collision
+          relativeVelocity = aVelocity.subtract(bVelocity)
+
+          aMass = a.mass()
+          bMass = b.mass()
+          totalMass = bMass + aMass
+
+          normal = overlap.norm()
+
+          pushA = normal.scale(-2 * (relativeVelocity.dot(normal) * (bMass / totalMass)))
+          pushB = normal.scale(+2 * (relativeVelocity.dot(normal) * (aMass / totalMass)))
+          average = pushA.add(pushB).scale(0.5)
+
+          pushA.subtract$(average).scale(a.elasticity())
+          pushB.subtract$(average).scale(b.elasticity())
+
+          a.I.velocity = average.add(pushA)
+          b.I.velocity = average.add(pushB)
+
+        else if !a.immovable()
+          a.changePosition(overlap.scale(-1))
+
+          a.I.velocity = bVelocity.subtract(aVelocity.scale(a.elasticity()))
+
+        else if !b.immovable()
+          b.changePosition(overlap)
+
+          b.I.velocity = aVelocity.subtract(bVelocity.scale(b.elasticity()))
+
+        return true
+)()
+

data/source/collision.coffee

@@ -0,0 +1,272 @@
+( ->
+  # Assume game objects
+  collides = (a, b) ->
+    # TODO: Be smart about auto-detecting collision types
+    Collision.rectangular(a.bounds(), b.bounds())
+
+  ###*
+  Collision holds many useful class methods for checking geometric overlap of various objects.
+
+  @name Collision
+  @namespace
+  ###
+  Collision =
+    ###*
+    Collision holds many useful class methods for checking geometric overlap of various objects.
+
+        player = engine.add
+          class: "Player"
+          x: 0
+          y: 0
+          width: 10
+          height: 10
+    
+        enemy = engine.add
+          class: "Enemy"
+          x: 5
+          y: 5
+          width: 10
+          height: 10
+    
+        enemy2 = engine.add
+          class: "Enemy"
+          x: -5
+          y: -5
+          width: 10
+          height: 10
+    
+        Collision.collide(player, enemy, (p, e) -> ...)
+        # => callback is called once
+    
+        Collision.collide(player, [enemy, enemy2], (p, e) -> ...)
+        # => callback is called twice
+    
+        Collision.collide("Player", "Enemy", (p, e) -> ...)
+        # => callback is also called twice
+
+    @name collide
+    @methodOf Collision
+    @param {Object|Array|String} groupA An object or set of objects to check collisions with
+    @param {Object|Array|String} groupB An object or set of objects to check collisions with
+    @param {Function} callback The callback to call when an object of groupA collides
+    with an object of groupB: (a, b) ->
+    @param {Function} [detectionMethod] An optional detection method to determine when two 
+    objects are colliding.
+    ###
+    collide: (groupA, groupB, callback, detectionMethod=collides) ->
+      if Object.isString(groupA)
+        groupA = engine.find(groupA)
+      else
+        groupA = [].concat(groupA)
+
+      if Object.isString(groupB)
+        groupB = engine.find(groupB)
+      else
+        groupB = [].concat(groupB)
+
+      groupA.each (a) ->
+        groupB.each (b) ->
+          callback(a, b) if detectionMethod(a, b)
+
+    ###*
+    Takes two bounds objects and returns true if they collide (overlap), false otherwise.
+    Bounds objects have x, y, width and height properties.
+
+        player = GameObject
+          x: 0
+          y: 0
+          width: 10
+          height: 10
+    
+        enemy = GameObject
+          x: 5
+          y: 5
+          width: 10
+          height: 10
+    
+        Collision.rectangular(player, enemy)
+        # => true
+    
+        Collision.rectangular(player, {x: 50, y: 40, width: 30, height: 30})
+        # => false
+
+    @name rectangular
+    @methodOf Collision
+    @param {Object} a The first rectangle
+    @param {Object} b The second rectangle
+    @returns {Boolean} true if the rectangles overlap, false otherwise
+    ###
+    rectangular: (a, b) ->
+      a.x < b.x + b.width &&
+      a.x + a.width > b.x &&
+      a.y < b.y + b.height &&
+      a.y + a.height > b.y
+
+    ###*
+    Takes two circle objects and returns true if they collide (overlap), false otherwise.
+    Circle objects have x, y, and radius.
+
+        player = GameObject
+          x: 5
+          y: 5
+          radius: 10
+    
+        enemy = GameObject
+          x: 10
+          y: 10
+          radius: 10
+    
+        farEnemy = GameObject
+          x: 500
+          y: 500
+          radius: 30
+    
+        Collision.circular(player, enemy)
+        # => true
+    
+        Collision.circular(player, farEnemy)
+        # => false
+
+    @name circular
+    @methodOf Collision
+    @param {Object} a The first circle
+    @param {Object} b The second circle
+    @returns {Boolean} true is the circles overlap, false otherwise
+    ###
+    circular: (a, b) ->
+      r = a.radius + b.radius
+      dx = b.x - a.x
+      dy = b.y - a.y
+
+      r * r >= dx * dx + dy * dy
+
+    ###*
+    Detects whether a line intersects a circle.
+
+        circle = engine.add
+          class: "circle"
+          x: 50
+          y: 50
+          radius: 10
+    
+        Collision.rayCircle(Point(0, 0), Point(1, 0), circle)
+        # => true
+
+    @name rayCircle
+    @methodOf Collision
+    @param {Point} source The starting position
+    @param {Point} direction A vector from the point
+    @param {Object} target The circle 
+    @returns {Boolean} true if the line intersects the circle, false otherwise
+    ###
+    rayCircle: (source, direction, target) ->
+      radius = target.radius()
+      target = target.position()
+
+      laserToTarget = target.subtract(source)
+
+      projectionLength = direction.dot(laserToTarget)
+
+      if projectionLength < 0
+        return false # object is behind
+
+      projection = direction.scale(projectionLength)
+
+      intersection = source.add(projection)
+      intersectionToTarget = target.subtract(intersection)
+      intersectionToTargetLength = intersectionToTarget.length()
+
+      if intersectionToTargetLength < radius
+        hit = true
+
+      if hit
+        dt = Math.sqrt(radius * radius - intersectionToTargetLength * intersectionToTargetLength)
+
+        hit = direction.scale(projectionLength - dt).add(source)
+
+    ###*
+    Detects whether a line intersects a rectangle.
+
+        rect = engine.add
+          class: "circle"
+          x: 50
+          y: 50
+          width: 20
+          height: 20
+    
+        Collision.rayRectangle(Point(0, 0), Point(1, 0), rect)
+        # => true
+
+    @name rayRectangle
+    @methodOf Collision
+    @param {Point} source The starting position
+    @param {Point} direction A vector from the point
+    @param {Object} target The rectangle
+    @returns {Boolean} true if the line intersects the rectangle, false otherwise
+    ###
+    rayRectangle: (source, direction, target) ->
+      unless target.xw? and target.yw?
+        if target.width? and target.height?
+          xw = target.width/2
+          yw = target.height/2
+
+          # Convert from bounds rect to centeredBounds rect
+          return Collision.rayRectangle source, direction,
+            x: target.x + xw
+            y: target.y + yw
+            xw: xw
+            yw: yw
+        else
+          error "Bounds object isn't a rectangle"
+
+          return
+
+      xw = target.xw
+      yw = target.yw
+
+      if source.x < target.x
+        xval = target.x - xw
+      else
+        xval = target.x + xw
+
+      if source.y < target.y
+        yval = target.y - yw
+      else
+        yval = target.y + yw
+
+      if direction.x == 0
+        p0 = Point(target.x - xw, yval)
+        p1 = Point(target.x + xw, yval)
+
+        t = (yval - source.y) / direction.y
+      else if direction.y == 0
+        p0 = Point(xval, target.y - yw)
+        p1 = Point(xval, target.y + yw)
+
+        t = (xval - source.x) / direction.x
+      else
+        tX = (xval - source.x) / direction.x
+        tY = (yval - source.y) / direction.y
+
+        # TODO: These special cases are gross!
+        if (tX < tY || (-xw < source.x - target.x < xw)) && !(-yw < source.y - target.y < yw)
+          p0 = Point(target.x - xw, yval)
+          p1 = Point(target.x + xw, yval)
+
+          t = tY
+        else
+          p0 = Point(xval, target.y - yw)
+          p1 = Point(xval, target.y + yw)
+
+          t = tX
+
+      if t > 0
+        areaPQ0 = direction.cross(p0.subtract(source))
+        areaPQ1 = direction.cross(p1.subtract(source))
+
+        if areaPQ0 * areaPQ1 < 0
+          hit = direction.scale(t).add(source)
+
+  (exports ? this)["Collision"] = Collision
+)()
+

data/source/collision_response.coffee

@@ -0,0 +1,28 @@
+CollisionResponse = (I={}, self) ->
+    # Handle multi-include
+  self.unbind ".Movable"
+    
+  self.bind 'update.Movable', (elapsedTime) ->
+    t = (elapsedTime * I.velocity.x).abs()
+    unit = I.velocity.x.sign()
+
+    # x dimension
+    t.times ->
+      if self.collide(unit, 0, ".solid")
+        I.velocity.x = 0
+      else
+        I.x += unit
+
+    t = (elapsedTime * I.velocity.y).abs()
+    unit = I.velocity.y.sign()
+    # y dimension
+    t.times ->
+      if self.collide(0, unit, ".solid")
+        I.velocity.y = 0
+      else
+        I.y += unit
+
+  self.extend
+    collide: (xOffset, yOffset, className) ->
+      engine.find(className).inject false, (hit, block) ->
+        hit || Collision.rectangular(self.bounds(xOffset, yOffset), block.bounds())