entityjs 0.2.2

data/src/entityjs/core/entity.js

@@ -0,0 +1,516 @@
+(function(re){
+	
+	/*
+	Main function for re.e
+	
+	//create multiple entities
+	re.e('spider', 10)
+	//returns a query with all entities
+	.each(function(index){
+		this.posX = index * 10;
+	});
+	
+	*/
+	var q = function(c, count){
+		if(!count){
+			return new re.entity.init(c);
+		}
+		
+		//optimize for multiple calls
+		var q = re();
+		
+		//create entity by number of count
+		for(var i=0; i<count; i++){
+			q._e.push(re.e(c));
+		}
+		
+		return q;
+	};
+	
+	q.id = 0;
+	
+	var e = function(c){
+		
+		this._re_comps = [];
+		this._re_signals = {};
+		
+		this.id = q.id+'';
+		
+		q.id++;
+		
+		re._e.push(this);
+		
+		this.addComp(c);
+	};
+	
+	var p = e.prototype;
+	
+	p.id = '';
+	
+	p.addComp = function(com){
+		
+		this._re_comp(com);
+		
+		//check implement
+		if(this._re_interface){
+			
+			for(var i in this._re_interface){
+				if(!this.hasOwnProperty(this._re_interface[i])){
+					throw 'implementation: '+this._re_interface[i]+' missing';
+				}
+			}
+			
+		}
+		
+		//check asserts
+		if(this._re_asserts){
+			for(var t in this._re_asserts){
+				if(this._re_comps.indexOf(c._re_asserts[t]) != -1){
+					throw 'assert: '+c.name+' cannot be coupled with '+c._re_asserts[t];
+				}
+			}
+		}
+		
+		return this;
+	};
+	
+	p.removeComp = function(com){
+		
+		var pieces;
+		
+		//handle string or array?
+		if(typeof com == 'object'){
+			pieces = com;
+			
+			com = com[0];
+		} else {
+			pieces = com.split(' ');
+		}
+		
+		if(pieces.length > 1){
+			
+			for(var k in pieces){
+				this._re_comp(pieces[k]);	
+			}
+			
+			return this;
+		}
+		
+		var c = re._c[com];
+		
+		if(!this.has(com)) return this;
+		
+		//remove from array
+		this._re_comps.splice(this._re_comps.indexOf(com), 1);
+		
+		//only remove if it exists
+		if(c){
+			
+			if(c._re_dispose){
+				c._re_dispose.call(this, c);
+			}
+			
+			c.signal('dispose', this);
+			
+		}
+	};
+	
+	/*
+	//add components
+	this.comp('point text');
+	
+	//add health component with 100 health
+	this.comp('health:100 physics');
+	
+	//remove components
+	this.comp('-point');
+	*/
+	/*p.comp = function(com){
+		
+		this._re_comp(com);
+		
+		//check implement
+		if(this._re_interface){
+			
+			for(var i in this._re_interface){
+				if(!this.hasOwnProperty(this._re_interface[i])){
+					throw 'implementation: '+this._re_interface[i]+' missing';
+				}
+			}
+			
+		}
+		
+		//check asserts
+		if(this._re_asserts){
+			for(var t in this._re_asserts){
+				if(this._re_comps.indexOf(c._re_asserts[t]) != -1){
+					throw 'assert: '+c.name+' cannot be coupled with '+c._re_asserts[t];
+				}
+			}
+		}
+		
+		return this;
+	}*/
+	
+	p._re_comp = function(com){
+		if(!com) return this;
+		
+		//split a multi word string into smaller one word function calls
+		var pieces;
+		
+		//handle array or string?
+		if(typeof com == 'object'){
+			pieces = com;
+			//set in case length is 1
+			com = com[0];
+		} else {
+			pieces = com.split(' ');
+		}
+		
+		if(pieces.length > 1){
+			for(var k in pieces){
+				this._re_comp(pieces[k]);	
+			}
+			
+			return this;
+		}
+		
+		//component reference
+		var c;
+		
+		var vals = com.split(':');
+		
+		com = vals[0];
+		
+		//add component
+		c = re._c[com];
+		
+		//swap values
+		vals[0] = c;
+		
+		//if already has component
+		if(this.has(com)) return this;
+		
+		//add comp first thing, to avoid dupe requirement calls
+		//and this lets the init remove the comp too.
+		this._re_comps.push(com);
+		
+		//init component only if it exists
+		if(c){
+			this._re_comp(c._re_requires);
+			
+			//add interface of component
+			if(c._re_implements){
+				if(!this._re_implements){
+					this._re_implements = [];
+				}
+				this._re_implements = this._re_implements.concat(c._re_implements);
+			}
+			
+			if(c._re_asserts){
+				if(!this._re_asserts){
+					this._re_asserts = [];
+				}
+				this._re_asserts = this._re_asserts.concat(c._re_asserts);
+			}
+			
+			if(c._re_inherits){
+				this.inherit(c._re_inherits);
+			}
+			
+			if(c._re_extends){
+				this.extend(c._re_extends);
+			}
+			
+			if(c._re_init){
+				c._re_init.apply(this, vals);
+			}
+			
+			c.signal('init', this);
+		}
+		
+		
+		
+	
+		return this;
+	}
+	
+	/*
+	Returns component array
+	*/
+	p.getComps = function(){
+		return this._re_comps.slice();
+	}
+	
+	p.clone = function(count){
+		return re.e(this._re_comps, count);
+	}
+	
+	/*
+	Calls methods of parent components.
+	
+	Use '' to call entities components when overriding
+	*/
+	p.parent = function(comp, method){
+		
+		var a = Array.prototype.slice.call(arguments, 2);
+		
+		if(comp == ''){
+			//call entity parent methods
+			re.e.init[method].apply(this, a);
+		}
+		
+		var c = re._c[comp];
+		
+		if(c._re_extends[method]){
+			return c._re_extends[method].apply(this, a);
+		}
+		
+		if(c._re_inherits[method]){
+			return c._re_inherits[method].apply(this, a);
+		}
+		
+		return this;
+	}
+	
+	/*
+	TODO extend has to multiple item query
+	
+	//returns true if both present
+	this.has('draw update');
+	
+	//return true if bitmap not present but has update
+	this.has('update -bitmap');
+	
+	//returns true if has asset id and update signal
+	this.has('#asset ^update');
+	
+	//expanded
+	this.has({
+		'comp':['draw'],
+		'id':'bob',
+		'signal':['draw'],
+		'not':['update']
+	});
+	*/
+	p.has = function(comp){
+		
+		if(typeof comp == 'string'){
+			
+			comp = re.query._toObj(comp);
+		}
+		
+		comp.comp = comp.comp || [];
+		comp.id = comp.id || '';
+		comp.signal = comp.signal || [];
+		comp.not = comp.not || [];
+			
+		//check if entitiy contains the correct components
+		for(p=0; p<comp.comp.length; p++){
+			
+			//check if not containing components
+			if(this._re_comps.indexOf(comp.comp[p]) == -1){
+				return false;
+			}
+		}
+		
+		//check if entity doesn't contain components
+		for(p=0; p<comp.not.length; p++){
+			if(this._re_comps.indexOf(comp.not[p]) != -1){
+				return false;
+			}
+		}
+		
+		var s;
+		//check if entity contains signals
+		for(p=0; p<comp.signal.length; p++){
+			s = comp.signal[p];
+			if(!this._re_signals[s] || this._re_signals[s].length == 0){
+				return false;
+			}
+		}
+		
+		if(comp.id != '' && this.id != comp.id){
+			return false;
+		}
+		
+		
+		return true;
+	};
+	
+	/*
+	New way to add signals version 0.2.1.
+	
+	//single
+	addSignal('draw', function(){});
+	
+	//multiple
+	addSignal({
+		
+		draw:function(){},
+		
+		update:function(){}
+		
+	});
+	*/
+	p.addSignal = function(type, method){
+		
+		if(typeof type == 'object'){
+			
+			for(var k in type){
+				this.addSignal(k, type[k]);
+			}
+			
+		} else {
+			
+			if(!this._re_signals[type]){
+				this._re_signals[type] = [];
+			}
+			
+			this._re_signals[type].push(method);
+			
+		}
+		
+		return this;
+	};
+	
+	/*
+	Added in V0.2.1
+	
+	//remove single
+	removeSignal('draw', this.draw);
+	
+	//remove multiple
+	removeSignal({
+		
+		draw:this.draw,
+		update:this.update
+		
+	});
+	*/
+	p.removeSignal = function(type, method){
+		
+		if(typeof type == 'object'){
+			
+			for(var k in type){
+				this.removeSignal(k, type[k]);
+			}
+			
+		} else {
+			
+			if(typeof method == 'function'){
+			
+				for(var k in this._re_signals[type]){
+				
+					if(this._re_signals[type][k] == method){
+						this._re_signals[type].splice(k, 1);
+					}
+					
+				}
+			} else {
+				
+				//no method was passed. Remove all signals
+				this._re_signals[type] = [];
+				
+			}
+		}
+		
+		return this;
+	};
+	
+	/*
+	Signal dispatches events to entities. 
+	Modified V0.2.1
+	
+	
+	-dispatch signals
+	this.signal('click');
+	this.signal('click draw');
+	this.signal('click', {data:0});
+	
+	*/
+	p.signal = function(type){
+		
+		if(!this._re_signals[type])	return this;
+		var b;
+		
+		for(var i=0, l = this._re_signals[type].length; i<l; i++){
+			
+			b = this._re_signals[type];
+			
+			if(!b[i]) continue;
+			
+			//return false remove?
+			if(b[i].apply( (b[i].c)?b[i].c : this , Array.prototype.slice.call(arguments, 1)) === false){
+				b.splice(i, 1);
+			}
+			
+		}
+		
+		return this;
+	};
+	
+	p.extend = function(obj, value){
+		var a = typeof obj;
+		if(a == 'object'){
+			
+			for(var key in obj){
+				if(!obj.hasOwnProperty(key)) continue;
+				
+				this.extend(key, obj[key]);
+			}
+			
+		}else {
+			//extend property
+			
+			this[obj] = value;
+		}
+		
+		return this;
+	}
+	
+	p.inherit = function(obj, value){
+		
+		if(typeof obj == 'object'){
+		
+			for(var key in obj){
+				if(!obj.hasOwnProperty(key)) continue;
+				
+				this.inherit(key, obj[key]);
+				
+			}
+			
+		} else {
+			//extend property
+			
+			if(!this.hasOwnProperty(obj) || typeof this[obj] != typeof value){
+				
+				this[obj] = value;	
+				
+			}
+		}
+		
+		return this;
+	}
+	
+	p.dispose = function(){
+		//delete from global array
+		re._e.splice(re._e.indexOf(this), 1);
+		
+		for(var i in this._re_comps){
+			var k = re.c(this._re_comps[i]);
+			if(k._re_dispose){
+				k._re_dispose.call(this, k);
+			}
+			k.signal('dispose', this);
+		}
+		
+		this.signal('dispose');
+		
+		return this;
+	}
+	
+	re.entity = re.e = q;
+	re.entity.init = e;
+	
+}(re));

