entityjs 0.2.2

data/src/entityjs/net/socket.js

@@ -0,0 +1,52 @@
+/*
+The socket component is an interface for the new HTML5 websockets.
+
+Its safe to use this abstraction incase specs change in the future.
+
+*/
+re.c('socket')
+.extend({
+	
+	connect:function(address){
+		
+		this.socket = new WebSocket(address);
+		
+	},
+	
+	close:function(){
+		if(!this.socket) return this;
+		
+		this.socket.close();
+		
+		return this;
+	},
+	
+	open:function(callback){
+		if(!this.socket) return this;
+		
+		this.socket.onopen = callback;
+		
+	},
+	
+	error:function(callback){
+		if(!this.socket) return this;
+		
+		this.socket.onerror = callback;
+		
+	},
+	
+	message:function(callback){
+		if(!this.socket) return this;
+		
+		this.socket.onmessage = callback;
+		
+	},
+	
+	send:function(){
+		if(!this.socket) return this;
+		
+		this.socket.send.apply(this.socket, arguments);
+		
+	}
+	
+});

data/src/entityjs/pattern/arraymap.js

@@ -0,0 +1,89 @@
+/*
+The arraymap component creates an auto expandable two-dimensional array.
+*/
+re.c('arraymap')
+.inherit({
+	lengthX:0,
+	lengthY:0
+})
+.extend({
+	/*map:null,
+	size:null,*/
+	value:0,
+	
+	set:function(x, y, value){
+			
+			//increate y length
+			while(y >= this.map.length){
+				var m = new Array(this.map[0]);
+				
+				for(var l in m){
+					m[l] = this.value;
+				}
+				
+				this.map.push(m);
+				
+			}
+			
+			//increase x length
+			while(x >= this.map[this.map.length-1].length){
+				
+				for(var k=0; k<this.map.length; k++){
+					this.map[k].push(this.value);
+				}
+				
+			}
+			
+			this.lengthX = this.map[y].length;
+			this.lengthY = this.map.length;
+			
+			this.map[y][x] = value;
+			
+			return this;
+	},
+	
+	within:function(x, y){
+		
+		if(y < 0 || y >= this.lengthY || x < 0 || x >= this.lengthX){
+			return false;
+		}
+		return true;
+	},
+	
+	get:function(x, y){
+		if(this.within(x,y)){
+			return this.map[y][x];
+		}
+		return null;
+	},
+	
+	copy:function(a){
+		
+		for(var y=0; y<a.length; y++){
+			for(var x=0; x<a[0].length; x++){
+				this.set(x, y, a[y][x]);
+			}
+		}
+		
+		return this;
+	},
+	
+	copyByRef:function(m){
+		
+		this.map = m;
+		
+		if(m.length > 0){
+			this.lengthX = m[0].length;
+		} else {
+			this.lengthX = 0;
+		}
+		
+		this.lengthY = m.length;
+		
+		return this;
+	}
+	
+})
+.init(function(){
+	this.map = [];
+});

data/src/entityjs/pattern/flicker.js

