entityjs 0.2.2 → 0.3.0

data/src/{entityjs/input → input}/keyboard.js

@@ -1,150 +1,152 @@
-re.c('keyboard')
-.global({
-	listeners:[],
-	
-	keyCodes: { 
-    /* start the a-z keys */
-    65 : 'a',
-    66:'b',
-    67:'c',
-    68:'d',
-    69:'e',
-    70:'f',
-    71:'g',
-    72:'h',
-    73:'i',
-    74:'j',
-    75:'k',
-    76:'l',
-    77:'m',
-    78:'n',
-    79:'o',
-    80:'p',
-    81:'q',
-    82:'r',
-    83:'s',
-    84:'t',
-    85:'u',
-    86:'v',
-    87:'w',
-    88:'x',
-    89:'y',
-    90:'z',
-    /* start number keys */
-    48:'0',
-    49:'1',
-    50:'2',
-    51:'3',
-    52:'4',
-    53:'5',
-    54:'6',
-    55:'7',
-    56:'8',
-    57:'9',
-    /* start the f keys */
-    112:'f1',
-    113:'f2',
-    114:'f3',
-    115:'f4',
-    116:'f5',
-    117:'f6',
-    118:'f7',
-    119:'f8',
-    120:'f9',
-    121:'f10',
-    122:'f11',
-    123:'f12',
-    /* start the modifier keys */
-    16:'shift',
-    17:'ctrl', //mac os - control
-    18:'alt',//mac os key - option opt
-    24:'cmd', //Mac OS key - also command
-	255:'fn',//lenovo - function
-    /* Misc. Keys */
-    8:'backspace',
-    13:'enter', //max os - return
-    32:'space',
-    27:'esc',
-    9:'tab',
-    20:'capslock',
-    91:'windows',//mac os - super
-    46:'delete', //NOT THE OS X DELETE KEY!
-    36:'home',
-    35:'end',
-    33:'pageup',
-    34:'pagedown',
-    /* Arrow keys */
-    37:'left',
-    38:'up',
-    39:'right',
-    40:'down',
-    /* Special char keys */
-    96:'`',
-    45:'-',//also insert on mac?
-    187:'=',
-    219:'[',
-    221:']',
-    220:'\\', //it's actually a \ but there's two to escape
-    59:';',
-    222:"'",
-    188:',',
-    190:'.',
-    191:'/'
-	},
-	
-	/*
-	Add modifiers, shift, alt, ctrl.
-	.signal('ctrl+k')
-	*/
-	keyboardEvent: function(e){
-		var that = re.c('keyboard');
-		
-		if(that.body != document.activeElement){
-			return;
-		}
-		
-		var c = e.keyCode || e.which;
-		
-		var key = that.keyCodes[c];
-		
-		if(re.c('pressed').preventDefault && re.c('pressed').preventDefault[key]){
-			if(e.preventDefault)
-				e.preventDefault();
-			 else 
-				e.returnValue = false;
-			
-		}
-		
-		if(re.c('pressed')._pressed){
-			re.c('pressed')._pressed[key] = (e.type == 'keydown');
-		}
-		
-		for(var k=0; k<that.listeners.length; k++){
-			that.listeners[k]
-			.signal(e.type, key, e)
-			.signal(e.type+':'+key, key, e);
-		}
-		
-	},
-	
-	active:false,
-	
-	initListeners:function(){
-		if(!this.active){
-			this.active = true;
-			re.listener('keydown', this.keyboardEvent, false);
-			re.listener('keyup', this.keyboardEvent, false);
-			this.body = re.$('body')[0];
-		}
-	}
-
-})
-.init(function(c){
-	c.initListeners();
-	//add to global key array
-	c.listeners.push(this);
-})
-.dispose(function(c){
-	//remove from global key array
-	c.listeners.splice(c.listeners.indexOf(this), 1);
-});
+/*
+The keyboard component allows an entity to listen for keyboard events.
+
+@usage
+re.e('keyboard')
+.keydown(function(key, event){
+  re.log('keydown', key, event);
+})
+.keyup(function(key, event){
+  re.log('keyup', key, event);
+});
+
+*/
+re.c('keyboard')
+.statics({
+  //list of listing entities
+	l:[],
+	
+	keyCodes: { 
+    /* start the a-z keys */
+    65 : 'a',
+    66:'b',
+    67:'c',
+    68:'d',
+    69:'e',
+    70:'f',
+    71:'g',
+    72:'h',
+    73:'i',
+    74:'j',
+    75:'k',
+    76:'l',
+    77:'m',
+    78:'n',
+    79:'o',
+    80:'p',
+    81:'q',
+    82:'r',
+    83:'s',
+    84:'t',
+    85:'u',
+    86:'v',
+    87:'w',
+    88:'x',
+    89:'y',
+    90:'z',
+    /* start number keys */
+    48:'0',
+    49:'1',
+    50:'2',
+    51:'3',
+    52:'4',
+    53:'5',
+    54:'6',
+    55:'7',
+    56:'8',
+    57:'9',
+    /* start the f keys */
+    112:'f1',
+    113:'f2',
+    114:'f3',
+    115:'f4',
+    116:'f5',
+    117:'f6',
+    118:'f7',
+    119:'f8',
+    120:'f9',
+    121:'f10',
+    122:'f11',
+    123:'f12',
+    /* start the modifier keys */
+    16:'shift',
+    17:'ctrl', //mac os - control
+    18:'alt',//mac os key - option opt
+    24:'cmd', //Mac OS key - also command
+	255:'fn',//lenovo - function
+    /* Misc. Keys */
+    8:'backspace',
+    13:'enter', //max os - return
+    32:'space',
+    27:'esc',
+    9:'tab',
+    20:'capslock',
+    91:'windows',//mac os - super
+    46:'delete', //NOT THE OS X DELETE KEY!
+    36:'home',
+    35:'end',
+    33:'pageup',
+    34:'pagedown',
+    /* Arrow keys */
+    37:'left',
+    38:'up',
+    39:'right',
+    40:'down',
+    /* Special char keys */
+    96:'`',
+    45:'-',//also insert on mac?
+    187:'=',
+    219:'[',
+    221:']',
+    220:'\\', //it's actually a \ but there's two to escape
+    59:';',
+    222:"'",
+    188:',',
+    190:'.',
+    191:'/'
+	},
+	
+	/*
+	Add modifiers, shift, alt, ctrl.
+	.trigger('ctrl+k')
+	*/
+	event: function(e){
+		var that = re._c.keyboard;
+		
+    //disable keyboard keys if focus lost
+		if(that.body != document.activeElement){
+			return;
+		}
+		
+		var c = e.keyCode || e.which;
+    
+		var key = that.keyCodes[c];
+		
+		if(re.pressed.d){
+			re.pressed.d[key] = (e.type == 'keydown');
+		}
+
+		for(var k=0; k<that.l.length; k++){
+			that.l[k]
+			.trigger(e.type, key, e)
+			.trigger(e.type+':'+key, key, e);
+		}
+		
+	},
+	
+  //initialize function
+	i:function(){
+		this.body = re.$('body');
+		re.listener('keydown', this.event, false);
+		re.listener('keyup', this.event, false);
+	}
+
+})
+.init(function(c){
+	//add to statics key array
+	c.l.push(this);
+})
+.dispose(function(c){
+	//remove from statics key array
+	c.l.splice(c.l.indexOf(this), 1);
+});

