entityjs 0.3.2 → 0.4.0

data/src/math/distance.js

@@ -0,0 +1,7 @@
+re.distance = function(x1, y1, x2, y2) {  
+  var kx, ky;
+  kx = x2 - x1;
+  ky = y2 - y1;
+  
+  return Math.sqrt(kx*kx + ky*ky);
+};

data/src/math/iso.js

@@ -0,0 +1,147 @@
+re.iso = re.c('iso')
+.statics({
+  sizeX:30,
+  sizeY:30,
+  sizeZ:30,
+  
+  /*
+  Converts an x position into the closest iso x position.
+  */
+  toPosX:function(x, y){
+    var isox = this.toIsoX(x, y);
+    var isoy = this.toIsoY(x, y);
+    
+    return (isox - isoy) * this.sizeX;
+  },
+  
+  toPosY:function(x, y){
+    var isox = this.toIsoX(x, y);
+    var isoy = this.toIsoY(x, y);
+    
+    return (isox + isoy) * this.sizeY * 0.5;
+  },
+  
+  toPos:function(x, y){
+    if(re.is(x,'object')){
+      y = x.posY || x.y;
+      x = x.posX || x.x;
+    }
+    
+    return {posX:this.toPosX(x, y), posY:this.toPosY(x, y)};
+  },
+  
+  toIsoX:function(x, y){
+    var ym = (2*y - x) * 0.5;
+    var xm = x + ym;
+    
+    return Math.round(xm / this.sizeX)-1;
+  },
+  
+  toIsoY:function(x, y){
+    var ym = (2*y - x) * 0.5;
+    
+    return Math.round(ym / this.sizeY);
+  },
+  
+  toIso:function(x, y){
+    if(re.is(x, 'object')){
+      y = x.posY || x.y;
+      x = x.posX || x.x;
+    }
+    return {isoX:this.toIsoX(x,y), isoY:this.toIsoY(x, y)};
+  }
+  
+})
+.defaults({
+  posX:0,
+  posY:0,
+  posZ:0
+})
+.defines({
+  
+  /*
+    Moves the iso entity to the given isometric position.
+    
+    examples:
+    
+    e.iso(1, 0, 0);
+    
+    e.iso(otherIso);
+    
+    e.iso({x:1, y:1, z:2});
+  */
+  iso:function(x, y, z){
+    if(re.is(x,'object')){
+      z = x.z
+      if(re.is(x.posZ)){
+        z = x.posZ / re.iso.sizeZ;
+      }
+      y = x.y;
+      
+      //copy attributes
+      if(re.is(x.posX) && re.is(x.posY)){
+        this.posX = x.posX;
+        this.posY = x.posY;
+        if(x.posZ){
+          this.posZ = x.posZ;
+        }
+        return this;
+      }
+      
+      x = x.x;
+      
+    }
+    
+    //convert to screen space
+    x = (re.is(x)) ? x : this.isoX();
+    x *= re.iso.sizeX;
+    
+    //posY handles a lot of transformations, its safest to recalculate it
+    y = (re.is(y)) ? y : this.isoY();
+    y *= re.iso.sizeY;
+    
+    z = (re.is(z)) ? z : this.isoZ();
+    z *= re.iso.sizeZ;
+    
+    //all values should be in screen space from here
+    this.posX = x - y;
+    this.posY = (x + y) * 0.5 - z;
+    this.posZ = z;
+    
+    return this;
+  },
+  
+  isoX:function(value){
+    if(re.is(value)){
+      
+      return this.iso(value);
+    }
+    
+    return (this.posX + (2*(this.posY+this.posZ) - this.posX) * 0.5) / re.iso.sizeX;
+  },
+  
+  isoY:function(value){
+    if(re.is(value)){
+      
+      return this.iso({y:value});
+    }
+    
+    return ((2*(this.posY+this.posZ) - this.posX) * 0.5) / re.iso.sizeY;
+  },
+  
+  isoZ:function(value){
+    if(re.is(value)){
+      
+      return this.iso({z:value});
+    }
+    
+    return this.posZ / re.iso.sizeZ;
+  },
+  
+  //returns true if the current iso position is directly on top of a tile.
+  onIso:function(){
+    var total = this.isoX() + this.isoY() + this.isoZ();
+    return (total|0) == total;
+  }
+  
+});