@@ -0,0 +1,214 @@
+/*
+The flicker component calls the implemented method and sends the given information over a period of time.
+
+This is most popular for sprite animation.
+
+It can also be used for graduatly writing text or flashing a drawing object.
+*/
+re.c('flicker')
+.require('update timestep')
+.implement('flick')
+.init(function(){
+	
+	this.flicker_reels = {};
+	this.flicker_old = {};
+	this.flicker_reel = {};
+	
+	this.flicker_flickering = '';
+	
+})
+.extend({
+	
+	flicker_stop:function(){
+		if(this.flickering()){
+		
+			this.signal('animated', this.flicker_flickering);
+			
+			this.flicker_flickering = '';
+			
+			this.stepProgress = 0;
+			this.frameX = this.flicker_oldX;
+			this.frameY = this.flicker_oldY;
+			
+			this.removeSignal('update', this.flicker_update);
+		}
+		return this;
+	},
+	
+	flicker_update:function(t){
+		
+		this.timestep(t, function(){
+			var c = this.flicker_reel;
+			
+			//check if over
+			if(this.flicker_frame == this.flicker_reel.frames.length){
+				
+				if(c.loops == -1 || --this.flicker_loops >= 1){
+					//loop again
+					
+					this.flicker_frame = 0;
+					
+				} else {
+					//done flickering
+					
+					this.flicker_stop();
+					
+					return;
+				}
+			}
+			
+			//flick
+			this.flick(c.frames[this.flicker_frame]);
+			
+			this.flicker_frame++;
+			
+		});
+		
+	},
+	
+	addFlicker:function(id, loops, duration, frames){
+	
+		if(typeof id == 'object'){
+			
+			for(var i in id){
+				if(!id.hasOwnProperty(i)) continue;
+					
+					//copy formed array and insert
+					var c = id[i].slice();
+					//add key into array
+					c.unshift(i);
+					
+					this.addFlicker.apply(this, c);
+					
+			}
+			
+			return this;
+		}
+		
+		if(typeof frames == 'string') frames = frames.split(' ');
+		
+		//add
+		this.flicker_reels[id] = 
+		{
+			frames:frames,
+			duration:duration,
+			loops:loops
+		};
+		
+		return this;
+	},
+	
+	removeFlicker:function(id){
+		
+		if(typeof id == 'object'){
+			
+			for(var i in id){
+				if(!id.hasOwnProperty(i)) continue;
+				
+				this.removeFlicker.call(this, id[i]);
+			}
+			
+			return this;
+		}
+		
+		//assuming this flicker isn't running
+		delete this.flicker_reels[id];
+		
+		return this;
+	},
+	
+	/*
+	The animate method either creates or plays an animation.
+	Time is in milliseconds.
+	
+	//create sequence animation
+	re('#player').flicker('die', 1, 200, [0, 1, 3, 3, 4, 3, 2, 1]);
+	
+	//play animation
+	//can customize the animation for this call.
+	re('#player').flicker('die', 0, 200);
+	
+	//stop flickering
+	re('#player').flicker();
+	
+	//add multiple animations
+	flicker({
+	idle:[loops, duration, frames],
+	..
+	
+	
+	});
+	
+	FUTURE: 
+	-allow backward animations
+	-allow entry of an array of frames. So each counter will go to the next frame in the array
+	*/
+	flicker:function(id, loops, duration, frames){
+		
+		if(arguments.length == 0){
+			//stop flickering
+			return this.flicker_stop();
+		}
+		
+		if(id == this.flicker_flickering) return;
+		
+		if(!this.flicker_reels[id]){
+			return this;	
+		}
+		
+		//defaults
+		
+		//startX = loops, endX = duration in seconds
+		//if startX equals 0, animation loops forever
+		
+		var r = this.flicker_reels[id];
+		
+		//create new reel based on custom attributes
+		var c = this.flicker_reel;
+		//copy from saved animation or newly given
+		c.loops = (isNaN(loops))? r.loops : loops;
+		c.duration = (isNaN(duration))? r.duration : duration;
+		c.frames = (typeof frames == 'object')? frames : r.frames;
+		
+		//setup counter for loops
+		this.flicker_loops = c.loops;
+		
+		this.stepProgress = 0;
+		this.stepSize = c.duration / c.frames.length;
+		
+		//save old frames for upon completion
+		
+		this.flicker_oldX = this.frameX;
+		this.flicker_oldY = this.frameY;
+		
+		this.flicker_frame = 0;
+		
+		//update frame then run
+		this.flick(c.frames[this.flicker_frame++]);
+		
+		if(!this.flickering()){
+			this.addSignal('update', this.flicker_update);
+		}
+		
+		this.flicker_flickering = id;
+			
+		
+		
+		return this;
+	},
+	
+	/*
+	Check if flicker is running / compare current.
+	
+	this.flickering(); // false
+	this.flickering('idle'); // false
+	*/
+	flickering:function(id){
+		if(id){
+			return this.flicker_flickering == id;	
+		}
+		
+		return this.flicker_flickering != '';	
+	}
+	
+});