data/src/input/mouse.js

@@ -0,0 +1,111 @@
+/*
+The mouse component allows an entity to listen to mouse triggers.
+
+@usage
+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
+})
+*/
+re.c('mouse')
+.statics({
+    l:[],
+    
+    press:function(e){
+        var b, c;
+        
+        //find which key
+        if(e.which == null){
+            //IE
+            if(e.button < 2){
+                b = 'left';    
+            } else if(e.button == 4){
+                b = 'middle';
+            } else {
+                b = 'right';    
+            }
+        } else {
+            if(e.which < 2){
+                b = 'left';    
+            } else if(e.which == 2){
+                b = 'middle';    
+            } else {
+                b = 'right';    
+            }
+        }
+        
+        c = 'mouse:'+b;
+        
+        //register mouse action
+        if(re.pressed.d){
+            re.pressed.d[c] = (e.type == 'mousedown');
+        }
+    
+        re.c('mouse').event(e, c);
+        
+    },
+    
+    event:function(e, extra){
+        
+        //calculate mouse coordinate
+        var x;
+        var y;
+        
+        if(e.pageX){
+            x = e.pageX;
+            y = e.pageY;
+        } else {
+            x = e.clientX + document.body.scrollLeft + document.documentElement.scrollLeft;
+            y = e.clientY + document.body.scrollTop + document.documentElement.scrollTop;
+        }
+        
+        //FUTURE fix, does not support multiple canvases
+        x -= re.sys.canvas.offsetLeft;
+        y -= re.sys.canvas.offsetTop;
+        
+        //ignore if off canvas
+        if(x < 0 || y < 0 || y > re.sys.sizeY || x > re.sys.sizeX){
+            return;
+        }
+        
+        var that = re.c('mouse');
+        
+        //FUTURE automatically transform screen coordinates?
+        var c, t, obj;
+        for(var i=0; i<that.l.length; i++){
+          t = that.l[i];
+          obj = {x:x, y:y};
+          obj.screenX = re.screen.toScreenX(x);
+          obj.screenY = re.screen.toScreenY(y);
+          
+          t.trigger(e.type, obj, e);
+          
+          if(extra){
+            t.trigger(e.type+':'+extra, obj, e);
+          }
+        }
+        
+    },
+    
+    i:function(){
+      re.listener('mousedown', this.press, false);
+      re.listener('mouseup', this.press, false);
+      re.listener('mousemove', this.event, false);
+      re.listener('click', this.event, false);
+      re.listener('dblclick', this.event, false);
+      re.listener('contextmenu', this.event, false);
+    }
+    
+})
+.init(function(c){
+    //add to listener array
+    c.l.push(this);
+})
+.dispose(function(c){
+    //remove from listener array
+    
+    c.l.splice(c.l.indexOf(this), 1);
+});

