entityjs 0.3.2 → 0.4.0

data/src/cycle/drawlist.js

@@ -0,0 +1,79 @@
+/*
+The drawlist is an array of draw entities. Which can all be drawn at once using the .draw() method.
+
+The draw component contains one drawlist for basic drawing. For cases when multiple drawlists is needed,
+such as for large depth sorts, its more efficient to depth sort on the wanted draw objects rather than all
+existing draw entities.
+
+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 || '';
+  
+  //name default to '' and returns default drawlist
+  
+  if(!d._lists[name]){
+    //add new list
+    re.e('drawlist:'+name);
+  }
+  
+  return d._lists[name];
+};
+
+re.c('drawlist')
+.statics({
+  _lists:{}
+})
+.defines({
+  
+  add:function(e){
+    if(e.drawlist){
+      e.drawlist.remove(e);
+    }
+    
+    e.drawlist = this;
+    this.list.last(e);
+    return this;
+  },
+  
+  remove:function(e){
+    if(e.drawlist){
+      this.list.erase(e);
+      e.drawlist = null;
+    }
+    return this;
+  },
+  
+  drawlist:function(c){
+        var lis = this.list;
+        
+        for(var i=0, b; i<lis.length; i++){
+          b = lis[i];
+            b.visible() && b.render(c);
+        }
+        
+  },
+    
+  sort:function(){
+    
+    this.list.sort(function(a, b){
+      if(a.depth && b.depth){
+        return a.depth() - b.depth();
+      }
+      return 0;
+    });
+    
+  }
+  
+})
+.init(function(c, name){
+  c._lists[name] = this;
+  this.listName = name;
+  this.list = re();
+})
+.dispose(function(c){
+  delete c._lists[this.listName];
+});

data/src/cycle/tween.js

@@ -47,15 +47,9 @@ re.c('tween')
       
       this.tweening = false;
       
-      this.trigger('tween:finish');
-      
-      //remove from queue
-      var next = this.tween_queue.shift();
-      
-      if(next){
-        this.tween.apply(this, next);
-      }
+      this.off('update', this.tween_update);
       
+      this.trigger('tween:finish');
     }
     
 	}
@@ -73,17 +67,13 @@ re.c('tween')
 .defines({
 	
 	tween:function(time, props){
-    if(this.tweening){
-      this.tween_queue.push(arguments);
-      return;
-    }
     
     //accepts ms or seconds
-    if(time >= 30){
+    if(time >= 100){
       time /= 1000;
     }
     
-    var maxTime = (time || 1) / (re.sys.stepSize * 60);
+    var maxTime = (time || 1) / re.sys.second;
     this.tween_time = 0;
     //steps are substracted until it reaches zero
     
@@ -104,18 +94,15 @@ re.c('tween')
     //tween maximum time
     this.tween_t = maxTime;
     
+    if(!this.tweening){
+      this.on('update', this.tween_update);
+    }
     
     this.tweening = true;
     
     return this.trigger('tween:start', starts);
 	}
   
-})
-.init(function(){
-	
-  this.on('update', this.tween_update);
-  this.tween_queue = [];
-	
 });
 
 re.tween = function(obj, time, props){

data/src/cycle/wait.js

@@ -1,23 +1,14 @@
-/*
-The wait component delays function calls.
-*/
 re.c('wait')
-.requires('update')
 .defines({
-	
-	wait:function(time, callback){
-		var c = 0;
-		
-		this.bind('update',  function(t){
-			c += t;
-			
-			if(c >= time){
-				this.callback.apply(this, Array.prototype.slice.call(arguments, 2));
-				return false;
-			}
-		});
-		
+  
+  wait:function(method, time){
+    time = time || 1000;
+    
+    //convert seconds to milliseconds
+    if(time < 100) time *= 1000;
+    
+    setTimeout(method, time);
     return this;
-	}
-	
+  }
+  
 });

data/src/{cycle → display}/draw.js

@@ -1,28 +1,10 @@
 re.c('draw')
-.statics({
-    l:[],
-    
-    draw:function(c){
-        var lis = this.l;
-        
-        for(var i=0, b; i<lis.length; i++){
-          b = lis[i];
-            b.drawable && b.visible() && b.draw_render(c);
-        }
-        
-    }
-    
-})
 .interfaces('draw')
