pixie_dust 0.0.1

data/test/cooldown.coffee

@@ -0,0 +1,116 @@
+module "Cooldown"
+
+test "objects count down each of their cooldowns", 2, ->
+  obj = GameObject
+    bullet: 83
+    cooldowns:
+      bullet:
+        target: 3
+        approachBy: 1
+
+  5.times ->
+    obj.update(1)
+
+  equals obj.I.bullet, 78, "bullet should decrease by 5"
+
+  100.times ->
+    obj.update(1)
+
+  equals obj.I.bullet, 3, "bullet should not cool down part target value"
+
+test "should handle negative value", ->
+  obj = GameObject
+    powerup: -70
+    cooldowns:
+      powerup:
+        target: 0
+        approachBy: 1
+
+  11.times ->
+    obj.update(1)
+
+  equals obj.I.powerup, -59, "powerup should increase by 11"
+
+  70.times ->
+    obj.update(1)
+
+  equals obj.I.powerup, 0, "powerup should not cooldown past target value"
+
+test "adding many cooldowns to default instance variables", 3, ->
+  obj = GameObject
+    cool: 20
+    rad: 0
+    tubular: 0
+    cooldowns:
+      cool:
+        approachBy: 5
+        target: -5
+      rad:
+        approachBy: 0.5
+        target: 1.5
+      tubular:
+        approachBy: 1
+        target: 1000
+
+  4.times ->
+    obj.update(1)
+
+  equals obj.I.cool, 0
+  equals obj.I.rad, 1.5
+  equals obj.I.tubular, 4
+
+test "#cooldown", 3, ->
+  obj = GameObject()
+
+  obj.cooldown 'health',
+    value: 100
+
+  3.times ->
+    obj.update(1)
+
+  equals obj.I.health, 97, "health cooldown should exist and equal 97"  
+
+  obj.cooldown 'turbo',
+    target: 5
+    approachBy: 3
+    value: 50
+
+  4.times ->
+    obj.update(1)
+
+  equals obj.I.health, 93, "health should continue of cool down when new cooldowns are added"
+  equals obj.I.turbo, 38, "turbo should cool down normally"
+
+test "should not blow up if cooldowns aren't specified", ->
+  obj = GameObject()
+
+  obj.update(1)
+  obj.trigger "afterUpdate", 1
+
+  equals obj.I.age, 1, "should successfully update"
+
+test "use existing value of instance variable as starting value if no value param given", ->
+  obj = GameObject()
+
+  obj.I.health = 3
+
+  obj.cooldown 'health',
+    target: 10
+
+  5.times ->
+    obj.update(1)
+
+  equals obj.I.health, 8
+
+test "initialize property to 0 if no current value", ->
+  obj = GameObject()
+
+  obj.cooldown 'health',
+    target: 10
+
+  5.times ->
+    obj.update(1)
+
+  equals obj.I.health, 5
+
+module()

data/test/debuggable.coffee

@@ -0,0 +1,71 @@
+module "Debuggable"
+
+test 'should exist', ->
+  obj = GameObject()
+  
+  obj.include Debuggable
+  
+  ok obj.debug
+
+test 'should accept x, y for debug position', ->
+  obj = GameObject()
+  
+  obj.include Debuggable
+  
+  obj.debug
+    x: 40
+    y: 90
+    
+  equals obj.I.debug.position.x, 40
+  equals obj.I.debug.position.y, 90
+  
+test 'position should override x, y for debug position', ->
+  obj = GameObject()
+  
+  obj.include Debuggable
+  
+  obj.debug
+    x: 2
+    y: 40
+    position:
+      x: 67
+      y: 34
+      
+  equals obj.I.debug.position.x, 67
+  equals obj.I.debug.position.y, 34
+  
+test '#debug', ->
+  obj = GameObject()
+  
+  obj.include Debuggable
+  
+  equals obj.I.debug.enabled, false
+  
+  obj.debug()
+  
+  equals obj.I.debug.enabled, true
+  
+test '#toggleDebug', ->
+  obj = GameObject()
+  
+  obj.include Debuggable
+  
+  equals obj.I.debug.enabled, false
+  
+  obj.toggleDebug()
+  
+  equals obj.I.debug.enabled, true 
+  
+  obj.toggleDebug()
+  
+  equals obj.I.debug.enabled, false
+  
+  obj.toggleDebug(false)
+  
+  equals obj.I.debug.enabled, false
+  
+  obj.toggleDebug(true)
+  
+  equals obj.I.debug.enabled, true
+  
+module()

