entityjs 0.2.2 → 0.3.0

data/src/util/random.js

@@ -0,0 +1,20 @@
+/*
+The random component implements two helper methods for calculating random numbers.
+
+
+re.random() // 0 - 1
+re.random(10) // 0 - 9
+re.random(10, 30) // 10 - 30
+
+*/
+re.random = function(max, min){
+    var r = Math.random();
+		switch(arguments.length){
+			case 0:
+			return r;
+			case 1:
+			return r * max;
+			case 2:
+			return r * (max - min + 1) + min;
+    }
+};

data/src/util/scene.js

@@ -0,0 +1,102 @@
+
+/*
+Goes to an other scene in the game. This calls the scene method with a possible object argument.
+
+Scenes are a helpful way to organize stages of a game.
+
+//create scene
+re.scene('game')
+.enter(function(data){
+	
+	//remove all 2d elements
+	re('2d').dispose();
+	
+	loadLevel(data.level);
+	
+});
+
+//go to scene
+re.scene('game').enter({tiles:[]} );
+
+*warning- bad idea passing in functions as the first argument
+
+//create manually
+re.e('scene:game')
+.enter(function(){
+  
+})
+
+*/
+re.scene = function(title){
+	var s = re.c('scene');
+	
+  if(!re.is(title)){
+    return s._scenes[re.scene.current];
+  }
+  
+	if(!s._scenes[title]){
+		//add scene
+		re.e('scene:'+title);
+	}
+	
+	return s._scenes[title];
+};
+
+re.c('scene')
+.statics({
+	
+	_scenes:{}
+	
+})
+.init(function(c, title){
+	
+	c._scenes[title] = this;
+	this.sceneName = title;
+	
+})
+.dispose(function(c){
+	
+	delete c._scenes[this.sceneName];
+	
+})
+.defines({
+	
+	enter:function(title){
+    if(!re.is(title, 'function')){
+      
+      if(re.scene.current)
+      re.scene().exit(title);
+      
+      //set current scene
+  		re.scene.current = this.sceneName
+  		
+      if(this.scene_enter)
+    		this.scene_enter.apply(this, arguments);
+      return this;
+    } else {
+      //set new enter method
+  		this.scene_enter = title;
+    }
+		
+		return this;
+	},
+	
+	exit:function(m){
+    if(!re.is(m, 'function')){
+      
+      re.scene.current = '';
+      
+  		if(re.is(this.scene_exit, 'function')){
+  			this.scene_exit.apply(this, arguments);
+  		}
+      
+      if(this.scene_exit)
+      this.scene_exit.apply(this, arguments);
+    } else {
+  		this.scene_exit = m;
+    }
+		
+		return this;
+	}
+  
+});

data/src/util/sheet.js

@@ -0,0 +1,35 @@
+/*
+The sheet component converts a each frame of a sprite sheet into their own components.
+*/
+re.sheet = function(map, components, sizeX, sizeY){
+        
+    var frameWidth = sizeX || re.tile.sizeX;
+    var frameHeight = sizeY || re.tile.sizeY;
+    
+    if(re.is(components,'array')){
+      components = components.join(' ');
+    }
+        
+    //create new sprites for sheet
+        
+    //save frame positions from map
+    var x;
+    var y;
+    var b = [];
+    for(var p in map){
+        x = map[p][0] || 0;
+        y = map[p][1] || 0;
+        b.push(p);
+        re.c(p)
+        .requires('sprite '+components)
+        .defines({
+      frameX:x,
+      frameY:y,
+      sizeX:frameWidth,
+      sizeY:frameHeight
+        });
+            
+    }
+  
+    return b;
+};

data/src/{entityjs/util → util}/support.js