data/src/math/point.js

@@ -30,11 +30,7 @@ re.c('point')
             y = x.posY || x.y;
             x = x.posX || x.x;
         }
-        var kx, ky;
-        kx = x - this.posX;
-        ky = y - this.posY;
-        
-        return Math.sqrt(kx*kx + ky*ky) + 0.5 | 0;
+        return re.distance(this.posX, this.posY, x, y);
     }
     
 });

data/src/math/random.js

@@ -0,0 +1,21 @@
+/*
+re.random() // 0 - 1 floats
+re.random(10) // 0 - 9 integer
+re.random(10, 30) // 10 - 30 integer
+re.random([1, 10, 40]) // 1 or 10 or 40
+
+*/
+re.random = function(max, min){
+  var r = Math.random();
+  if(re.is(max, 'array')){
+    return max[r * max.length | 0];
+  }
+		switch(arguments.length){
+			case 0:
+			return r;
+			case 1:
+			return r * max | 0;
+			case 2:
+			return r * (max - min + 1) + min | 0;
+  }
+};

data/src/math/range.js

@@ -0,0 +1,14 @@
+/*
+Returns an array of integers within the given range.
+
+re.range(0, 2); //[0, 1]
+re.range(2, 10, 2); //[2, 4, 6, 8]
+
+*/
+re.range = function(start, finish, step){
+  var a = [];
+  for(var i=start||0; i<finish; i+=step||1){
+    a.push(i);
+  }
+  return a;
+};

data/src/math/tile.js

@@ -39,44 +39,56 @@ re.e('tile sprite tiles.png', map.length * map[0].length)
 @warning moving to negative tiles will cause rounding issues.
 Its recommended you avoid negative tile values
 
+TODO: remove size vars from entity. Use global size instead
 */
 re.tile = re.c('tile')
 .statics({
     sizeX:40,
     sizeY:40,
     
-    toX:function(x, size){
-        size = size || this.sizeX;
-        return this.toTileX(x, size) * size;
+    toPosX:function(x){
+        return this.toTileX(x) * this.sizeX;
     },
     
-    toY:function(y, size){
-      size = size || this.sizeY;
-        return this.toTileY(y, size) * size;
+    toPosY:function(y){
+        return this.toTileY(y) * this.sizeY;
+    },
+    
+    toPos:function(x, y){
+      if(re.is(x,'object')){
+        y = x.posY || x.y;
+        x = x.posX || x.x;
+      }
+      
+      return {posX:this.toPosX(x), posY:this.toPosY(y)};
     },
     
     //converts the given coordinate to a tile position
-    toTileX:function(x, size){
-        size = size || this.sizeX;
-        return (x - size * 0.5) / size + 0.5 | 0
+    toTileX:function(x){
+        return (x - this.sizeX * 0.5) / this.sizeX + 0.5 | 0
     },
     
-    toTileY:function(y, size){
-        size = size || this.sizeY;
-        return (y - size * 0.5) / size + 0.5 | 0
+    toTileY:function(y){
+        return (y - this.sizeY * 0.5) / this.sizeY + 0.5 | 0
+    },
+    
+    toTile:function(x, y){
+      if(re.is(x,'object')){
+        y = x.posY || x.y;
+        x = x.posX || x.x;
+      }
+      
+      return {tileX:this.toTileX(x), tileY:this.toTileY(y)};
     }
     
 })
 .defaults({
     
     posX:0,
-    posY:0
+    posY:0,
+    regX:0,
+    regY:0
     
-})
-.init(function(){
-  this.sizeX = re.tile.sizeX;
-  this.sizeY = re.tile.sizeY;
-  
 })
 .defines({
 
@@ -92,25 +104,26 @@ re.tile = re.c('tile')
     },
     
     tileX:function(v){
-      var s = this.sizeX || re.tile.sizeX;
-      var r = this.regX || 0;
       if(re.is(v)){
-        this.posX = (v - r) * s;
+        this.posX = v * this.sizeX + 0.5 | 0;
         return this;
       }
       
-      return (this.posX - r) / s + 0.5 | 0;
+      return this.posX / this.sizeX + 0.5 | 0;
     },
     
     tileY:function(v){
-      var s = this.sizeX || re.tile.sizeY;
-      var r = this.regY || 0;
       if(re.is(v)){
-        this.posY = (v - r)* s;
+        this.posY = v* this.sizeY + 0.5 | 0;
         return this;
       }
       
-      return (this.posY - r) / s + 0.5 | 0;
+      return this.posY / this.sizeY + 0.5 | 0;
     }
     
-});
+})
+.init(function(){
+  this.sizeX = re.tile.sizeX;
+  this.sizeY = re.tile.sizeY;
+  
+})

data/src/pattern/automap.js

@@ -18,12 +18,12 @@ var level =
 [2,3,4,5,6,4]
 ]
 