data/test/drawable.coffee

@@ -0,0 +1,31 @@
+module "Drawable"
+
+test "alpha", ->
+  object = GameObject()
+
+  equal object.I.alpha, 1
+
+  object2 = GameObject
+    alpha: 0.5
+
+  equal object2.I.alpha, 0.5
+
+test "scale", ->
+  object = GameObject()
+
+  transform = object.transform()
+  
+  equal transform.a, 1
+  equal transform.d, 1
+
+  object = GameObject
+    scale: 2
+    scaleX: -1
+    scaleY: 0.5
+
+  transform = object.transform()
+  
+  equal transform.a, -2
+  equal transform.d, 1
+
+module()

data/test/emitterable.coffee

@@ -0,0 +1,15 @@
+module "Emitter"
+
+test "Particles should move", ->
+  e = Emitter()
+
+  xVelocity = e.I.particleData.velocity.x
+
+  e.update(1)
+
+  ok e.I.particles.length
+
+  equals e.I.particles.first().I.x, xVelocity
+
+module()
+

data/test/engine.coffee

@@ -0,0 +1,228 @@
+module "Engine"
+
+MockCanvas = ->
+  clear: ->
+  context: ->
+    beginPath: ->
+    clip: ->
+    rect: ->
+  drawRect: ->
+  fill: ->
+  withTransform: (t, fn) ->
+    fn(@)
+  clip: ->
+
+test "#play, #pause, and #paused", ->
+  engine = Engine()
+
+  equal engine.paused(), false
+  engine.pause()
+  equal engine.paused(), true
+  engine.play()
+  equal engine.paused(), false
+
+  engine.pause()
+  equal engine.paused(), true
+  engine.pause()
+  equal engine.paused(), false
+
+  engine.pause(false)
+  equal engine.paused(), false
+
+  engine.pause(true)
+  equal engine.paused(), true
+
+test "#save and #restore", ->
+  engine = Engine()
+
+  engine.add {}
+  engine.add {}
+
+  equals(engine.objects().length, 2)
+
+  engine.saveState()
+
+  engine.add {}
+
+  equals(engine.objects().length, 3)
+
+  engine.loadState()
+
+  equals(engine.objects().length, 2)
+
+test "before add event", 1, ->
+  engine = Engine()
+
+  engine.bind "beforeAdd", (data) ->
+    equals data.test, "test"
+
+  engine.add
+    test: "test"
+
+test "#add", ->
+  engine = Engine()
+
+  engine.add "GameObject",
+    test: true
+
+  ok engine.first("GameObject")
+
+test "#add class name only", ->
+  engine = Engine()
+
+  engine.add "GameObject"
+
+  ok engine.first("GameObject")
+
+test "zSort", ->
+  engine = Engine
+    canvas: MockCanvas()
+    zSort: true
+
+  n = 0
+  bindDraw = (o) ->
+    o.bind 'draw', ->
+      n += 1
+      o.I.drawnAt = n
+
+  o2 = engine.add
+    zIndex: 2
+  o1 = engine.add
+    zIndex: 1
+
+  bindDraw(o1)
+  bindDraw(o2)
+
+  engine.frameAdvance()
+
+  equals o1.I.drawnAt, 1, "Object with zIndex #{o1.I.zIndex} should be drawn first"
+  equals o2.I.drawnAt, 2, "Object with zIndex #{o2.I.zIndex} should be drawn second"
+
+test "invalid module throws error", ->
+  raises ->
+    engine = Engine
+      includedModules: ["HellaInvalidModule"]
+
+test "excluded modules", ->
+  engine = Engine
+    excludedModules: "Developer"
+
+  engine = Engine
+    excludedModules: ["Developer"]
+
+test "draw events", 2, ->
+  engine = Engine
+    canvas: MockCanvas()
+    backgroundColor: false
+
+  engine.bind "beforeDraw", ->
+    ok true
+
+  engine.bind "draw", ->
+    ok true
+
+  engine.frameAdvance()
+
+test "Remove event", 1, ->
+  engine = Engine
+    backgroundColor: false
+
+  object = engine.add
+    active: false
+
+  object.bind "remove", ->
+    ok true, "remove called"
+
+  engine.frameAdvance()
+
+test "#find", ->
+  engine = Engine()
+
+  engine.add
+    id: "testy"
+
+  engine.add
+    test: true
+
+  engine.add
+    solid: true
+    opaque: false
+
+  equal engine.find("#no_testy").length, 0
+  equal engine.find("#testy").length, 1
+  equal engine.find(".test").length, 1
+  equal engine.find(".solid=true").length, 1
+  equal engine.find(".opaque=false").length, 1
+
+test "Selector.parse", ->
+  a = Engine.Selector.parse("#foo")
+  equal a.length, 1
+  equal a.first(), "#foo"
+
+  a = Engine.Selector.parse("#boo, baz")
+  equal a.length, 2
+  equal a.first(), "#boo"
+  equal a.last(), "baz"
+
+  a = Engine.Selector.parse("#boo,Light.flicker,baz")
+  equal a.length, 3
+  equal a.first(), "#boo"
+  equal a[1], "Light.flicker"
+  equal a.last(), "baz"
+
+test "Selector.process", ->
+  [type, id, attr, value] = Engine.Selector.process("Foo#test.cool=1")
+
+  equal type, "Foo"
+  equal id, "test"
+  equal attr, "cool"
+  equal value, 1
+
+  [type, id, attr, value] = Engine.Selector.process(".baz=false")
+
+  equal type, undefined
+  equal id, undefined
+  equal attr, "baz"
+  equal value, false
+
+test "#camera", ->
+  engine = Engine()
+
+  equal engine.camera(), engine.cameras().first()
+
+test "#collides", ->
+  engine = Engine()
+
+  engine.collides(Rectangle(0, 0, 10, 10), null)
+
+test "Integration", ->
+  engine = Engine
+    FPS: 30
+
+  object = engine.add
+    class: "GameObject"
+    velocity: Point(30, 0)
+
+  engine.frameAdvance()
+
+  equals object.I.x, 1
+  equals object.I.age, 1/30
+
+test "#setState", 3, ->
+  engine = Engine()
+
+  nextState = GameState()
+
+  engine.setState nextState
+
+  # Test state change events
+  engine.bind "stateEntered", ->
+    ok true
+  engine.bind "stateExited", ->
+    ok true
+
+  engine.update()
+
+  equal engine.I.currentState, nextState
+
+module()

