entityjs 0.3.2 → 0.4.0

data/src/core/load.js

@@ -140,12 +140,12 @@
         });
         
         img.onload = function(){
-          re.c(a).defaults({
+          re.c(a).defines({
             sizeX:img.width,
-            sizeY:img.height
-            })
-            .defines('bisect', img.width);
-            
+            sizeY:img.height,
+            bisect:img.width
+          });
+          
           that._loaded();
         };
         

data/src/core/query.js

@@ -29,7 +29,7 @@
     //takes values from all objects and returns an array
     .pluck('width height');
     
-    //find all bitmap entities with update bind.
+    //find all bitmap entities with update event.
     re('bitmap ^update');
     
     //add color comp to all text components
@@ -49,8 +49,7 @@
     //calls reset method on all entities
     .method('reset');
     
-    //returns direct reference to first entity with id of player
-    re('#player').health = 100;
+    re('#player')[0].health = 100;
     
     */
     var q = function(selector){
@@ -135,6 +134,8 @@
                if(select.call(e, i, l)) this.push(e);
             }
             
+        } else if(re.is(select, 'array')){
+          this.push.apply(this, select);
         }
         
         return this;
@@ -143,13 +144,12 @@
     /*
     Calls the given method name on all entities.
     
-    re('enemies').method('rest');
+    re('enemies').invoke('rest');
     */
