entityjs 0.3.1 → 0.3.2

data/templates/tiltmaze/scripts/structs/level.js

@@ -0,0 +1,82 @@
+re.level = re.c('level')
+.requires('automap')
+.statics({
+  get:function(num){
+    //find entity with component
+    return re('level'+num+'.json')[0];
+  }
+})
+.defines({
+  
+  setup:function(){
+    
+    //default value for blanks in automap
+    this.automapDefault = re.e('walltile');
+    
+    for(var y=0; y<this.map.length; y++){
+      for(var x=0; x<this.map[0].length; x++){
+        
+        var tile = this.map[y][x];
+        
+        if(!tile) continue;
+        
+        //place tiles
+        var e = re.walltile.factory(tile)
+        .tile(x, y);
+        
+        this.automap(x, y, e);
+        
+      }
+    }
+    
+    //place ball
+    this.ball = re.e('ball')
+    .tile(this.start[0], this.start[1])
+    .on('move:update', this.checkTargets);
+    
+    this.ball.level = this;
+    
+    re('target').dispose();
+    
+    //place target
+    for(var i in this.targets){
+      var targ = this.targets[i];
+      
+      re.e('target')
+      .tile(targ[0], targ[1]);
+      
+    }
+    
+  },
+  
+  checkTargets:function(){
+    
+    var ball = this;
+    
+    re('target').each(function(){
+      
+      if(ball.tileX() == this.tileX() && this.tileY() == ball.tileY()){
+        this.dispose();
+      }
+      
+    });
+    
+    if(re('target').length == 0){
+      re.scene('game').advance();
+    }
+  },
+  
+  teardown:function(){
+    //remove tiles
+    re('walltile').dispose();
+    
+    re('target').dispose();
+    
+    //remove ball
+    re('ball').dispose();
+  }
+  
+})
+.dispose(function(){
+  this.teardown();
+});

data/templates/tiltmaze/scripts/tiles/walltile.js

@@ -0,0 +1,147 @@
+re.walltile = re.c('walltile')
+.statics({
+  factory:function(num){
+    var e = re.e('walltile');
+    switch(num){
+      case 1:
+      return e.attr({
+        topWall:true
+      });
+      
+      case 2:
+      return e.attr({
+        rightWall:true
+      });
+      
+      case 3:
+      return e.attr({
+        bottomWall:true
+      });
+      
+      case 4:
+      return e.attr({
+        leftWall:true
+      });
+      
+      case 5:
+      return e.attr({
+        topWall:true,
+        rightWall:true
+      });
+      
+      case 6:
+      return e.attr({
+        bottomWall:true,
+        rightWall:true
+      });
+      
+      case 7:
+      return e.attr({
+        leftWall:true,
+        bottomWall:true
+      });
+      
+      case 8:
+      return e.attr({
+        topWall:true,
+        leftWall:true
+      });
+      
+      case 10:
+      return e.attr({
+        leftWall:true,
+        bottomWall:true,
+        rightWall:true
+      });
+      
+      case 11:
+      return e.attr({
+        rightWall:true,
+        topWall:true,
+        bottomWall:true
+      });
+      
+      case 12:
+      return e.attr({
+        topWall:true,
+        rightWall:true,
+        leftWall:true
+      })
+      
+      case 13:
+      return e.attr({
+        topWall:true,
+        leftWall:true,
+        bottomWall:true
+      })
+    }
+    
+    return null;
+  }
+})
+.requires('tile draw')
+.defines({
+  
+  leftWall:false,
+  rightWall:false,
+  topWall:false,
+  bottomWall:false,
+  
+  thick:3,
+  
+  draw:function(c){
+    
+    c.fillStyle = '#000';
+    
+    //first wall
+    if(this.topWall){
+      c.fillRect(0, 0, this.sizeX, this.thick);
+    }
+    
+    //bottom wall
+    if(this.bottomWall){
+      c.fillRect(0, this.sizeY - this.thick, this.sizeX, this.thick);
+    }
+    
+    //left wall
+    if(this.leftWall){
+      c.fillRect(0, 0, this.thick, this.sizeY);
+    }
+    
+    //right wall
+    if(this.rightWall){
+      c.fillRect(this.sizeX - this.thick, 0, this.thick, this.sizeY); 
+    }
+    
+  },
+  
+  checkWall:function(x, y){
+    if(y == 1){
+      return this.topWall;
+    } else if(y == -1){
+      return this.bottomWall;
+    }
+    
+    if(x == 1){
+      return this.leftWall;
+    } else if(x == -1){
+      return this.rightWall;
+    }
+    
+  },
+  
+  checkWallInside:function(x, y){
+    if(y == 1){
+      return this.bottomWall;
+    } else if(y == -1){
+      return this.topWall;
+    }
+    
+    if(x == 1){
+      return this.rightWall;
+    } else if(x == -1){
+      return this.leftWall;
+    }
+  }
+  
+});

data/templates/tiltmaze/tests/displays/ball_test.js