-//value copy
+//reference copy
 map.automap(level)
 
 map.automap(0, 1) // 1
 
-//reference copy
+//value copy
 map.automap(level, true)
 
 map.map == level //true
@@ -45,6 +45,16 @@ re.c('automap')
     if(re.is(x, 'array')){
       
       if(y){
+        
+        //deep copy
+        for(var y=0; y<x.length; y++){
+			   for(var k=0; k<x[0].length; k++){
+				   this.automap(k, y, x[y][k]);
+			    }
+		    }
+        
+      } else {
+    		
         //non-deep copy
 		  
 		    this._automap = x;
@@ -56,15 +66,6 @@ re.c('automap')
     		}
     		
     		this.lenY = x.length;
-        
-      } else {
-    		
-        //deep copy
-        for(var y=0; y<x.length; y++){
-			   for(var k=0; k<x[0].length; k++){
-				   this.automap(k, y, x[y][k]);
-			    }
-		    }
       }
       
       return this;  

data/src/pattern/flicker.js

@@ -1,27 +1,45 @@
 /*
-The flicker component calls the implemented method and sends the given information over a period of time.
+The flicker component calls the implemented flick method with the given array data 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('health')
+.requires('flicker')
+.defines({
+  
+  health:100,
+  flick:function(health){
+    this.health += health;
+    if(this.health >= 100){
+      //stops flicker
+      return false;
+    }
+  },
+  
+  regen:function(){
+    //adds health over a duration of 30 seconds
+    this.flicker(30, [5, 5, 5, 5, 5, 5]);
+  }
+
+});
+
+var e = re.e('health').attr('health', 40);
+
+//low on health, regenerate
+e.regen();
+
 */
 re.c('flicker')
 .requires('update timestep')
 .interfaces('flick')
