entityjs 0.2.2

data/src/entityjs/display/rect.js

@@ -0,0 +1,19 @@
+/*
+The rect component draws a rectangle on screen.
+*/
+re.c('rect')
+.require('draw')
+.inherit({
+	color:'#82d5f4'
+})
+.extend({
+	
+	draw:function(c){
+		
+		c.fillStyle = this.color;
+		
+		c.fillRect(-this.regX, -this.regY, this.sizeX, this.sizeY);
+		
+	}
+	
+});

data/src/entityjs/display/screen.js

@@ -0,0 +1,46 @@
+/*
+The screen component is used for scrolling or shaking all visible objects. 
+It simply offsets pos values upon rendering.
+
+This is useful for setting up a tile-based game.
+*/
+re.c('screen')
+.require('hittest')
+.extend({
+	
+	setPos:function(x, y){
+		if(arguments.length == 1){
+			y = x.posY;
+			x = x.posX;
+		}
+		
+		this.posX = x - this.regX;
+		this.posY = y - this.regY;
+		
+		return this;
+	},
+	
+	toScreenX:function(x){
+		return x + this.posX + this.offX;
+	},
+	
+	toScreenY:function(y){
+		return y + this.posY + this.offY;
+	}
+	
+})
+.inherit({
+	
+	posX:0,
+	posY:0,
+	
+	regX:0,
+	regY:0,
+	
+	sizeX:0,
+	sizeY:0,
+	
+	offX:0,
+	offY:0
+	
+});

data/src/entityjs/display/sprite.js

@@ -0,0 +1,37 @@
+/*
+The sprite object extends a drawable image for an entity.
+*/
+
+re.c('sprite')
+.require('bitmap bisect')
+.inherit({
+	
+	frameX:0,
+	frameY:0
+	
+})
+.extend({
+	
+	setFrameId:function(id){
+		this.frameX = this.biToXt(id);
+		this.frameY = this.biToYt(id);
+		
+		return this;
+	},
+	
+	getFrameId:function(){
+		return this.toBi(this.frameX, this.frameY);
+	},
+	
+	draw:function(c){
+		c.drawImage(this.bitmap, this.frameX * this.sizeX, this.frameY * this.sizeY, this.sizeX, this.sizeY, -this.regX, -this.regY, this.sizeX, this.sizeY);
+		
+		return this;
+	},
+	
+	//implement for flicker
+	flick:function(c){
+		this.setFrameId(c);
+	}
+	
+});

data/src/entityjs/input/keyboard.js

@@ -0,0 +1,150 @@
+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);
+});

data/src/entityjs/input/mouse.js

@@ -0,0 +1,123 @@
+re.c('mouse')
+.global({
+	listeners:[],
+	
+	mouseAction:function(e){
+		var b;
+		
+		//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';	
+			}
+		}
+		
+		b = 'mouse:'+b;
+		
+		//register mouse action
+		if(re.c('pressed')._pressed){
+			re.c('pressed')._pressed[b] = (e.type == 'mousedown');
+		}
+		
+		var c = false;
+		
+		if(re.c('pressed').preventDefault){
+			if(re.c('pressed').preventDefault[b]){
+				if(e.preventDefault)
+					e.preventDefault();
+				 else 
+					e.returnValue = false;
+					
+				c = true;
+			}
+		}
+		
+		re.c('mouse').mouseEvent(e);
+		
+		if(c) return false;
+	},
+	
+	mouseEvent:function(e){
+		
+		//calculate mouse coordinate
+		var x;
+		var y;
+		
+		if(e.pageX || e.pageY){
+			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
+		if(re.sys.canvas){
+			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, sx, sy;
+		for(var i=0, l = that.listeners.length; i<l; i++){
+			t = that.listeners[i];
+			if(t.toScreen && t.screen){
+				sx = t.screen.toScreenX(x);
+				sy = t.screen.toScreenY(y);
+			} else {
+				sx = x;
+				sy = y;
+			}
+			t.signal(e.type, sx, sy, e);
+		}
+		
+	},
+	
+	active:false,
+	initListeners:function(){
+		if(!this.active){
+			this.active = true;
+			
+			re.listener('mousedown', this.mouseAction, false);
+			re.listener('mouseup', this.mouseAction, false);
+			re.listener('mousemove', this.mouseEvent, false);
+			re.listener('click', this.mouseEvent, false);
+			re.listener('dblclick', this.mouseEvent, false);
+			re.listener('contextmenu', this.mouseEvent, false);
+		}
+	}
+	
+})
+.inherit({
+	toScreen:false
+})
+.init(function(c){
+	//add to listener array
+	c.initListeners();
+	c.listeners.push(this);
+})
+.dispose(function(c){
+	//remove from listener array
+	
+	c.listeners.splice(c.listeners.indexOf(this), 1);
+});