data/test/engine_data.coffee

@@ -0,0 +1,12 @@
+module "Engine"
+
+test "#data", ->
+  engine = Engine
+    backgroundColor: false
+
+  engine.data.score = 0
+  engine.data.score += 50
+  
+  equals engine.data.score, 50
+
+module()

data/test/engine_delay.coffee

@@ -0,0 +1,14 @@
+module "Engine"
+
+test "#delay", 1, ->
+  engine = Engine
+    backgroundColor: false
+
+  3.times (n) ->
+    engine.delay n, ->
+      ok(true)
+
+  engine.frameAdvance()
+
+module()
+

data/test/engine_selector.coffee

@@ -0,0 +1,100 @@
+module "Engine"
+
+test "#closest", ->
+  engine = Engine()
+
+  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
+
+test "#each", ->
+  engine = Engine()
+
+  obj1 = engine.add
+    rad: "Awesome"
+    x: 0
+    y: 5
+
+  obj2 = engine.add
+    rad: "Awesome"
+    x: 5
+    y: 10
+
+  obj3 = engine.add
+    rad: "Awesome"
+    x: 5
+    y: 10
+
+  obj4 = engine.add
+    rad: "Awesome"
+    x: 40
+    y: 320
+
+  indexSum = 0
+
+  engine.each '.rad=Awesome', (obj, index) ->
+    indexSum += index
+
+    if index is 0
+      equals obj, obj1
+    else if index is 1
+      equals obj, obj2
+    else if index is 2
+      equals obj, obj3
+    else if index is 3
+      equals obj, obj4
+
+  equals indexSum, 6
+
+test "#find", ->
+  engine = Engine()
+
+  engine.add
+    findable: true
+    x: 0
+    y: 50
+
+  equals engine.find('.findable').length, 1
+
+  engine.add
+    findable: true
+    x: 50
+    y: 30
+
+  equals engine.find('.findable').length, 2
+
+test "#first", ->
+  engine = Engine()
+
+  obj1 = engine.add
+    type: 'testObj'
+    x: 4
+    y: 20
+
+  equals engine.first('.type=testObj'), obj1, "should find obj1"
+
+  obj2 = engine.add
+    type: 'testObj'
+    x: 9
+    y: 10
+
+  equals engine.first('.type=testObj'), obj1, "should only find the first object"
+
+module()

