entityjs 0.4.1 → 0.4.2

data/src/core/entity.js

@@ -11,9 +11,14 @@
     });
     
     */
-    var q = function(c, count){
+    var q = function(c, count, alone){
         if(!count){
-          return new re.entity.init(c);
+            var r = new re.entity.init(c);
+            
+            if(!alone){
+                re._e.push(r);
+            }
+          return r;
         }
         
         //optimize for multiple calls
@@ -21,42 +26,32 @@
         
         //create entity by number of count
         for(var i=0; i<count; i++){
-            q.push(re.e(c));
+            q.push(re.e(c, 0, alone));
         }
         
         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._re_listens = {};
         
         this.comp(c);
     };
     
     var p = e.prototype;
     
-    p.id = '';
-    
     p.comp = function(com){
         
         this._re_comp(com);
         
         //check implement
-        if(this._re_implements){
+        if(this._re_interfaces){
             
-            for(var i in this._re_implements){
-                if(!this.hasOwnProperty(this._re_implements[i])){
-                    throw 'Interface: '+this._re_implements[i]+' missing';
+            for(var i in this._re_interfaces){
+                if(!this.hasOwnProperty(this._re_interfaces[i])){
+                    throw 'Interface: '+this._re_interfaces[i]+' missing';
                 }
             }
             
@@ -155,16 +150,17 @@
         //component reference
         var c;
         
+        //will be sent to init function
         var vals = com.split(':');
         
         com = vals[0];
         
+        //remove comp string
+        vals.shift();
+
         //add component
         c = re._c[com];
-        
-        //swap values
-        vals[0] = c;
-        
+
         //if already has component
         if(!this.has(com)){
         
@@ -177,11 +173,11 @@
             this._re_comp(c._re_requires);
             
             //add interface of component
-            if(c._re_implements){
-                if(!this._re_implements){
-                    this._re_implements = [];
+            if(c._re_interfaces){
+                if(!this._re_interfaces){
+                    this._re_interfaces = [];
                 }
-                this._re_implements = this._re_implements.concat(c._re_implements);
+                this._re_interfaces = this._re_interfaces.concat(c._re_interfaces);
             }
             
             if(c._re_asserts){
@@ -191,8 +187,8 @@
                 this._re_asserts = this._re_asserts.concat(c._re_asserts);
             }
             
-            if(c._re_inherits){
-                this.def(c._re_inherits);
+            if(c._re_defaults){
+                this.def(c._re_defaults);
             }
             
             if(c._re_defines){
@@ -223,8 +219,8 @@
         return this._re_comps.slice();
     }
     
-    p.clone = function(count){
-        return re.e(this._re_comps, count);
+    p.clone = function(count, a){
+        return re.e(this._re_comps, count, a);
     }
     
     /*
@@ -251,7 +247,7 @@
             return c._re_defines[method].apply(this, a);
         }
         
-        return c._re_inherits[method].apply(this, a);
+        return c._re_defaults[method].apply(this, a);
     }
     
     /*
@@ -306,7 +302,7 @@
         //check if entity contains signals
         for(p=0; p<comp.on.length; p++){
             s = comp.on[p];
-            if(!this._re_signals[s] || this._re_signals[s].length == 0){
+            if(!this._re_listens[s] || this._re_listens[s].length == 0){
                 return false;
             }
         }
@@ -343,12 +339,12 @@
             
         } else {
             
-            if(!this._re_signals[type]){
-                this._re_signals[type] = [];
+            if(!this._re_listens[type]){
+                this._re_listens[type] = [];
             }
             if(!re.is(method)) throw 'Method is null'
             //save context
-            this._re_signals[type].push({c:context || this, f:method});
+            this._re_listens[type].push({c:context || this, f:method});
             
         }
         
@@ -385,7 +381,7 @@
         } else {
             
             if(method){
-               var i = this._re_signals[type];
+               var i = this._re_listens[type];
                 for(var k in i){
                 
                     if(i[k].f == method){
@@ -396,11 +392,11 @@
             } else if(type){
                 
                 //no method was passed. Remove all signals
-                this._re_signals[type] = [];
+                this._re_listens[type] = [];
                 
             } else {
                 //remove all signals
-                this._re_signals = {};
+                this._re_listens = {};
             }
         }
         
@@ -417,12 +413,12 @@
     */
     p.trigger = function(type){
         
-        if(!this._re_signals[type])    return this;
+        if(!this._re_listens[type])    return this;
         var b;
         
-        for(var i=0, l = this._re_signals[type].length; i<l; i++){
+        for(var i=0, l = this._re_listens[type].length; i<l; i++){
             
-            b = this._re_signals[type];
+            b = this._re_listens[type];
             
             if(!b) break;
             if(!b[i]) continue;
@@ -465,8 +461,7 @@
     };
 
     p.get = function(v){
-        var l = this[v];
-        return (re.is(l,'function'))? l() : l;
+        return (re.is(this[v], 'function'))? this[v]() : this[v];
     };
 
     p.def = function(obj, value){

data/src/core/load.js

@@ -131,13 +131,10 @@
         //create new image component
         re.c(a)
         .alias(n+re.load.imageExt)
-        .statics({
-            image:img
-        })
         .defines({
             //save image for other components to copy or use
             _image:img
-        });
+        }).image = img;
         
         img.onload = function(){
           re.c(a).defines({
@@ -236,12 +233,9 @@
       re.c(a)
       //create statics codec for easy use
       .alias(n+re.load.soundExt)
-      .statics({
-          sound:s
-      })
       .defines({
           _sound:s
-      });
+      }).sound = s;
     }
     
     p.progress = function(m){

data/src/core/query.js

@@ -63,6 +63,7 @@
     Sort a query string into objects
     */
     q._toObj = function(query){
+        //check if its caught
         if(q.c[query]){
             return q.c[query];
         }
@@ -99,6 +100,7 @@
             id:id
         };    
         
+        //catch it
         q.c[query] = comp;
         
         return comp;
@@ -168,7 +170,7 @@
       while(++i < l && (e = this[i]) != null && m.call(context || this, e, i, this) !== false);
         
       return this;
-    }
+    };
     
     /*
     The map method allows multidimensional loops.
@@ -371,23 +373,33 @@
       return re(Array.prototype.filter.apply(this, arguments));
     }
     
+    //Removes all elements in the array that pass the truth test
+    p.reject = function(it, c){
+        for(var i=0; i<this.length; i++){
+            if(it.call(c || this, this[i], i, this)){
+                this.splice(i, 1);
+            }
+        }
+        return this;
+    };
+
     /*
     Finds first entity with components
     
     re('draw').findWith('circle !red');
     
     */
-    p.findWith = function(comps, c){
+    p.findWith = function(comps){
       return this.find(function(e){
         return e.has(comps);
-      }, c);
+      });
     }
     
     /*
     Creates a new entity and pushes it into the array.
     */
-    p.e = function(comps, count){
-      var e = re.e(comps, count);
+    p.e = function(comps, count, alone){
+      var e = re.e(comps, count, alone);
       if(count){
         //add all in query
         for(var i in e){

data/src/core/re.js

@@ -11,7 +11,7 @@ re = function(selector){
 };
 
 //automatically filled when compiled
-re.version = "$VERSION";
+re.version = "RE_VERSION";
     
 //contains all entities
 re._e = [];

data/src/core/system.js

@@ -88,14 +88,14 @@ re.c('system')
         this.sizeY = s.sizeY = this.canvas.height;
         
         //init listeners
-        if(re._c.keyboard){
-          re._c.keyboard.i();
+        if(re.keyboard){
+          re.keyboard.i();
         }
-        if(re._c.mouse){
-          re._c.mouse.i();
+        if(re.mouse){
+          re.mouse.i();
         }
-        if(re._c.touch){
-          re._c.touch.i();
+        if(re.touch){
+          re.touch.i();
         }
         this.system_loop = this.defaultLoop;
         this.second = this.stepSize * 30;
@@ -119,7 +119,7 @@ re.c('system')
     },
     
     update:function(){
-      re._c.update.update(this.stepSize);
+      re.update.update(this.stepSize);
     },
     
     draw:function(){
@@ -129,9 +129,6 @@ re.c('system')
     
     
 })
-.run(function(){
     
     //create default system
-    re.system = re.sys = re.e('system');
-    
-});
+    re.system = re.sys = re.e('system');

data/src/cycle/drawlist.js

@@ -10,20 +10,20 @@ For example:
 In a case of an isometric game, certain tiles should appear behind or in
 
 */
-re.drawlist = function(name){
-  var d = re.c('drawlist'), name = name || '';
+
+re.c('drawlist')
+.method(function(name){
+  var name = name || '';
   
   //name default to '' and returns default drawlist
   
-  if(!d._lists[name]){
+  if(!re.drawlist._lists[name]){
     //add new list
     re.e('drawlist:'+name);
   }
   
-  return d._lists[name];
-};
-
-re.c('drawlist')
+  return re.drawlist._lists[name];
+})
 .statics({
   _lists:{}
 })
@@ -69,11 +69,11 @@ re.c('drawlist')
   }
   
 })
-.init(function(c, name){
-  c._lists[name] = this;
+.init(function(name){
+  re.drawlist._lists[name] = this;
   this.listName = name;
   this.list = re();
 })
-.dispose(function(c){
-  delete c._lists[this.listName];
+.dispose(function(){
+  delete re.drawlist._lists[this.listName];
 });

data/src/cycle/update.js

@@ -23,7 +23,7 @@ re.c('update')
 })
 .defines(function(){
 	
-	var l = re.c('update').l;
+	var l = re.update.l;
 	
 	return {
   
@@ -78,10 +78,10 @@ re.c('update')
 	};
 	
 }())
-.init(function(c){
-	c.l.push(this);
+.init(function(){
+	re.update.l.push(this);
 })
-.dispose(function(c){
+.dispose(function(){
 	
-	c.l.splice(c.l.indexOf(this), 1);
+	re.update.l.splice(re.update.l.indexOf(this), 1);
 });

data/src/display/align.js

@@ -5,13 +5,20 @@ The align component contains helper methods for positioning entities relative to
 
 */
 re.c('align')
-.requires('draw')
+.defaults({
+    regX:0,
+    regY:0,
+    sizeX:1,
+    sizeY:1,
+    posX:0,
+    posY:0
+})
 .defines({
     
-  align:function(x, y){
+    align:function(x, y){
     this.alignHor(x);
     return this.alignVer(y);
-  },
+    },
   
     alignHor:function(o){
         o = o || 0;

data/src/display/animate.js

@@ -5,7 +5,7 @@ The animate comp defines a simple interface for animating sprites.
 var apple = re.e('apple.png animate sprite');
 
 //setup animations to play
-apple.anis = {
+apple.animates = {
 			//time, frames, loops
 	explode:[1000, [0, 1, 2], 1]
 		  //seconds, frames, loops defaults to once
@@ -25,26 +25,40 @@ apple.flickering(); //this comes from flicker comp
 re.c('animate')
 .requires('flicker')
 .defines({
-  	
-	animate:function(name){
-		//ignore if calling the same frame
+  
+  //overload flickers method
+	flicker_stop:function(){
+		this._super('flicker', 'flicker_stop');
+		if(this.animate_finish) this.animate_finish();
+	},
+
+	animate:function(name, onFinish, onUpdate){
+		//ignore if calling the same animation
 		if(this.flickering() != name){
-			
-			var a = this.anis[name] || [];
+
+    	this.animate_finish = onFinish;
+    	this.animate_update = onUpdate;
+    	
+			var a = this.animates[name];
 			//flicker interface
 			//(duration:int, frames:array, loops:int, id:string)
 			this.flicker(a[0], a[1], a[2], name);
 
 			//only run if a is defined
-			if(a.length)
-			this.flicker_run(); //run first frame
+			if(a.push)
+				this.flicker_run(); //run first frame
 		}
 		return this;
 	},
 
-    //implement for flicker
-    flick:function(c){
-        this.frame(c);
-    }
+	animating:function(t){
+		return this.flickering(t);
+	},
+
+  //implement for flicker
+  flick:function(c){
+      this.frame(c);
+      if(this.animate_update)  this.animate_update.apply(this, arguments);
+  }
   
 });