data/src/entityjs/input/pressed.js

@@ -0,0 +1,81 @@
+re.c('pressed')
+.global({
+	//contains pressed keys and mouse clicks
+	_pressed:{},
+	preventDefault:{}
+	
+})
+.extend({
+	
+	/*
+	This function is usually used in conjunction with mousemove or update for controls.
+	
+	//if either one is true
+	if(this.pressed('w', 'up')){
+		this.posY--;	
+	}
+	
+	//or
+	if(this.pressed(['w', 'up']){
+	
+	}
+	
+	*/
+	pressed:function(){
+		return re.pressed.apply(this, arguments);
+	},
+	
+	/*
+	Stops inputs default value.
+	
+	FUTURE
+	-be able to remove prevents
+	*/
+	preventDefault:function(){
+		re.preventDefault.apply(this, arguments);
+		return this;
+	}
+	
+})
+.init(function(){
+	
+	//int mouse and keyboard
+	re._c.keyboard.initListeners();
+	re._c.mouse.initListeners();
+	re._c.touch.initListeners();
+	
+});
+
+re.pressed = function(key){
+		var that = re.c('pressed');
+		
+		var c = arguments;
+		
+		if(typeof key == 'object') c = key;
+		
+		for(var i=0; i<c.length; i++){
+			if(that._pressed[c[i]]){
+				return true;
+			}
+		}
+		
+		return false;
+};
+
+re.preventDefault = function(key){
+	
+	var p = key.split(' ');
+	
+	if(p.length > 1){
+		
+		for(var k in p){
+			this.preventDefault(p[k]);	
+		}
+		
+		return this;
+	}
+	
+	 re.c('pressed').preventDefault[key] = true;
+	
+	return this;
+};

data/src/entityjs/input/touch.js

@@ -0,0 +1,28 @@
+/*
+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();
+	
+});

data/src/entityjs/math/bind.js

@@ -0,0 +1,76 @@
+/*
+The bind component prevents points from going outside of the set parameters.
+
+This can be useful for maps, characters, enemies, boxes etc..
+
+re.e('bind bitmap char.png')
+.bind = {min:{x:0, y:0}, max:{x:100, y: 10}};
+
+*/
+
+re.c('bind')
+.require('update')
+.namespace({
+	
+	update:function(){
+		if(!this.bind) return;
+		
+		if(this.posX < this.bindMinX){
+			
+			this.posX = this.bindMinX;
+			
+		} else if(this.posX > this.bindMaxX){
+		
+			this.posX = this.bindMaxX;	
+		}
+		
+		if(this.posY < this.bindMinY){
+			
+			this.posY = this.bindMinY;
+			
+		} else if(this.posY > this.bindMaxY){
+		
+			this.posY = this.bindMaxY;	
+		}
+		
+	}
+	
+})
+.inherit({
+	
+	posX:0,
+	posY:0,
+	
+	bindMinX:0,
+	bindMinY:0,
+	
+	bindMaxX:10,
+	bindMaxY:10,
+	
+	bind:true
+	
+})
+.extend({
+	
+	setBind:function(minx, miny, maxx, maxy){
+		
+		this.bindMinX = minx;
+		this.bindMinY = miny;
+		
+		this.bindMaxX = maxx;
+		this.bindMaxY = maxy;
+		
+		return this;
+	}
+	
+})
+.init(function(){
+	
+	this.addSignal('update', this.bind_update);
+	
+})
+.dispose(function(){
+	
+	this.removeSignal('update', this.bind_update);
+	
+});