data/test/expirable.coffee

@@ -0,0 +1,35 @@
+module "Expirable"
+
+test "objects become inactive after their duration", ->
+  obj = GameObject
+    duration: 5
+
+  obj.include Expirable
+
+  4.times ->
+    obj.update(1)
+    obj.trigger "afterUpdate", 1
+
+  equals obj.I.active, true, "object is active until duration is exceeded"
+
+  5.times ->
+    obj.update(1)
+    obj.trigger "afterUpdate", 1
+
+  equals obj.I.active, false, "object is inactive after duration"
+  
+test "should fade out if that option is set", ->
+  obj = GameObject
+    duration: 10
+    alpha: 0.8
+    fadeOut: true
+    
+  obj.include Expirable
+  
+  5.times ->
+    obj.update(1)
+    obj.trigger "afterUpdate", 1
+    
+  equals obj.I.alpha, 0.48
+
+module()

data/test/flickerable.coffee

@@ -0,0 +1,51 @@
+module "Flickerable"
+
+test 'it should set up defaults', ->
+  player = GameObject()
+
+  player.include Flickerable
+  
+  player.flicker()
+  
+  equals player.I.flickerAlpha, 0.5
+  equals player.I.flickerFrequency, 0.1
+  equals player.I.flickerDuration, 2
+  
+test 'it should be able to set one param at a time', ->
+  player = GameObject()
+  
+  player.include Flickerable
+
+  player.flicker
+    frequency: 20
+    
+  equals player.I.flickerAlpha, 0.5
+  equals player.I.flickerFrequency, 20
+  equals player.I.flickerDuration, 2
+  
+  enemy = GameObject()
+  
+  enemy.include Flickerable
+  
+  enemy.flicker
+    alpha: 0.4
+    
+  equals enemy.I.flickerAlpha, 0.4
+  equals enemy.I.flickerFrequency, 0.1
+  equals enemy.I.flickerDuration, 2  
+  
+  boss = GameObject()
+  
+  boss.include Flickerable
+  
+  boss.flicker
+    duration: 3
+ 
+  equals boss.I.flickerAlpha, 0.5
+  equals boss.I.flickerFrequency, 0.1
+  equals boss.I.flickerDuration, 3 
+ 
+#TODO test this with new time step stuff
+#test 'it should change the alpha value when the flicker duration has elapsed', ->
+    
+module()

data/test/follow.coffee

@@ -0,0 +1,34 @@
+module "Follow"
+
+test "should set the correct velocity", ->
+  player = GameObject
+    x: 50
+    y: 50
+    width: 10
+    height: 10
+
+  enemy = GameObject
+    x: 0
+    y: 50
+    widht: 10
+    height: 10
+    speed: 1
+
+  enemy.include(Follow)
+  enemy.follow(player)
+
+  ok enemy.I.velocity.equal(Point(1, 0)), 'enemy should head toward player with a velocity Point(1, 0)'
+
+  rightEnemy = GameObject
+    x: 100
+    y: 50
+    width: 10
+    height: 10
+    speed: 1
+
+  rightEnemy.include(Follow)
+  rightEnemy.follow(player)
+
+  ok rightEnemy.I.velocity.equal(Point(-1, 0)), 'rightEnemy should head toward player with a velocity Point(-1, 0)'
+
+module()