data/src/input/pressed.js

@@ -0,0 +1,41 @@
+/*
+The pressed method is used to check if a key or keys are currently pressed.
+This is most useful in mousemove, keydown or usually an update listener.
+
+@usage
+//move player
+re.e('update image player.png')
+.on('update', function(){
+  
+  if(re.pressed(['w', 'up'])){
+    this.posY -= 10;
+  }
+
+});
+
+//click based on key
+re.e('mouse image button.png')
+.on('click', function(){
+  
+  if(re.pressed('mouse:middle')){
+    //do something..
+  }
+
+});
+
+*/
+re.pressed = function(key){
+		
+		var c = arguments;
+		
+		if(re.is(key, 'array')) c = key;
+		
+		for(var i=0, l = c.length; i<l; i++){
+			if(re.pressed.d[c[i]]){
+				return true;
+			}
+		}
+		
+		return false;
+};
+re.pressed.d = {};

data/src/{entityjs/input → input}/touch.js

@@ -1,28 +1,24 @@
-/*
-The touch component handles touch events and dispatches signals.
-*/
-re.c('touch')
-.global({
-	
-	touchEvent:function(e){
-		
-	},
-	
-	active:false,
-	
-	initListeners:function(){
-		if(!this.active){
-			this.active = true;
-			
-			re.listener('touchstart', this.touchEvent, false);
-			re.listener('touchmove', this.touchEvent, false);
-			re.listener('touchend', this.touchEvent, false);
-			
-		}
-	}
-	
-})
-.init(function(c){
-	c.initListeners();
-	
-});
+/*
+The touch component handles touch events and dispatches signals.
+*/
+/*re.c('touch')
+.statics({
+	
+	touchEvent:function(e){
+		
+	},
+	
+	active:false,
+	
+	i:function(){
+		if(!this.active){
+			this.active = true;
+			
+			re.listener('touchstart', this.touchEvent, false);
+			re.listener('touchmove', this.touchEvent, false);
+			re.listener('touchend', this.touchEvent, false);
+			
+		}
+	}
+	
+});*/