@@ -1,132 +1,109 @@
-/*
-The support component contains information about supported 
-functionality of the browser.
-
-v0.1 currently only checks for support of canvas and canvas text.
-
-FUTURE
--check audio support
-
-//returns true if canvas AND text is supported
-if(re.support('canvas text')){
-	//supports
-}
-
-//checks all arguments and returns first thing thats supported
-re.support('ogg', 'aac', 'mp3', 'wav');
-
-//find first supported storage storage
-re.support('database', 'localstorage');
-
-this is helpful to find a supported codec or a storage component
-
-or add to entity
-
-re.e('support').support('canvas');
-
----- possible support checks
-canvas
-text
-audio
-ogg
-mp3
-wav
-aac
-localstorage
-worker
-webgl
-
-*/
-re.c('support')
-.global({
-
-	support:function(s){
-		var that = re.c('support');
-		
-		if(arguments.length > 1){
-			//find first supported arg and return
-			
-			var d;
-			for(var i=0; i<arguments.length; i++){
-				d = arguments[i];
-				if(that.support(d)){
-					return d;
-				}
-			}
-			
-			return false;
-		}
-		
-		//find if supported
-		var k = s.split(' ');
-		
-		var stat = true;
-		
-		//check multiple supports
-		for(var j in k){
-				stat = stat && !!that[k[j]];
-		}
-		
-		return stat;
-	}
-	
-})
-.extend({
-	support:function(s){
-		return re.c('support').call(this, s);
-	}
-	
-})
-.run(function(){
-	
-	//add supports to component
-	var c = re.c('support');
-	
-	//quick checking function
-	re.support = c.support;
-	
-	//check canvas support
-	c.canvas = !!document.createElement('canvas').getContext;
-	
-	//check for text support
-	c.text = !!(c.canvas && typeof document.createElement('canvas').getContext('2d').fillText == 'function');
-	
-	//check audio support
-	var ele = document.createElement('audio');
-	
-	try {
-	
-		if(c.audio = !!ele.canPlayType){
-			
-			c.ogg  = ele.canPlayType('audio/ogg; codecs="vorbis"');
-			c.mp3  = ele.canPlayType('audio/mpeg;');
-			c.wav  = ele.canPlayType('audio/wav; codecs="1"');
-			c.aac = ele.canPlayType('audio/x-m4a;') || ele.canPlayType('audio/aac;');
-			
-			//switch unsupported codecs to false
-			for(var i in c){
-				if(c[i] == 'no' || c[i] == ''){
-					c[i] = false;
-				}
-			}
-			
-		}
-		
-	} catch(e){}
-	
-	//check local storage
-	try {
-		c.localstorage = !!localStorage.getItem;
-	} catch(e){
-		c.localstorage = false;
-	}
-	
-	//check web worker
-	c.worker = !!window.Worker;
-	
-	//check webgl
-	c.webgl = !!window.WebGLRenderingContext;
-	
-	c.touch = 'ontouchstart' in window;
-	
-});
+/*
+The support component contains information about supported 
+functionality of the browser.
+
+//returns true if canvas AND text is supported
+if(re.support('canvas text')){
+	//supports
+}
+
+//checks all arguments and returns first thing thats supported
+re.support('ogg', 'aac', 'mp3', 'wav');
+
+//find first supported storage storage
+re.support('database', 'localstorage');
+
+this is helpful to find a supported codec or a storage component
+
+or add to entity
+
+re.e('support').support('canvas');
+
+---- possible support checks
+canvas
+text
+audio
+ogg
+mp3
+wav
+aac
+localstorage
+worker
+webgl
+
+*/
+re.support = function(s){
+		if(arguments.length > 1){
+			//find first supported arg and return
+			
+			var d;
+			for(var i=0; i<arguments.length; i++){
+				d = arguments[i];
+				if(re.support(d)){
+					return d;
+				}
+			}
+			
+			return false;
+		}
+		
+		//find if supported
+		var k = s.split(' ');
+		
+		var stat = true;
+		
+		//check multiple supports
+		for(var j in k){
+				stat = stat && !!re.support[k[j]];
+		}
+		
+		return stat;
+}
+	
+	//add supports to component
+	var c = re.support;
+	
+	//check canvas support
+	c.canvas = !!document.createElement('canvas').getContext;
+	
+	//check for text support
+	c.text = !!(c.canvas && typeof document.createElement('canvas').getContext('2d').fillText == 'function');
+	
+	//check audio support
+	var ele = document.createElement('audio');
+	
+	try {
+	
+		if(c.audio = !!ele.canPlayType){
+			
+			c.ogg  = ele.canPlayType('audio/ogg; codecs="vorbis"');
+			c.mp3  = ele.canPlayType('audio/mpeg;');
+			c.wav  = ele.canPlayType('audio/wav; codecs="1"');
+			c.aac = ele.canPlayType('audio/x-m4a;') || ele.canPlayType('audio/aac;');
+			
+			//switch unsupported codecs to false
+			for(var i in c){
+				if(c[i] == 'no' || c[i] == ''){
+					c[i] = false;
+				}
+			}
+			
+		}
+		
+	} catch(e){}
+	
+	//check local storage
+	try {
+		c.localstorage = !!localStorage.getItem;
+	} catch(e){
+		c.localstorage = false;
+	}
+	
+	//check web worker
+	c.worker = !!window.Worker;
+	
+	//check webgl
+	c.webgl = !!window.WebGLRenderingContext;
+	
+	c.touch = 'ontouchstart' in window;
+	