data/src/entityjs/math/bisect.js

@@ -0,0 +1,69 @@
+/*
+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.
+*/
+re.bisect = re.c('bisect')
+.global({
+	
+	biToX:function(bi, width, size){
+		
+		return this.biToXt(bi, width) * size;
+	},
+	
+	biToY:function(bi, width, size){
+		
+		return this.biToYt(bi, width) * size;
+	},
+	
+	biToXt:function(bi, width, size){
+		
+		return Math.floor(bi % (width / size) );
+	},
+	
+	biToYt:function(bi, width, size){
+		return Math.floor((bi * size) / (width - 0.1));
+	},
+	
+	toBi:function(xt, yt, w, s){
+		
+		return (xt + (yt * (w / s))) / s;
+	}
+	
+})
+.extend({
+
+	
+	biToX:function(bi){
+		
+		return this.biToXt(bi, this.bisect) * this.sizeX;
+	},
+	
+	biToY:function(bi){
+		
+		return this.biToYt(bi, this.bisect) * this.sizeY;
+	},
+	
+	biToXt:function(bi){
+		
+		return Math.floor(bi % (this.bisect / this.sizeX) );
+	},
+	
+	biToYt:function(bi){
+		return Math.floor((bi * this.sizeY) / (this.bisect - 0.1));
+	},
+	
+	toBi:function(xt, yt){
+		
+		return (xt + (yt * (this.bisect / this.sizeX))) / this.sizeX;
+	}
+	
+})
+.inherit({
+	
+	//spliting width
+	bisect:1,
+	
+	sizeX:1,
+	sizeY:1
+	
+});

data/src/entityjs/math/body.js

@@ -0,0 +1,39 @@
+/*
+The body component replaces the hittest component for
+a more precise touch checking.
+
+*/
+re.c('body')
+.extend({
+	
+	touches:function(x, y, w, h){
+		return !
+		(
+		x > this.posX + this.bodX - this.padX  ||
+		x + w < this.posX + this.padX ||
+		y > this.posY + this.bodY - this.padY||
+		y + h < this.posY + this.padY
+		);
+	},
+	
+	touchesBody:function(x, y, bx, by, px, py){
+		return !
+		(
+		x + px > this.posX + this.bodX + this.padX ||
+		x + bx - px < this.posX + this.padX ||
+		y + py > this.posY + this.bodY - this.padY ||
+		y + by - py < this.posY + this.padY
+		);
+	}
+	
+	
+})
+.inherit({
+	
+	padX:0,
+	padY:0,
+	
+	bodX:1,
+	bodY:1
+	
+});

data/src/entityjs/math/drag.js

@@ -0,0 +1,39 @@
+/*
+The drag component adds functions to move points
+in relation to its starting postion.
+*/
+re.c('drag')
+.inherit({
+	posX:0,
+	posY:0,
+	
+	dragX:0,
+	dragY:0,
+	
+	dragging:false
+})
+.extend({
+	
+	startDrag:function(x, y){
+		if(!this.dragging){
+			this.dragging = true;
+			this.dragX = x;
+			this.dragY = y;
+		}
+	},
+	
+	endDrag:function(){
+		this.dragging = false;
+	},
+	
+	updateDrag:function(x, y){
+		if(this.dragging){
+			this.posX += x - this.dragX;
+			this.posY += y - this.dragY;
+			
+			this.dragX = x;
+			this.dragY = y;
+		}
+	}
+	
+});