@@ -0,0 +1,67 @@
+module('displays/ball', lazy('level box', function(){
+  ball = level.ball;
+}));
+
+test('move up correctly', function(){
+  stop();
+  
+  ball.on('move:finish', function(){
+    eq(this.tileY(), 0);
+    start();
+  });
+  
+  ball.tileY(2);
+  
+  keypress('w', function(){
+    ball.update();
+  });
+  
+});
+
+test('move down correctly', function(){
+  stop();
+  
+  ball.on('move:finish', function(){
+    eq(this.tileY(), level.map.length-1);
+    start();
+  });
+  
+  keypress('s', function(){
+    ball.update();
+  });
+  
+});
+
+test('move right correctly', function(){
+  stop();
+  
+  ball.on('move:finish', function(){
+    eq(this.tileX(), level.map[0].length-1);
+    start();
+  });
+  
+  ball.tileX(0);
+  
+  keypress('d', function(){
+    ball.update();
+  });
+  
+});
+
+test('move left correctly', function(){
+  stop();
+  
+  var width = level.map[0].length -1;
+  
+  ball.on('move:finish', function(){
+    eq(this.tileX(), 0);
+    start();
+  });
+  
+  ball.tileX(width);
+  
+  keypress('a', function(){
+    ball.update();
+  });
+  
+});

data/templates/tiltmaze/tests/displays/target_test.js

@@ -0,0 +1,8 @@
+module('displays/target', lazy('target'));
+
+test('draws correctly', function(){
+  
+  //uncomment stop to see it on canvas
+  //stop();
+  expect(0);
+});

data/templates/tiltmaze/tests/factories.js

@@ -0,0 +1,38 @@
+factory('level', function(){
+  this.targets = [];
+  this.map = [[]];
+  this.start = [0,0];
+  
+  this.setup();
+});
+
+//fake level for ball testing
+factory('level box', function(){
+  this.targets = [
+  [4, 4],
+  [3, 1]
+  ];
+  
+  this.map = [
+  [8,1,1,1,5],
+  [4,0,0,0,2],
+  [4,0,0,0,2],
+  [4,0,0,0,2],
+  [7,3,3,3,6]
+  ];
+  
+  this.start = [0,0];
+  
+  this.setup();
+});
+
+factory('ball', function(){
+  
+  //stub out level
+  this.level = {
+    automap:function(){
+      return null;
+    }
+  };
+  
+});

data/templates/tiltmaze/tests/scenes/game_test.js

@@ -0,0 +1,59 @@
+module('scenes/game', lazyScene('game'));
+
+test('load level', function(){
+  
+  is(game.currentLevel);
+  
+});
+
+test('quit on keyup', function(){
+  
+  expectCall(game, 'quit');
+  
+  keyup('q');
+  
+})
+
+test('restart on keyup', function(){
+  
+  expectCall(game, 'restart');
+  
+  keyup('r');
+  
+});
+
+//uncomment the stop to test the level
+test('test level1.json', function(){
+  //stop();
+  re.scene('game').enter(2);
+  
+  expect(0);
+});
+
+test('test level2.json', function(){
+  //stop();
+  re.scene('game').enter(2);
+  
+  expect(0);
+});
+
+test('test level3.json', function(){
+  //stop();
+  re.scene('game').enter(3);
+  
+  expect(0);
+});
+
+test('test level4.json', function(){
+  //stop();
+  re.scene('game').enter(4);
+  
+  expect(0);
+});
+
+test('test level5.json', function(){
+  //stop();
+  re.scene('game').enter(5);
+  
+  expect(0);
+});

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

@@ -0,0 +1,7 @@
+module('scenes/home', lazyScene('home'));
+
+test('entities should exist', function(){
+  
+  expect(0);
+  
+});

data/templates/tiltmaze/tests/structs/level_test.js

@@ -0,0 +1,44 @@
+module('structs/level', lazy('level box'));
+
+test('defines ball', function(){
+  
+  ball = level.ball;
+  
+  is(ball);
+  
+  eq(ball.level, level);
+  
+});
+
+test('defines targets', function(){
+  
+  //lazy smoke test
+  ok(re('target').length != 0);
+  
+});
+
+test('collects targets advances to next level', function(){
+  
+  //two targets are in the level
+  //collecting them should advance to the next one
+  
+  expectCall(re.scene('game'), 'advance');
+  
+  var ball = level.ball;
+  
+  var first = re('target')[0];
+  
+  //move to target
+  ball.tile(first);
+  
+  ball.trigger('move:update');
+  
+  eq(re('target').length, 1);
+  
+  var last = re('target')[0];
+  
+  ball.tile(last);
+  
+  ball.trigger('move:update');
+  
+});

data/templates/tiltmaze/tests/tiles/walltile_test.js

@@ -0,0 +1,36 @@
+module('tiles/walltile', lazy('walltile'));
+
+test('display correctly', function(){
+  
+  //testing the visual
+  //use stop() to see it
+  walltile.topWall = true;
+  walltile.bottomWall = true;
+  walltile.leftWall = true;
+  walltile.rightWall = true;
+  
+  expect(0);
+  
+});
+
+//these are mostly smoke tests
+//just making sure the methods don't crash
+test('create factory wall tile', function(){
+  
+  ok(re.walltile.factory(1).topWall);
+  
+});
+
+test('checkWall', function(){
+  walltile.topWall = true;
+  
+  ok(walltile.checkWall(0, 1));
+  
+});
+
+test('checkWallInside', function(){
+  walltile.bottomWall = true;
+  
+  ok(walltile.checkWallInside(0, 1));
+  
+});