data/templates/arrow_keys/config.yml

@@ -0,0 +1,22 @@
+# Configure your game settings
+
+width: 500
+height: 400
+canvas-id: game-canvas
+
+#files to ignore in /scripts
+scripts-ignore:
+  
+#specify files to be loaded first in /scripts
+order:
+  
+#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/arrow_keys/readme.txt

@@ -0,0 +1,9 @@
+--------------- Arrow Keys ------------
+
+# About
+
+This is a simple example demostrating the usefulness of EntityJS.
+It shows how to use sprites and keyboard controls to move around arrows
+and remove them from screen.
+
+For more information on the engine visit www.entityjs.com

data/templates/arrow_keys/scripts/display/arrow.js

@@ -0,0 +1,69 @@
+/*
+The arrow component is a simple sprite with key controls.
+It listens to system updates and will move around based on WASD keys.
+
+The image comes from arrow.png, you can view the element here, re.c('arrow.png').image.
+
+The sprite component automatically finds the ._image on the entity and draws it to screen.
+It will chop the image into frames based on the sizeX and sizeY values.
+
+The original image is 80x80 and has 4 frames. So its frame sizes will be 40x40.
+
+Switch between frames by using .frame(id), and get the current frame with .frame()
+
+The posX and posY come from the sprite component and defines the position of the image on screen.
+
+*/
+re.c('arrow')
+.requires('update sprite keyboard arrow.png')
+.defines({
+  
+  //speed of the arrow
+  speed:10,
+  //defines the sprite frame size
+  sizeX:40,
+  sizeY:40,
+  
+  update:function(){
+    var s = this.speed;
+    
+    //if w or up key is currently pressed..
+    if(re.pressed('w', 'up')){
+      //moves position y
+			this.posY -= s;
+			
+      //change sprite frame
+			this.frame(0);
+			
+		} else if(re.pressed('s', 'down')){
+		
+			this.posY += s;
+			this.frame(2);
+			
+		}
+		
+		if(re.pressed('a', 'left')){
+		
+			this.posX -= s;
+			this.frame(3);
+			
+		} else if(re.pressed('d', 'right')){
+		
+			this.posX += s;
+			this.frame(1);
+			
+		}
+    
+  }
+  
+})
+.init(function(){
+  
+  //move to the center of the screen
+	this.posX = re.sys.sizeX * 0.5;
+	this.posY = re.sys.sizeY * 0.5;
+  
+  //add event listener
+  this.on('update', this.update);
+  
+});

data/templates/arrow_keys/scripts/init.js

@@ -0,0 +1,10 @@
+//runs when the window is finished loading
+re.ready(function(){
+  //Starts the system and listens for inputs
+  //re.canvas in automatically defined and can be changed in config.yml
+  re.sys.init(re.canvas).start();
+  
+  //enter the next scene
+  re.scene('load').enter();
+  
+});