-.init(function(){
-	
-	this.flicker_reels = {};
-	this.flicker_old = {};
-	this.flicker_reel = {};
-	
-	this.flicker_flickering = '';
-	
-})
-.defines({
-	
-	flicker_stop:function(){
-		var o = this.flicker_flickering;
-		this.flicker_flickering = '';
+.namespaces({
+	flickering:'',
+  
+	stop:function(){
+		var o = this.flicker_id;
+		this.flicker_id = '';
 			
 		this.stepProgress = 0;
 			
@@ -30,15 +48,12 @@ re.c('flicker')
 		return this.trigger('flicker:finish', o);
 	},
 	
-	flicker_update:function(t){
-		
-		this.timestep(t, function(){
-			var c = this.flicker_reel;
-      
+  change:function(){
+    
 			//check if over
-			if(this.flicker_frame == this.flicker_reel.frames.length){
+			if(this.flicker_frame == this.flicker_frames.length){
 				
-				if(c.loops == -1 || --this.flicker_loops >= 1){
+				if(this.flicker_loops == -1 || --this.flicker_loops >= 1){
 					//loop again
 					
 					this.flicker_frame = 0;
@@ -47,151 +62,88 @@ re.c('flicker')
 					//done flickering
 					
 					this.flicker_stop();
-					
-					return;
+          return;
 				}
 			}
 			
+      this.flicker_run();
+  },
+  
+  run:function(){
+    
+    var f = this.flicker_frame,
+    fs = this.flicker_frames,
+    l = this.flicker_loops,
+    val = fs[f];
+    
+    var quit = this.flick(val, f, fs, l);
+    
+    this.trigger('flicker:update', val, f, fs, l);
+    
 			//flick
-			if(this.flick(c.frames[this.flicker_frame], this.flicker_flickering, this.flicker_loops) === false){
+			if(quit === false){
         //stop
         this.flicker();
       }
-			
+      
 			this.flicker_frame++;
-			
-		});
-		
-	},
-	
-	addFlicker:function(id, loops, duration, frames){
-	
-		if(re.is(id, 'object')){
-			
-			for(var i in id){
-					
-					//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(re.is(frames, 'string')) frames = frames.split(' ');
-		
-		//add
-		this.flicker_reels[id] = 
-		{
-			frames:frames,
-			duration:duration,
-			loops:loops
-		};
-		
-		return this;
-	},
-	
-	removeFlicker:function(id){
-		
-		if(re.is(id,'object')){
-			
-			for(var i in id){
-				
-				this.removeFlicker.call(this, id[i]);
-			}
-			
-			return this;
-		}
-		
-		//assuming this flicker isn't running
-		delete this.flicker_reels[id];
-		
-		return this;
+  },
+  
+	update:function(t){
+		this.timestep(t, this.flicker_change);
 	},
 	
+})
+.defines({
+  
 	/*
-	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],
-	..
-	
-	
-	});
-	
+  
+  loops defaults to 1
+  id default to true
+  
 	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){
+	flicker:function(duration, frames, loops, id){
 		
-		if(!re.is(id) && this.flickering()){
+    //stop
+		if(!re.is(loops) && this.flickering()){
 			//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;
-    
     //convert to seconds
-    if(c.duration >= 30){
-      c.duration /= 1000;
+    if(duration >= 100){
+      duration /= 1000;
     }
     
-		c.frames = (re.is(frames,'object'))? frames : r.frames;
-		
+		this.flicker_duration = duration || 1;
+    
+    frames = (re.is(frames,'array')) ? frames : [frames];
+    
 		//setup counter for loops
-		this.flicker_loops = c.loops;
+		this.flicker_loops = loops || 1;
 		
 		this.stepProgress = 0;
-		this.stepSize = c.duration / c.frames.length;
+		this.stepSize = (duration / frames.length) / re.sys.second;
     
-		//save old frames for upon completion
-		
+    this.flicker_frames = frames;
 		this.flicker_frame = 0;
 		
-		//update frame then run
-		this.flick(c.frames[this.flicker_frame++]);
-		
 		if(!this.flickering()){
 			this.on('update', this.flicker_update);
 		}
 		
-		this.flicker_flickering = id;
+    //sets flicker status
+		this.flicker_id = id || true;
+    
+		this.trigger('flicker:start');
+    
+		//update frame then run
+		this.flicker_run();
 		
-		return this.trigger('flicker:start');
+		return this;
 	},
 	
 	/*
@@ -202,10 +154,10 @@ re.c('flicker')
 	*/
 	flickering:function(id){
 		if(id){
-			return this.flicker_flickering == id;	
+			return this.flicker_id == id;	
 		}
 		
-		return this.flicker_flickering;
+		return this.flicker_id;
 	}
 	
 });