entityjs 0.3.1 → 0.3.2

data/templates/pong/tests/controls/arena_test.js

@@ -0,0 +1,20 @@
+module('controls/arena', lazy('arena'));
+
+test('start round', function(){
+  
+  arena.startRound();
+  
+  is(arena.ball);
+  
+  ok(re('ball').length == 1);
+  
+  
+});
+
+test('stop round', function(){
+  
+  arena.stopRound();
+  
+  expect(0);
+  
+});

data/templates/pong/tests/controls/hitmap_test.js

@@ -0,0 +1,89 @@
+/*
+The hitmap controls the balls boundaires, so i'll write some extra tests to make sure it works.
+*/
+module('controls/hitmap', {
+  setup:function(){
+    hitmap = f('hitmap');
+    ball = f('ball');
+  },
+  teardown:function(){
+    hitmap.dispose();
+    ball.dispose();
+  }
+});
+
+test('ball hitting the left side should trigger event', function(){
+  
+  ball.posX = -1 + ball.hsizeX;
+  
+  expectTrigger(hitmap, 'score:left');
+  
+  hitmap.checkHit(ball);
+  
+});
+
+test('ball hitting the right side should trigger event', function(){
+  
+  ball.posX = re.sys.sizeX - ball.hsizeX + 1;
+  
+  expectTrigger(hitmap, 'score:right');
+  
+  hitmap.checkHit(ball);
+  
+});
+
+test('ball should hit top', function(){
+  
+  ball.posY = -1 + ball.hsizeY;
+  
+  var res = hitmap.checkHit(ball);
+  
+  eq(res.hitY, 1);
+  eq(res.posY, ball.hsizeY);
+  
+});
+
+test('ball should hit bottom', function(){
+  
+  ball.posY = re.sys.sizeY - ball.hsizeY + 1;
+  
+  var res = hitmap.checkHit(ball);
+  
+  eq(res.hitY, 1);
+  eq(res.posY, re.sys.sizeY - ball.hsizeY);
+  
+});
+
+test('ball should hit right of paddle', function(){
+  
+  var paddle = re.e('paddle')
+  .attr({
+    posX:100,
+    posY:100
+  });
+  
+  ball.posX = paddle.posX + paddle.hsizeX + ball.hsizeX;
+  
+  var res = hitmap.checkHit(ball);
+  
+  ok(res.hitX);
+  eq(res.posX, ball.posX+1);
+  
+})
+
+test('ball should hit left of paddle', function(){
+  
+  var paddle = re.e('paddle')
+  .attr({
+    posX:100,
+    posY:100
+  });
+  
+  ball.posX = paddle.posX - ball.hsizeX - paddle.hsizeX;
+  
+  var res = hitmap.checkHit(ball);
+  
+  ok(res.hitX);
+  eq(res.posX, ball.posX-1);
+  
+});

data/templates/pong/tests/controls/player_test.js

@@ -0,0 +1,25 @@
+module('controls/player', lazy('player'));
+
+test('paddle moves down on w press', function(){
+  
+  player.posY = 30;
+  
+  expectValueDown(player, 'posY');
+  
+  keypress('w', function(){
+    player.update();
+  });
+  
+});
+
+test('paddle moves up on s press', function(){
+  
+  player.posY = 10;
+  
+  expectValueUp(player, 'posY');
+  
+  keypress('s', function(){
+    player.update();
+  });
+  
+});

data/templates/pong/tests/controls/twoarena_test.js

@@ -0,0 +1,7 @@
+module('controls/twoarena', lazy('twoarena'));
+
+test('creates second player', function(){
+  
+  ok(twoarena.paddle2.has('player'));
+  
+});

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

@@ -0,0 +1,10 @@
+module('displays/ball', lazy('ball'));
+
+test('reset ball', function(){
+  
+  ball.reset();
+  
+  ok(ball.velX != 0)
+  ok(ball.velY != 0)
+  
+});