data/src/entityjs/pattern/timestep.js

@@ -0,0 +1,34 @@
+/*
+
+
+re.e('timestep')
+.timestep(progress, function(){
+	
+	
+	
+});
+*/
+
+re.c('timestep')
+.inherit({
+	
+	stepProgress:0,
+	stepSize:0.3
+	
+})
+.extend({
+	
+	timestep:function(progress, callback, context){
+		
+		this.stepProgress += progress;
+		
+		while(this.stepProgress >= this.stepSize){
+			
+			callback.call((context)?context:this);
+			
+			this.stepProgress -= this.stepSize;
+		}
+		
+	}
+	
+})

data/src/entityjs/save/database.js

@@ -0,0 +1,7 @@
+/*
+The database component adds functions for creating and dealing with databases.
+This will reference only one database.
+
+Because of the current stance of firefox. I'm not sure if its safe implementing this yet.
+*//*
+re.c('database');*/

data/src/entityjs/save/storage.js

@@ -0,0 +1,57 @@
+/*
+The storage component contains methods for storing locally or session values.
+This utilizes the new HTML5 localstorage and sessionstorage.
+
+//create new local storage
+re.e('storage:local');
+
+//create new session storage
+re.e('storage:session');
+
+*/
+re.c('storage')
+.init(function(c, type){
+	this.storage = (type == 'session')? sessionStorage : localStorage;
+})
+.extend({
+	
+	length:function(){
+		return this.storage.length;
+	},
+	
+	key:function(index){
+		return this.storage.key(index);
+	},
+	
+	getItem:function(key){
+		return this.storage.getItem(key);
+	},
+	
+	getJson:function(key){
+		return JSON.parse(this.getItem(key));
+	},
+	
+	setItem:function(key, data){
+		
+		if(typeof data != 'number' || typeof data != 'string'){
+			data = JSON.stringify(data);
+		}
+		
+		this.storage.setItem(key, data);
+		
+		return this;
+	},
+	
+	removeItem:function(key){
+		this.storage.removeItem(key);
+		
+		return this;
+	},
+	
+	clear:function(){
+		this.storage.clear();
+		
+		return this;
+	}
+	
+})

data/src/entityjs/util/log.js

@@ -0,0 +1,25 @@
+/*
+The log component extends a cross browser console.log command.
+
+//example usage
+re.e('log')
+.log('example log');
+
+//global usage
+re.log('example log');
+
+*/
+re.log = function(){
+	try{
+		console.log.apply(console, arguments);
+	} catch(e){
+		try {
+			opera.postError.apply(opera, arguments);
+		} catch(e){
+			alert(Array.prototype.join.call(arguments, " "));
+		}
+	}
+};
+
+re.c('log')
+.extend('log', re.log);

data/src/entityjs/util/polyfill.js

@@ -0,0 +1,25 @@
+/*
+The polyfill component polyfills unsupported HTML5 functions when possible.
+*/
+re.c('polyfill')
+.extend({
+	
+	requestAnimationFrame:function(callback, canvas){
+		return requestAnimFrame(callback, canvas);
+	}
+	
+})
+.run(function(){
+	
+	//setup requestanimationframe on support
+	window.requestAnimFrame = 
+	window.requestAnimationFrame ||
+	window.webkitRequestAnimationFrame ||
+	window.mozRequestAnimationFrame ||
+	window.oRequestAnimationFrame ||
+	window.msRequestAnimationFrame ||
+	function(callback){
+		window.setTimeout(callback, 1000 / 60);
+	};
+	
+});