data/src/entityjs/core/load.js

@@ -0,0 +1,224 @@
+(function(re){
+	
+	var b = function(assets){
+		return new re.load.init(assets);	
+	}
+	
+	b.path = "";
+	
+	b.imageExt = 'img';
+	b.soundExt = 'sfx';
+	b.images = ['gif', 'jpg', 'jpeg', 'png'];
+	b.sounds = ['wav', 'mp3', 'aac', 'ogg'];
+	
+	/*
+	Loads images, sounds and other files into components.
+	
+	All loaded assets will be put into a component with a ref to the asset.
+	
+	//example of loading assets
+	re.load('tiles.png add.js attack.mp3')
+	.complete(function(arrayOfAssets){
+		//create new bitmap of tiles.png
+		re.e('bitmap tiles.png');
+		
+		//new sound
+		re.e('sound attack.mp3');
+		
+		//access image staticaly or localy
+		re.comp('tiles.png').image;
+		re.entity('tiles.png').image;
+		
+	})
+	.error(function(assetThatCausedError){
+		//error
+	})
+	.progress(function(current, total, assetLoaded){
+		//called on loads
+	});
+	
+	@warning only supports loading images and sounds
+	
+	//load sound
+	
+	//re.support will return the supported codec
+	re.load('run.'+re.support('ogg', 'aac'));
+	
+	FUTURE remove directories from calls
+	
+	*/
+	var l = function(assets){
+		
+		if(typeof assets == 'string'){
+			this.assets = assets.split(' ');
+		} else {
+			this.assets = assets;
+		}
+		
+		var a;
+		for(var i=0; i<this.assets.length; i++){
+			
+			this.total++;
+			
+			a = this.assets[i];
+			
+			//find file extension
+			var j = a.lastIndexOf('.')+1;
+			var ext = a.substr(j).toLowerCase();
+			
+			//copy full source path
+			var s = a;
+			
+			//remove directories
+			var d = a.lastIndexOf('/');
+			if(d != -1){
+				a = a.substr(d+1, a.length);
+			}
+			
+			//find name
+			var n = a.substr(0, j);
+			
+			if(re.load.images.indexOf(ext) != -1){
+
+				this._loadImg(s, a, n);
+				
+			} else if(re.load.sounds.indexOf(ext) != -1){
+				
+				//check if support component exists first
+				if(!re.support || re.support(ext)){
+					this._loadSound(s, a, n);
+				}
+				
+			}
+			
+			
+		}
+		
+		return this;
+	}
+	
+	var p = l.prototype;
+	
+	p.current = 0;
+	p.total = 0;
+	
+	p._loadImg = function(src, a, n){
+	
+		var that = this;
+		var img = new Image();
+		
+		//create new image component
+		re.c(a)
+		.alias(n+re.load.imgExt)
+		.global({
+			bitmap:img
+		})
+		.extend({
+			//save image for other components to copy or use
+			bitmap:img
+		});
+		
+		img.onload = function(){
+		
+			re.c(a).extend({
+			
+			bisect:img.width,
+			sizeX:img.width,
+			sizeY:img.height
+			});
+			
+			that.current++;
+			
+			if(that._p){
+				that._p.call(that, that.current, that.total, a);
+			}
+			
+			if(that.current >= that.total){
+			
+				if(that._s){
+					that._s.call(that, that.assets);
+				}
+				
+			}
+		};
+		
+		img.onerror = function(){
+			
+			if(that._e){
+				that._e.call(that, a);
+			}
+			
+		};
+		
+		img.src = re.load.path+src;
+		
+		return this;
+	}
+	
+	p._loadSound = function(src, a, n){
+		var that = this;
+		
+		var s = new Audio(re.load.path+src);
+		s.preload = "auto";
+		s.load();
+		
+		re.c(a)
+		//create global codec for easy use
+		.alias(n+re.load.soundExt)
+		.global({
+			sound:s
+		})
+		.extend({
+			sound:s
+		});
+		
+		s.addEventListener('canplaythrough',function(){
+			that.current++;
+			
+			if(that._p){
+				that._p.call(that, that.current, that.total, a);
+			}
+			
+			if(that.current >= that.total){
+				if(that._s){
+					that._s.call(that, that.assets);
+				}
+				
+			}
+			
+		},false);
+		
+		s.addEventListener('error',function(){
+			
+			if(that._e){
+				that._e.call(that, a);
+			}
+		},false);
+		
+	}
+	
+	p.progress = function(m){
+		
+		this._p = m;
+		
+		return this;
+	}
+	
+	p.complete = function(m){
+		
+		this._s = m;
+		
+		return this;
+	}
+	
+	p.error = function(m){
+		
+		this._e = m;
+		
+		return this;
+	}
+	
+	re.load = b;
+	re.load.init = l;
+	
+}(re));