data/templates/pong/tests/displays/counter_test.js

@@ -0,0 +1,13 @@
+module('displays/counter', lazy('counter'));
+
+test('counting up should trigger win', function(){
+  
+  counter.name = 'blah';
+  counter.maxCount = 1;
+  counter.count = 0;
+  
+  expectTrigger(counter, 'max', [counter.name]);
+  
+  counter.up();
+  
+});

data/templates/pong/tests/displays/paddle_test.js

@@ -0,0 +1,17 @@
+module('displays/paddle', lazy('paddle'));
+
+test('stay within bounds', function(){
+  
+  paddle.posY = -10;
+  
+  paddle.checkBounds();
+  
+  ok(paddle.posY >= 0);
+  
+  paddle.posY = re.sys.sizeY + 10;
+  
+  paddle.checkBounds();
+  
+  ok(paddle.posY <= re.sys.sizeY)
+  
+});

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

@@ -0,0 +1,16 @@
+module('scenes/game');
+
+test('exit cleanly', function(){
+  
+  re.scene('game').enter();
+  
+  //game finished
+  re('counter')[0]
+  .attr({
+    maxCount:1
+  })
+  .up();
+  
+  ok(re('counter').length == 0)
+  
+});

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

@@ -0,0 +1,30 @@
+module('scenes/home', {
+  setup:function(){
+    re.scene('home').enter();
+  },
+  teardown:function(){
+    re.scene('home').exit();
+  }
+});
+
+test('create home screen', function(){
+  
+  is(re('text')[0]);
+  
+});
+
+test('z should go to single player', function(){
+  
+  expectCall(re.scene('game'), 'enter', [false]);
+  
+  keyup('z');
+  
+});
+
+test('x should go to two player', function(){
+  
+  expectCall(re.scene('game'), 'enter', [true]);
+  
+  keyup('x');
+  
+});

data/templates/pong/tests/scenes/over_test.js

@@ -0,0 +1,16 @@
+module('scenes/over');
+
+test('enter over scene', function(){
+  
+  var message = 'You lost!';
+  
+  re.scene('over').enter(message);
+  
+  eq(re('text')[0].text(), message);
+  
+  expectCall(re.scene('home'), 'enter');
+  
+  //back to home
+  keyup('z');
+  
+});

data/templates/tiltmaze/config.yml

@@ -0,0 +1,25 @@
+# Configure your game settings
+
+width: 180
+height: 180
+canvas-id: game-canvas
+
+canvas-border: false
+
+#files to ignore in /scripts
+scripts-ignore:
+  
+#specify files to be loaded first in /scripts
+order:
+  /tile.js$
+  
+#components to ignore in the entityjs source
+#reduce file size by ignoring unused components
+entity-ignore:
+  socket
+  wait
+  group
+
+#ignore tests in /tests
+tests-ignore:
+  

data/templates/tiltmaze/readme.txt

@@ -0,0 +1,79 @@
+------------- EntityJS Gem ----------------------
+
+The EntityJS Gem lets you quickly create HTML5 javascript games.
+
+# Directory Structure
+
+## /assets 
+Contains all sounds, images and data files. Place all sounds in the sounds directory
+and all the images in the images directory. These directories will be looked at
+and an asset array will be created for easy asset loading (see scripts/scenes/load.js)
+
+Creating any other directory or placing files in the levels directory will be seen
+as data files and will be read and automatically put in js files.
+
+For example, if I have a directory like /assets/animations/monster.json.
+
+The file will automatically be read upon calling 'entityjs refresh' and will be turned into this:
+
+re.e('monster.json animation')
+.attr(**Animation JSON here**);
+
+Which means you can edit files in different programs and not worry about copying and pasting
+the contents. Just run entityjs refresh.
+
+At the moment JSON, XML and TMX is supported but in the future, YAML, and CSV will be supported.
+TMX is a special XML format for a tile map editor called tiled.
+
+## /builds
+
+Contains assets and minified code for the game.
+
+## /scripts
+
+Contains javascripts for the game.
+
+## /tests
+
+Contains tests for the game. It is good practice to keep this structured exactly the same as the scripts
+directory.
+
+## config.yml
+
+A configuration file in yaml. This can be edited in any text editor.
+
+## readme.txt
+
+Good practice to make one for every game to help other people.
+
+# Commands
+
+## create a new entityjs game
+entityjs new [project_name]
+
+- example
+entityjs new alien_shooter
+
+- create game with arrow_keys template
+entityjs new alien_shooter alien arrow_keys
+
+## create a new component
+entityjs comp [component_name]
+
+- example
+entityjs comp hero
+
+## build game
+entityjs build
+
+Exports game in builds directory
+
+## build game with custom name
+entityjs build release1
+
+## Run server
+entityjs server
+or
+entityjs s
+
+Navigate to localhost:2345 to play the game.