-    p.method = function(m){
+    p.invoke = function(m){
         var b = Array.prototype.slice.call(arguments, 1);
-        return this.each(function(){
-        
-            this[m].apply(this, b);
+        return this.each(function(e){
+            e[m].apply(e, b);
         });
         
     }
@@ -162,10 +162,10 @@
     
     returning false will break the loop
     */
-    p.each = function(m){
-        var l = this.length, i = -1, e;
-        
-        while(++i < l && (e = this[i]) && m.call(e, i, l) !== false);
+    p.each = function(m, context){
+      var l = this.length, i = -1, e;
+      
+      while(++i < l && (e = this[i]) != null && m.call(context || this, e, i, this) !== false);
         
       return this;
     }
@@ -175,9 +175,9 @@
     
     //map through and increase y every 3 entities.
     
-    re('draw').tilemap(3, function(x, y){
-        this.x(x * width);
-        this.y(Y * height);
+    re('draw').tilemap(3, function(e, x, y){
+        e.x(x * width);
+        e.y(Y * height);
     });
     
     //so instead of getting this back
@@ -194,13 +194,13 @@
     returning false will break the loop
     
     */
-    p.tilemap = function(w, method){
+    p.tilemap = function(w, method, context){
         var x = 0;
         var y = 0;
         
         return this.each(function(i, l){
             
-            if(method.call(this[i], x, y, i, l) == false) return false;
+            if(method.call(context, this[i], x, y, i, this) == false) return false;
             
             x++;
             
@@ -217,8 +217,8 @@
     p.comps = function(){
         var l = [];
         
-        this.each(function(){
-          var k = this.comps();
+        this.each(function(e){
+          var k = e.comps();
           for(var i=0; i<k.length; i++){
             if(l.indexOf(k[i]) == -1){
               l.push(k[i])
@@ -233,7 +233,48 @@
     Returns a random entity.
     */
     p.random = function(){
-        return this[~~(Math.random()*this.length)];
+        return this[(Math.random()*this.length)|0];
+    }
+    
+    p.attr = function(obj, value){
+      return this.invoke('attr', obj, value);
+        
+    }
+    
+    p.def = function(obj, value){
+      return this.invoke('def', obj, value);
+    }
+    
+    p.comp = function(c){
+      return this.invoke('comp', c);
+        
+    }
+    
+    p.removeComp = function(c){
+      return this.invoke('removeComp', c);
+    }
+    
+    p.on = function(type, method){
+        return this.invoke('on', type, method);
+    }
+    
+    p.off = function(type, method){
+      return this.invoke('off', type, method);
+    }
+    
+    p.trigger = function(){
+        var p = arguments;
+        return this.each(function(e){
+            e.trigger.apply(e, p);
+        });
+    }
+    
+    p.has = function(comp){
+      //return false if empty
+      if(!this.length) return false;
+        return this.every(function(e){
+          return e.has(comp);
+        });
     }
     
     /*
@@ -255,13 +296,12 @@
         
         var k = value.split(' ');
         
-        this.each(function(){
+        this.each(function(e){
             var o = {};
             
             for(var p in k){
-                if(k.hasOwnProperty(p)){
-                    o[k[p]] = this[k[p]];
-                }
+              var name = k[p];
+              o[name] = e[name];
             }
             
             t.push(o);
@@ -271,84 +311,184 @@
         return t;
     }
     
-    p.defines = function(){
-      throw 'Deprecated use attr'
+    p.isEmpty = function(){
+      return !this.length;
     }
     
-    p.attr = function(obj, value){
-        return this.each(function(){
-            this.attr(obj,value);
-        });
+    /*
+    Returns the first entity that passes the truth iterator method.
+    
+    re('tile').find(function(e){
+      return e.tileX() == 0 && e.tileY() == 1;
+    });
+    
+    */
+    p.find = function(method, context){
+      for(var i=0, l=this.length; i<l; i++){
+        if(method.call(context || this, this[i], i, this)) return this[i];
+      }
+      
+      return null;
+    }
+    
+    /*
+    Returns the lowest entity from the given iterator.
+    
+    var weakestRat = re('rat').min(function(e){
+      return e.health;
+    });
+    
+    */
+    p.min = function(method, context){
+      var lowest = Infinity, val;
+      this.each(function(e, i, l){
+        var next = method.call(context || this, e, i, l);
+        if(next < lowest){
+          lowest = next;
+          val = e;
+        }
         
+      });
+      
+      return val;
     }
     
-    p.defaults = function(){
-      throw 'Deprecated use def'
+    p.max = function(method, context){
+      var lowest = -Infinity, val;
+      this.each(function(e, i, l){
+        var next = method.call(context || this, e, i, l);
+        if(next > lowest){
+          lowest = next;
+          val = e;
+        }
+      });
+      
+      return val;
     }
     
-    p.def = function(obj, value){
-        return this.each(function(){
-            this.def(obj, value);
-        });
-        
+    //without this filter would return a normal array.
+    p.filter = function(){
+      return re(Array.prototype.filter.apply(this, arguments));
     }
     
-    p.comp = function(c){
-        
-        return this.each(function(ref){
-            this.comp(c);
-        });
-        
+    /*
+    Finds first entity with components
+    
+    re('draw').findWith('circle !red');
+    
+    */
+    p.findWith = function(comps, c){
+      return this.find(function(e){
+        return e.has(comps);
+      }, c);
     }
     
-    p.removeComp = function(c){
-        return this.each(function(ref){
-          this.removeComp(c);
-        });
+    /*
+    Creates a new entity and pushes it into the array.
+    */
+    p.e = function(comps, count){
+      var e = re.e(comps, count);
+      if(count){
+        //add all in query
+        for(var i in e){
+          this.push(e[i]);
+        }
+      } else {
+        this.push(e);
+      }
+      
+      return this;
     }
     
-    p.on = function(type, method){
-        
-        return this.each(function(){
-            this.on(type,method);
-        });
-        
+    p.include = function(ref){
+      return this.indexOf(ref) != -1;
     }
     
-    p.off = function(type, method){
-        return this.each(function(){
-            this.off(type, method);
-        });
+    /*
+    Removes first reference found from array.
+    
+    var blah = re.e();
+    
+    var q = re()
+    q.push(blah);
+    
+    q.erase(blah);
+    
+    q.include(blah) //false
+    
+    Can also add in other in its place.
+    
+    q.erase(blah, re.e());
+    
+    */
+    p.erase = function(ref){
+      for(var i=this.length; i--;){
+        if(this[i] == ref) this.splice(i, 1);
+      }
+      return this;
     }
     
-        p.trigger = function(){
-            var p = arguments;
-            return this.each(function(){
-                this.trigger.apply(this, p);
-            });
-        }
+    /*
+    Inserts an element after the other.
+    */
+    p.insertAfter = function(target, ref){
+      this.splice(this.indexOf(target)+1, 0, ref);
+      return this;
+    }
     
-    p.has = function(comp){
-        
-        for(var i=0; i<this.length; i++){
-            if(!this[i].has(comp)){
-                return false;
-            }
-        }
-        
-        return this.length != 0;
+    /*
+    Inserts an element before the other.
+    */
+    p.insertBefore = function(target, ref){
+      this.splice(this.indexOf(target), 0, ref);
+      return this;
+    }
+    
+    /*
+    Swaps the indexes of the given elements.
+    */
+    p.swap = function(ref1, ref2){
+      var ref1i = this.indexOf(ref1);
+      var ref2i = this.indexOf(ref2);
+      
+      var t = this[ref1i];
+      this[ref1i] = ref2;
+      this[ref2i] = t;
+      
+      return this;
     }
     
     p.dispose = function(){
         
-        return this.each(function(){
+        return this.each(function(e){
             
-            this.dispose();
+            e.dispose();
             
         });
         
     }
     
+    /*
+    returns first element or appends it to front
+    
+    re().first(1).first(); //1
+    */
+    p.first = function(r){
+      if(arguments.length){
+        this.unshift.apply(this, arguments);
+        return this;
+      }
+      return this[0];
+    }
+    
+    p.last = function(ref){
+      if(arguments.length){
+        this.push.apply(this, arguments);
+        return this;
+      }
+      return this[this.length-1];
+    }
+    
     re.query = q;
     
 }(re));

data/src/core/system.js

@@ -44,6 +44,7 @@ re.c('system')
             (function m(){
               
               that.system_loop();
+              
               if(that.running){
                 that.requestAnimationFrame(m, that.canvas);
               }
@@ -67,7 +68,7 @@ re.c('system')
     },
     
     //scale is currently not implemented!
-    init:function(canvasId, scale, contextType){
+    init:function(canvasId, contextType){
         
         //add comps here because system is defined earlier than other comps
         this.comp('polyfill tick timestep');
@@ -79,8 +80,6 @@ re.c('system')
           this.canvas = re.$(canvasId);
         }
         
-        this.scale = scale || 1;
-        
         this.context = this.canvas.getContext(contextType || '2d');
         
         var s = re.screen = re.e('screen');
@@ -98,6 +97,8 @@ re.c('system')
         if(re._c.touch){
           re._c.touch.i();
         }
+        this.system_loop = this.defaultLoop;
+        this.second = this.stepSize * 30;
         
         return this;
     },
@@ -105,16 +106,25 @@ re.c('system')
     /*
     Default main loop
     */
-    system_loop:function(){
+    defaultLoop:function(){
         
         this.timestep(Math.min(this.tick() / 1000, this.maxTick), function(){
             //update
-            re._c.update.update(this.stepSize);
+            this.update();
         });
         
         //clear
         this.clear(this.clearColor);
-        re._c.draw.draw(this.context);
+        this.draw();
+    },
+    
+    update:function(){
+      re._c.update.update(this.stepSize);
+    },
+    
+    draw:function(){
+      //renders default drawlist
+      re.drawlist().drawlist(this.context);
     }