data/src/math/bisect.js

@@ -0,0 +1,84 @@
+/*
+The bisect component cuts an object into equal sections. It supplies helper functions 
+for converting to a section and from a section. Useful for sprites and animation.
+
+The bisect is the width of an area.
+The size is the size of each equally divided block inside the width.
+For a sprite the bisect would be the total width of the image
+and the size would be the size of each frame.
+
+The bisect transforms two numbers, x and y positons, into a single bi number.
+
+This works by increasing the bi value once the x position is past the width.
+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){
+		
+		return this.biToTileX(bi, width, size) * size;
+	},
+	
+	biToY:function(bi, width, size){
+		
+		return this.biToTileY(bi, width, size) * size;
+	},
+	
+	biToTileX:function(bi, width, size){
+		
+		return bi % (width / size) | 0;
+	},
+	
+	biToTileY:function(bi, width, size){
+		return (bi * size) / (width - 0.1) | 0;
+	},
+	
+  /*
+  Accepts Tile positions not normal X,Y
+  */
+	tileToBi:function(xt, yt, w, s){
+		
+		return (xt + (yt * (w / s)));
+	}
+	
+})
+.defines({
+
+	
+	biToX:function(bi){
+		
+		return re.bisect.biToX(bi, this.bisect, this.sizeX);
+	},
+	
+	biToY:function(bi){
+		
+		return re.bisect.biToY(bi, this.bisect, this.sizeY);
+	},
+	
+	biToTileX:function(bi){
+		
+		return re.bisect.biToTileX(bi, this.bisect, this.sizeX);
+	},
+	
+	biToTileY:function(bi){
+		return re.bisect.biToTileY(bi, this.bisect, this.sizeY);
+	},
+	
+	tileToBi:function(xt, yt){
+		return re.bisect.tileToBi(xt, yt, this.bisect, this.sizeX);
+	}
+	
+})
+.defaults({
+	
+	//full width
+	bisect:1,
+	
+	sizeX:1,
+	sizeY:1
+	
+});

data/src/math/body.js

@@ -0,0 +1,70 @@
+/*
+The body component replaces the hittest component for
+a more precise hit test.
+
+It also removes the usage of sizeX and sizeX for collision
+boundaries.
+
+@usage
+
+re.e('body player.png')
+.attr({
+bodyX:40,
+bodyY:40,
+padX:2 //pushes the body in 2 pixels on both right and left
+})
+.touches(0, 0, 40, 40) //touches random thing?
+.touchesBody(0, 0, 40, 40, 2, 2) //touches another body?
+
+*/
+re.c('body')
+.defines({
+	
+	hit:function(x, y, w, h){
+    if(re.is(x,'object')){
+      y = x.posY;
+      w = x.sizeX;
+      h = x.sizeY;
+      x = x.posX;
+    }
+		return !
+		(
+		x > this.posX + this.bodyX - this.padX  ||
+		x + w < this.posX + this.padX ||
+		y > this.posY + this.bodyY - this.padY||
+		y + h < this.posY + this.padY
+		);
+	},
+	
+	hitBody:function(x, y, bx, by, px, py){
+    if(re.is(x,'object')){
+      y = x.posY;
+      bx = x.bodyX;
+      by = x.bodyY;
+      px = x.padX;
+      py = x.padY;
+      x = x.posX;
+    }
+		return !
+		(
+		x + px > this.posX + this.bodyX + this.padX ||
+		x + bx - px < this.posX + this.padX ||
+		y + py > this.posY + this.bodyY - this.padY ||
+		y + by - py < this.posY + this.padY
+		);
+	}
+	
+	
+})
+.defaults({
+	
+  posX:0,
+  posY:0,
+  
+	padX:0,
+	padY:0,
+	
+	bodyX:1,
+	bodyY:1
+	
+});