entityjs 0.2.2 → 0.3.0

data/templates/platform/scripts/util/level.js

@@ -0,0 +1,84 @@
+re.c('level')
+.defines({
+  
+  build:function(){
+    if(re.hitmap){
+      re.hitmap.dispose();
+    }
+    re.hitmap = re.e('hitmap');
+    
+    this.placeTiles();
+    
+    this.placeHero();
+    
+    //items requires hero to be defined first
+    this.placeItems();
+    
+  },
+  
+  teardown:function(){
+    //todo
+  },
+  
+  placeTiles:function(){
+    
+    var map = this.layer.data.$;
+    
+    for(var y=0; y<map.length; y++){
+      
+      for(var x=0; x<map[0].length; x++){
+        
+        var v = map[y][x];
+        
+        if(v){
+          v--;
+          
+         re.e('tile').attr({
+          tileX:x,
+          tileY:y,
+          frame:v
+          });
+          
+          //add to hitmap
+          re.hitmap.automap(x, y, 1);
+          
+        }
+        
+      }
+      
+    }
+    
+  },
+  
+  placeItems:function(){
+    
+    var gid = this.tileset[2].firstgid;
+    var items = this.objectgroup[1].object;
+    
+    for(var i in items){
+      var it = items[i];
+      
+      var frame = items[i].gid - gid;
+      
+      re.e('t'+frame).attr({
+        posX:it.x,
+        posY:it.y - re.tile.sizeY,
+        frame:frame
+      });
+      
+    }
+  },
+  
+  placeHero:function(){
+    
+    var pos = this.objectgroup[0].object;
+    
+    re.e('hero')
+    .attr({
+      posX:pos.x,
+      posY:pos.y - re.tile.sizeY //tiled editor adds an extra tile to y
+    });
+    
+  }
+  
+});

data/templates/platform/tests/display/bit_test.js

@@ -0,0 +1,7 @@
+module('bit', lazy('bit'));
+
+test('valid', function(){
+  
+  ok(e.has('bit.png align'));
+  
+});

data/templates/platform/tests/display/hero_test.js

@@ -0,0 +1,73 @@
+module('hero', lazy('hero'));
+
+test('has flicks', function(){
+  
+  expectFlicker(e, 'idle');
+  expectFlicker(e, 'run');
+  expectFlicker(e, 'jump');
+  expectFlicker(e, 'ladder');
+  
+});
+
+test('has components', function(){
+  ok(e.has('hero.png tsprite update force flicker body'));
+});
+
+test('flickers idle when not moving', function(){
+  
+  e.flicker('run');
+  
+  stub(e, 'isIdle', function(){return true});
+  
+  e.update();
+  
+  ok(e.flickering('idle'));
+  
+});
+
+test('moves right', function(){
+  
+  expectCall(e, 'flicker');
+  
+  keypress('d', function(){
+    e.update();
+  });
+  
+  
+});
+
+test('moves left', function(){
+  
+  expectCall(e, 'flicker');
+  
+  keypress('a', function(){
+    e.update();
+  });
+  
+});
+
+test('jumps when w pressed', function(){
+  
+  //setup requrements for jumping
+  e.ground = true;
+  e.jump = false;
+  
+  expectCall(e, 'forceJump');
+  
+  keypress('w', function(){
+    e.update();
+  });
+  
+});
+
+test('resets jump when hitting the y axis', function(){
+  
+  e.ground = false;
+  e.jump = true;
+  
+  e.jumpReset(false, true, 10, 999);
+  
+  ok(e.ground);
+  ok(!e.jump);
+  
+});

data/templates/platform/tests/display/tile_test.js

@@ -0,0 +1,7 @@
+module('tile', lazy('tile'));
+
+test('valid', function(){
+  
+  ok(e.has('tsprite tiles.png'))
+  
+});

data/templates/platform/tests/display/tsprite_test.js

@@ -0,0 +1,8 @@
+module('tsprite', lazy('tsprite'));
+
+test('valid', function(){
+  
+  eq(e.sizeX, re.tile.sizeX)
+  eq(e.sizeY, re.tile.sizeY)
+  
+});

data/templates/platform/tests/factories.js