data/templates/tiltmaze/scripts/displays/ball.js

@@ -0,0 +1,78 @@
+re.c('ball')
+.requires('tile draw update')
+.defines({
+  color:'#ff0000',
+  speed:6,
+  moving:false,
+  pad:5,
+  
+  draw:function(c){
+    c.fillStyle = this.color;
+    
+    c.beginPath();
+        var r = 10;
+        
+        c.arc(r + 5, r + 5, r, 0, Math.PI*2, true);
+    
+    c.closePath();
+    
+    c.fill();
+  },
+  
+  move:function(x, y){
+    
+    var tx = this.tileX();
+    var ty = this.tileY();
+    
+    var tile = this.level.automap(tx, ty);
+    var tileAfter = this.level.automap(tx+x, ty+y);
+    
+    if(tileAfter && !tile.checkWallInside(x, y) && !tileAfter.checkWall(x, y)){
+      
+      if(y){
+        this.posY += this.speed * y;
+      }
+      if(x){
+        this.posX += this.speed * x;
+      }
+      
+    } else {
+      this.tile(tx, ty);
+      this.moving = false;
+      this.off('update');
+      this.on('update', this.update);
+      this.trigger('move:finish');
+    }
+    
+    this.trigger('move:update');
+  },
+  
+  keydown:function(x, y){
+    if(this.moving) return;
+    this.moving = true;
+    this.on('update', function(){
+      this.move(x, y);
+    });
+  },
+  
+  update:function(){
+    
+    if(re.pressed('a', 'left')){
+      this.keydown(-1, 0);
+    } else if(re.pressed('d', 'right')){
+      this.keydown(1, 0);
+    }
+    
+    if(re.pressed('s', 'down')){
+      this.keydown(0, 1);
+    } else if(re.pressed('w', 'up')){
+      this.keydown(0, -1);
+    }
+    
+  }
+  
+})
+.init(function(){
+  
+  this.on('update', this.update);
+});

data/templates/tiltmaze/scripts/displays/target.js

@@ -0,0 +1,13 @@
+re.c('target')
+.requires('draw tile')
+.defines({
+  color:'#0000ff',
+  
+  draw:function(c){
+    
+    c.fillStyle = this.color;
+    
+    c.fillRect(this.sizeX / 2 - 5, this.sizeY / 2 - 5, 10, 10);
+  }
+  
+});

data/templates/tiltmaze/scripts/displays/tile.js

@@ -0,0 +1,2 @@
+re.tile.sizeX = 30;
+re.tile.sizeY = 30;

data/templates/tiltmaze/scripts/init.js

@@ -0,0 +1,7 @@
+re.ready(function(){
+  
+  re.sys.init(re.canvas).start();
+  
+  re.scene('home').enter();
+  
+});

data/templates/tiltmaze/scripts/levels/level1.json