data/src/entityjs/util/random.js

@@ -0,0 +1,38 @@
+/*
+The random component implements two helper methods for calculating random numbers.
+
+r = re.e('random');
+
+r.random() // 0 - 1
+r.random(10) // 0 - 9
+r.random(10, 30) // 10 - 30
+
+randomInt rounds numbers to whole
+*/
+re.c('random')
+.extend({
+	
+	random:function(max, min){
+		switch(arguments.length){
+			case 0:
+			return Math.random();
+			case 1:
+			return Math.random() * max;
+			case 2:
+			return Math.random() * (max - min + 1) + min;
+		}
+	},
+	
+	randomInt:function(max, min){
+		return Math.floor(this.random.apply(this, arguments));
+	}
+	
+})
+.run(function(){
+	var b = re.e('random');
+	
+	re.random = b.random;
+	re.randomInt = b.randomInt;
+	
+	b.dispose();
+});

data/src/entityjs/util/scene.js

@@ -0,0 +1,101 @@
+
+/*
+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', {tiles:[]} );
+
+//delete a scene
+re.scene('-home');
+
+//combine delete home goto title sceen
+re.scene('-home title');
+*/
+re.scene = function(title){
+	var s = re.c('scene');
+	
+	//delete scene
+	if(title.charAt(0) == '-'){
+		
+		delete s._scenes[title.substr(1)];
+		
+		return s;
+		
+	} else if(s._scenes[title]){
+	//go to scene
+		
+		var current = arguments.callee.current;
+		
+		//call exit
+		var t = s._scenes[current];
+		if(t && typeof t.scene_exit == 'function'){
+			t.scene_exit.call(t, title);
+		}
+		
+		arguments.callee.current = title;
+		s.curent = title;
+		
+		t = s._scenes[title];
+		
+		if(typeof t.scene_enter == 'function'){
+			t.scene_enter.apply(t, Array.prototype.slice.call(arguments, 1));
+		}
+		
+		
+	} else {
+	
+		//add scene
+		re.e('scene:'+title);
+	}
+	
+	return s._scenes[title];
+};
+
+re.c('scene')
+.global({
+	
+	_scenes:{}
+	
+})
+.init(function(c, title){
+	
+	c._scenes[title] = this;
+	this.sceneName = title;
+	
+})
+.dispose(function(c){
+	
+	delete c._scenes[this.sceneName];
+	
+})
+.extend({
+	
+	enter:function(m){
+		this.scene_enter = m;
+		
+		return this;
+	},
+	
+	exit:function(m){
+		this.scene_exit = m;
+		
+		return this;
+	},
+	
+	scene:function(){
+		return re.scene.apply(this, arguments);
+	}
+});

data/src/entityjs/util/sheet.js

@@ -0,0 +1,51 @@
+/*
+The sheet component converts a each frame of a sprite sheet into their own components.
+*/
+re.c('sheet')
+.global({
+	
+	sheet:function(map, padX, padY, sizeX, sizeY){
+		
+		var frameWidth = sizeX || re.tile.sizeX;
+		var frameHeight = sizeY || re.tile.sizeY;
+		
+		if(padX){
+			frameWidth += padX;
+		}
+		
+		if(padY){
+			frameHeight += padY;	
+		}
+		
+		//create new sprites for sheet
+		
+		//save frame positions from map
+		var x;
+		var y;
+		
+		for(var p in map){
+			x = map[p][0] || 0;
+			y = map[p][1] || 0;
+			
+			re.c(p)
+			.require('sprite')
+			.extend({
+				frame:{x:x, y:y},
+				size:{x:frameWidth, y:frameHeight},
+				bitmap:this.bitmap
+			});
+			
+		}
+		
+		return this;
+	}
+	
+})
+.require('tile')
+.extend({
+	
+	sheet:re.sheet
+	
+});
+
+re.sheet = re.c('sheet').sheet;