-.init(function(c){
-    
-    c.l.push(this);
-    
+.init(function(){
+    re.drawlist().add(this);
 })
 .dispose(function(c){
-    
-    c.l.splice(c.l.indexOf(this), 1);
-    
+    this.drawlist.remove(this);
 })
 .defaults({
     screenable:true,
@@ -45,6 +27,11 @@ re.c('draw')
 })
 .defines({
     
+  depth:function(){
+    return this.posY;
+  },
+  
+  /* NOT WORKING
     cache:function(){
         if(!this.image) return this;
         
@@ -65,9 +52,9 @@ re.c('draw')
     clearCache:function(){
         this.canvasCache = null;
     },
-    
+    */
     drawFirst:function(){
-        var l = re.c('draw').l;
+      var l = this.drawlist.list;
         
         l.splice(l.indexOf(this), 1);
         
@@ -76,7 +63,7 @@ re.c('draw')
     },
     
     drawLast:function(){
-        var l = re.c('draw').l;
+        var l = this.drawlist.list;
         
         l.splice(l.indexOf(this), 1);
         
@@ -85,7 +72,7 @@ re.c('draw')
     },
     
     drawAfter:function(en){
-        var l = re.c('draw').l;
+        var l = this.drawlist.list;
         var him = l.indexOf(en);
         var me = l.indexOf(this);
         
@@ -101,7 +88,7 @@ re.c('draw')
     
     drawBefore:function(en){
         
-        var l = re.c('draw').l;
+        var l = this.drawlist.list;
         var him = l.indexOf(en);
         var me = l.indexOf(this);
         
@@ -131,25 +118,28 @@ re.c('draw')
         return this.posY - re.screen.posY;
     },
     
+    /*
+    Renders the entity to the canvas. Goes through the transformations, scaling, alpha etc...
+    */
+    render:function(c){
+        
+        this.draw_before(c);
+            this.draw(c);
+        this.draw_after(c);
+    },
+    
     /*
     Returns true or false wether the object is visible on screen.
     */
     visible:function(){
         
-        return re.screen.hit(this.posX - this.regX, this.posY - this.regY, this.sizeX, this.sizeY);
+        return this.drawable && re.screen.hit(this.posX - this.regX, this.posY - this.regY, this.sizeX, this.sizeY);
         
     }
     
 })
 .namespaces({
     
-    render:function(c){
-        
-        this.draw_before(c);
-            this.draw(c);
-        this.draw_after(c);
-    },
-    
     before:function(c){
         
         c.save();

data/src/display/image.js

@@ -2,7 +2,7 @@
 The image component draws an image on screen.
 
 
-FUTURE - add bitdata component for image manipulation.
+FUTURE - add imagedata component for image manipulation.
 */
 re.c('image')
 .requires('draw')

data/src/display/screen.js

@@ -12,9 +12,9 @@ re.c('screen')
       if(!arguments.length){
         return this;
       }
-      if(arguments.length == 1){
-          y = x.posY;
-          x = x.posX;
+      if(re.is(x,'object')){
+        y = x.posY;
+        x = x.posX;
       }
       
       this.posX = x - this.regX;

data/src/display/sprite.js

@@ -5,13 +5,13 @@ The sprite object definess a drawable image for an entity.
 var sprite = re.e('sprite player.png');
 
 //move to frame 3
-sprite.fra(3)
+sprite.frame(3)
 
 //get current frame
-sprite.fra()
+sprite.frame()
 
 //manually move to frame
-sprite.attr({fraX:0, fraY:1});
+sprite.attr({frameX:0, frameY:1});
 
 //add animation
 sprite.comp('flicker')

data/src/display/text.js

@@ -28,7 +28,9 @@ re.c('text')
 	
 	text:function(t){
     if(re.is(t)){
-      t += '';
+      //convert to string
+      t = Array.prototype.join.call(arguments, ' ');
+      
       this.text_lines = t.split('\n');
   		this._text = t;
       //set text width

data/src/input/mouse.js

@@ -6,9 +6,12 @@ re.e('mouse')
 .on('mousedown:middle', function(m){
     //m.x - x position
     //m.y - y position
-    //m.scrX - screen x position
-    //m.scrY - screen y position
+    //m.screenX - screen x position
+    //m.screenY - screen y position
 })
+
+FUTURE: rename triggers to the standard format
+mousemove -> mouse:move
 */
 re.c('mouse')
 .statics({
@@ -50,11 +53,22 @@ re.c('mouse')
     
     event:function(e, extra){
         
+        var canvas = re.sys.canvas;
         //calculate mouse coordinate
-        var x = e.offsetX;
-        var y = e.offsetY;
+        var x = canvas.width / canvas.offsetWidth;
+        var y = canvas.height / canvas.offsetHeight;
+        
+        //calculate offset
+        if(e.offsetX != null){ //chrome, opera
+          x *= e.offsetX;
+          y *= e.offsetY;
+        } else { //firefox
+          x *= e.layerX - canvas.offsetLeft;
+          y *= e.layerY - canvas.offsetTop;
+        }
+        
         
-        var that = re.c('mouse');
+        var listeners = re.c('mouse').l;
         
         /*
         if(re.preventDefault && re.preventDefault.d[key]){
@@ -63,16 +77,21 @@ re.c('mouse')
         */
         
         var c, t, obj;
-        for(var i=0; i<that.l.length; i++){
-          t = that.l[i];
-          obj = {posX:x, posY:y};
-          obj.screenX = re.screen.toScreenX(x);
-          obj.screenY = re.screen.toScreenY(y);
+        for(var i=0; i<listeners.length; i++){
+          t = listeners[i];
+          if(t.screenable){
+            x = re.screen.toScreenX(x);
+            y = re.screen.toScreenY(y);
+          }
+          
+          //offset mouse coordinates
+          var tx = x + t.offX;
+          var ty = y + t.offY;
           
-          t.trigger(e.type, obj, e);
+          t.trigger(e.type, tx, ty, e);
           
           if(extra){
-            t.trigger(e.type+':'+extra, obj, e);
+            t.trigger(e.type+':'+extra, tx, ty, e);
           }
         }
         
@@ -89,6 +108,10 @@ re.c('mouse')
     }
     
 })
+.defaults({
+  offX:0,
+  offY:0
+})
 .init(function(c){
     //add to listener array
     c.l.push(this);

data/src/math/bisect.js

@@ -18,22 +18,22 @@ Note: width is called the bisect and the bi is the transformed x,y positions.
 re.bisect = re.c('bisect')
 .statics({
 	
-	biToX:function(bi, width, size){
+	toX:function(bi, width, size){
 		
-		return this.biToTileX(bi, width, size) * size;
+		return this.toTileX(bi, width, size) * size;
 	},
 	
-	biToY:function(bi, width, size){
+	toY:function(bi, width, size){
 		
-		return this.biToTileY(bi, width, size) * size;
+		return this.toTileY(bi, width, size) * size;
 	},
 	
-	biToTileX:function(bi, width, size){
+	toTileX:function(bi, width, size){
 		
 		return bi % (width / size) | 0;
 	},
 	
-	biToTileY:function(bi, width, size){
+	toTileY:function(bi, width, size){
 		return (bi * size) / (width - 0.1) | 0;
 	},
 	
@@ -51,21 +51,22 @@ re.bisect = re.c('bisect')
 	
 	biToX:function(bi){
 		
-		return re.bisect.biToX(bi, this.bisect, this.sizeX);
+		return re.bisect.toX(bi, this.bisect, this.sizeX);
 	},
 	
 	biToY:function(bi){
 		
-		return re.bisect.biToY(bi, this.bisect, this.sizeY);
+		return re.bisect.toY(bi, this.bisect, this.sizeX);
 	},
 	
 	biToTileX:function(bi){
 		
-		return re.bisect.biToTileX(bi, this.bisect, this.sizeX);
+		return re.bisect.toTileX(bi, this.bisect, this.sizeX);
 	},
 	
 	biToTileY:function(bi){
-		return re.bisect.biToTileY(bi, this.bisect, this.sizeY);
+    //sizeY doesn't matter when dealing with bisects
+		return re.bisect.toTileY(bi, this.bisect, this.sizeX);
 	},
 	
 	tileToBi:function(xt, yt){