@@ -0,0 +1,14 @@
+{
+"map":[
+[12,1,1,8,1,5],
+[4,0,0,0,0,2],
+[4,0,0,0,0,2],
+[4,0,7,0,0,6],
+[7,0,0,0,0,2],
+[7,3,3,3,10,6]
+],
+"targets":[
+[5,3]
+],
+"start":[0,3]
+}

data/templates/tiltmaze/scripts/levels/level2.json

@@ -0,0 +1,14 @@
+{
+"map":[
+[8,1,13,1,1,11],
+[4,0,0,0,0,2],
+[7,0,2,0,0,2],
+[4,0,0,0,6,2],
+[4,0,0,0,0,2],
+[7,6,3,11,3,6]
+],
+"targets":[
+[5,0]
+],
+"start":[0,2]
+}

data/templates/tiltmaze/scripts/levels/level3.json

@@ -0,0 +1,14 @@
+{
+"map":[
+[8,1,1,1,8,5],
+[4,11,0,0,0,2],
+[10,0,0,0,0,2],
+[4,0,0,8,3,2],
+[4,7,0,0,0,6],
+[7,3,3,3,3,6]
+],
+"targets":[
+[3,3]
+],
+"start":[1,1]
+}

data/templates/tiltmaze/scripts/levels/level4.json

@@ -0,0 +1,15 @@
+{
+"map":[
+[8,1,1,1,5],
+[8,0,8,0,2],
+[4,0,0,0,10],
+[10,0,0,0,2],
+[7,3,7,3,6]
+],
+"targets":[
+[2,4],
+[4,0],
+[0,4]
+],
+"start":[3,2]
+}

data/templates/tiltmaze/scripts/levels/level5.json

@@ -0,0 +1,18 @@
+{
+"map":[
+[8,1,11,1,1,5],
+[4,0,0,0,0,12],
+[4,0,0,0,0,2],
+[4,7,0,1,0,2],
+[4,0,0,4,0,2],
+[7,6,3,3,3,10]
+],
+"targets":[
+[0,5],
+[0,1],
+[4,5],
+[5,1],
+[2,0]
+],
+"start":[3,1]
+}

data/templates/tiltmaze/scripts/scenes/game.js

@@ -0,0 +1,56 @@
+re.scene('game')
+.enter(function(levelNum){
+  
+  //prevent default browser actions
+  re.preventDefault('left right up down');
+  
+  this.setLevel(levelNum);
+  this.currentLevel.setup();
+  
+  var self = this;
+  
+  //set keyboard shortcuts
+  re.e('keyboard')
+  .on('keyup:q', function(){
+    self.quit();
+  })
+  .on('keyup:r', function(){
+    self.restart();
+  });
+  
+})
+.attr({
+  
+  setLevel:function(num){
+    
+    this.currentLevel = re.level.get(num);
+    this.num = num;
+    
+    if(!re.is(this.currentLevel)){
+      this.num = 1;
+      this.currentLevel = re.level.get(1);
+    }
+    
+  },
+  
+  advance:function(){
+    this.num++;
+    
+    this.enter(this.num);
+  },
+  
+  restart:function(){
+    this.enter(this.num);
+  },
+  
+  quit:function(){
+    re.scene('home').enter();
+  }
+  
+})
+.exit(function(){
+  
+  this.currentLevel.teardown();
+  re('keyboard').dispose();
+  
+});

data/templates/tiltmaze/scripts/scenes/home.js

@@ -0,0 +1,24 @@
+re.scene('home')
+.enter(function(){
+  
+  //add help text
+  re.e('text align')
+  .attr({
+    font:'bold 30px Verdina',
+    text:'Tiltmaze'
+  })
+  .align(0, -60);
+  
+  re.e('text align keyboard')
+  .text('Press any key to begin\nQ - Quit\nR - Restart')
+  .align()
+  .on('keyup', function(){
+    re.scene('game').enter(1);
+  });
+  
+})
+.exit(function(){
+  
+  re('text').dispose();
+  
+});