@@ -0,0 +1,30 @@
+/*
+The factories file should define factories for creating various entities.
+A factory is an easy way to create complex entities for testing.
+*/
+factory('spring', function(){
+  this.hero = re.e('hero');
+});
+
+factory('item', function(){
+  this.hero = re.e('hero');
+})
+
+//can also use f
+f('hero', function(){
+  //this is a fake value because factories 
+  //don't have much use in this project
+  this.health = 100;
+  
+  //all normal methods are available too
+  this.on('update', function(){
+    //something
+  });
+});
+
+/*
+Create an entity from a factory..
+
+var hero = f('hero') //new entity
+hero.health = 100;
+*/

data/templates/platform/tests/items/coin_test.js

@@ -0,0 +1,28 @@
+module('coin', lazy('coin'));
+
+test('valid', function(){
+  
+  expectListener(e, 'update');
+  
+  expectFlicker(e, 'glow');
+  
+});
+
+test('touch should collect', function(){
+  
+  expectCall(e, 'collect');
+  
+  e.touch();
+  
+})
+
+test('collect should dispose and stuff', function(){
+  
+  expectCall(e.sfx, 'play');
+  expectCall(e, 'dispose');
+  
+  expectTrigger(e, 'collect');
+  
+  e.collect();
+  
+})

data/templates/platform/tests/items/item_test.js

@@ -0,0 +1,36 @@
+module('item', lazy('item'));
+
+test('has components', function(){
+  
+  ok(e.has('tsprite update items.png'))
+  
+});
+
+test('update method', function(){
+  
+  //touching default to false
+  ok(!e.touching)
+  
+  expectListener(e, 'update');
+  
+});
+
+test('hitting hero should call touch', function(){
+  
+  expectCall(e, 'touch');
+  
+  //fake hitBody and always return true
+  stub(e.hero, 'hitBody', function(){ return true; });
+  
+  e.item_update();
+  
+  //should call untouch afterwards
+  
+  //force hitbody to always return false now...
+  stub(e.hero, 'hitBody', function(){ return false; });
+  
+  expectCall(e, 'untouch');
+  
+  e.item_update();
+  
+});

data/templates/platform/tests/items/spring_test.js

@@ -0,0 +1,21 @@
+module('spring', lazy('spring'));
+
+test('flicker animation', function(){
+  
+  expectFlicker(e, 'bounce');
+  
+});
+
+test('bounce on touch and key press', function(){
+  stub(re, 'pressed', function(key){
+    //make sure w key is checked
+    equal(key, 'w');
+    
+    return true;
+  });
+  
+  expectCall(e, 'flicker');
+  
+  e.touch();
+  
+});

data/templates/platform/tests/scenes/home_test.js

@@ -0,0 +1,9 @@
+module('home');
+
+test('move from to play', function(){
+  
+  expectCall(re.scene('play'), 'enter');
+  
+  re.scene('home').enter();
+  
+});

data/templates/platform/tests/scenes/load_test.js

@@ -0,0 +1,11 @@
+module('load');
+
+test('load stuff', function(){
+  
+  stub(re.scene('home'), 'enter', function(){start()});
+  
+  re.scene('load').enter();
+  
+  stop();
+  
+});

data/templates/platform/tests/scenes/play_test.js

@@ -0,0 +1,15 @@
+module('play');
+
+test('enter play scene', function(){
+  
+  expectCall(re('level1.tmx')[0], 'build');
+  
+  re.scene('play').enter('level1');
+  
+  ok(re.screen.posX != 0);
+  ok(re.screen.posY != 0);
+  
+  is(re.scene('play').counter);
+  is(re.scene('play').level);
+  
+});

data/templates/platform/tests/util/counter_test.js

@@ -0,0 +1,9 @@
+module('counter', lazy('counter'));
+
+test('add value', function(){
+  
+  e.add(1);
+  
+  eq(e.add(), 1);
+  
+})

data/templates/platform/tests/util/level_test.js

@@ -0,0 +1,29 @@
+module('level', {
+  setup:function(){
+    //take existing level
+    e = re('level1.tmx')[0];
+  }
+});
+
+test('build level', function(){
+  
+  e.build();
+  
+  //some simple smoke tests
+  ok(re('hero').length != 0);
+  
+  ok(re('tile').length != 0);
+  
+  ok(re('item').length != 0);
+  
+  //should probably write better tests
+});
+
+test('teardown level', function(){
+  
+  //does nothing in code
+  e.teardown();
+  
+  //todo write tests...
+  //ok(re('hero').length == 0)
+});