data/templates/arrow_keys/scripts/input/controls.js

@@ -0,0 +1,35 @@
+/*
+The controls component listens for keyevents and creates new arrows
+based on keys pressed.
+*/
+re.c('controls')
+.requires('keyboard')
+.defines({
+  
+  addArrow:function(count){
+    count = count || 1;
+    //creates a new arrow
+    re.e('arrow', count);
+  },
+  
+  removeArrow:function(){
+    //finds an entity with the arrow component and removes it.
+    re('arrow').random().dispose();
+  }
+  
+})
+.init(function(){
+  //called on instantiation
+  
+  //listen for key events
+  //these come from the keyboard component
+  this.on({
+    'keydown:space': function(){
+      this.addArrow();
+    },
+    'keyup:r': function(){
+      this.removeArrow();
+    }
+  });
+  
+});

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

@@ -0,0 +1,20 @@
+/*
+The home scene is the entry point of the game.
+It creates a new controls entity and a starting arrow to play with.
+*/
+re.scene('home')
+.enter(function(){
+  
+  console.log('entering home scene. . .');
+  
+  //add controls
+  re.controls = re.e('controls');
+  
+  //add first arrow
+  re.controls.addArrow();
+})
+.exit(function(){
+  
+  console.log('exiting home scene. . .');
+  
+})

data/templates/arrow_keys/scripts/scenes/load.js

@@ -0,0 +1,57 @@
+/*
+The load scene loads all images and sounds in the game.
+
+The re.assets object contains two arrays:
+
+re.assets.images
+re.assets.sounds
+
+re.assets is automatically created for you and will contains whatever images
+you place in the /assets/images or /assets/sounds directory.
+
+You can even create new directories and place json or xml inside.
+
+/assets/levels/level1.json
+
+The file contents will be turned into a component and can be used on entities.
+
+If /assets/levels/level1.json contains this:
+
+{"something":100}
+
+It will do this in the background for you:
+
+re.c('level1.json level')
+.defines({
+  something:100
+});
+
+You can even look in the source code and see for yourself.
+
+Of course this will all be included when you run 'entityjs build'
+
+Currently only, json, xml and tmx are supported. Tmx is a special file type used by
+the map maker tiled and it can be used to create levels. More info: http://www.mapeditor.org/
+
+*/
+re.scene('load')
+.enter(function(){
+  
+  re.load(re.assets)
+  .complete(function(){
+    console.log('finished loading...');
+    
+    //move to home
+    re.scene('home').enter();
+  })
+  .error(function(e){
+    console.log('Error loading asset: '+e);
+  })
+  .progress(function(i){
+    console.log('Finished loading: '+i);
+  });
+  
+})
+.exit(function(){
+  //exit load scene
+})

data/templates/arrow_keys/tests/display/arrow_test.js

@@ -0,0 +1,29 @@
+module('arrow');
+
+var arrow = re.e('arrow');
+
+//verify the arrow has the correct sizes
+test('size', function(){
+  
+  equal(arrow.sizeX, 40);
+  equal(arrow.sizeY, 40);
+  
+});
+
+test('keys move arrow', function(){
+  
+  //mock/stub methods in qunit/qunit.mock.js
+  //expects 4 calls to frame
+  expectCall(arrow, 'frame', 4);
+  
+  //simulate keypress / mouse clicks with qunit/qunit.input.js
+  //dispatches a keydown on each key, calls the given method
+  //then dispatches keyup.
+  keypress(['w', 's', 'd', 'a'], function(){
+    arrow.update();
+  });
+  
+  //by the end of the method e.frame() should have been called 4 times
+  //take a look at scripts/display/arrow.js @ update()
+  
+});

data/templates/arrow_keys/tests/init_test.js

@@ -0,0 +1,4 @@
+module('init');
+
+//in tests re.ready is NOT called.
+//make sure re.sys.init() is called or else input will not function!