entityjs 0.2.2

data/src/entityjs/math/hitmap.js

@@ -0,0 +1,165 @@
+/*
+
+The hitmap component is used for collision detection in a tile-based game.
+This can be sent to a physics entity and it will recieve checks if it hits
+a tile.
+
+Creating this signal system will allow other developers to easily implement
+their own hit collision system.
+*/
+re.c('hitmap')
+.require('arraymap')
+.extend({
+
+	hitValue:1,
+	
+	checkAxisX:function(value, x, y, vx, vy){
+		
+		return value == this.hitValue;
+		
+	},
+	
+	checkAxisY:function(value, x, y, vx, vy){
+		return value == this.hitValue;
+	},
+	
+	checkHit:function(posX, posY, velX, velY, bodX, bodY, padX, padY){
+		if(arguments.length == 1){
+			var velX = posX.velX;
+			var velY = posX.velY;
+			
+			var bodX = posX.bodX;
+			var bodY = posX.bodY;
+			
+			var padX = posX.padX;
+			var padY = posX.padY;
+			
+			var posY = posX.posY;
+			posX = posX.posX;
+		}
+		
+		var res = {
+			posX:posX,
+			posY:posY,
+			tarX:-1,
+			tarY:-1
+		};
+		
+		var step = ~~(Math.max(Math.abs(velX), Math.abs(velY)) / ((re.tile.sizeX + re.tile.sizeY) * 0.5) + 0.5);
+		
+        if(step > 1) {
+            var sx = velX / step;
+            var sy = velY / step;
+            
+            for(var i=0; i<step && (sx || sy); i++) {
+				
+                this.hitmap_step(res, posX, posY, sx, sy, bodX, bodY, padY, padY);
+                
+                if(res.hitX) {
+					sx = 0;
+				}
+				
+                if(res.hitY) {
+					sy = 0;
+				}
+            }
+			
+        } else {
+			
+            this.hitmap_step(res, posX, posY, velX, velY, bodX, bodY, padX, padY);
+			
+        }
+		
+		return res;
+	}
+	
+})
+.namespace({
+	
+	/*
+	TODO:
+	refactor
+	possibly utilize entity methods for more robust calculations.
+	*/
+	step:function(res, x, y, vx, vy, width, height, padx, pady){
+	
+		res.posX += vx;
+        res.posY += vy;
+        
+		var t, ty, tx;
+		
+        if(vx) {
+			
+			t = re.tile.sizeX;
+			
+            var offsetx = (vx > 0 ? width - padx : padx);
+			
+            var firsty = Math.floor((y + pady)/ t);
+            var lasty = Math.ceil((y + height - pady) / t);
+			
+            tx = Math.floor((x + vx + offsetx) / t);
+            
+            var offx = (vx < 0 ? t : 0);
+			//is inside
+            if(tx >= 0 && tx < this.lengthX && lasty >= 0 && firsty < this.lengthY) {
+				
+                for(ty = firsty; ty<lasty; ty++){
+					
+                    if(this.map[ty]){
+						
+						//signal
+						this.signal('hit', this.map[ty][tx], tx, ty);
+						
+						if(this.checkAxisX(this.map[ty][tx], x, y, vx, vy)) {
+							res.hitX = true;
+							res.posX = tx * t + offx  - offsetx;
+							res.tarX = tx * t;
+							res.tarY = ty * t;
+							break;
+						}
+                    }
+					
+                }
+				
+            }
+			
+        }
+		
+        if(vy) {
+			t = re.tile.sizeY;
+			
+            var offsety = (vy > 0 ? height -pady : pady);
+			
+            var firstx = Math.floor((res.posX + padx) / t);
+            var lastx = Math.ceil((res.posX + width - padx) / t);
+            ty = Math.floor((y + vy + offsety) / t);
+            
+            var offy = (vy < 0 ? t : 0);
+            // Still inside this collision map?
+            if(ty >= 0 && ty < this.lengthY && lastx >= 0 && firstx< this.lengthX) {
+					
+                for(tx = firstx; tx<lastx; tx++) {
+					
+                    if(this.map[ty]){
+						
+						this.signal('hit', this.map[ty][tx], tx, ty);
+						
+						if(this.checkAxisY(this.map[ty][tx], x, y, vx, vy)) {
+							res.hitY = true;
+							res.posY = ty * t + offy - offsety;
+							res.tarX = tx * t;
+							res.tarY = ty * t;
+							break;
+						}
+                    }
+					
+                }
+            }
+			
+			
+			
+        }
+		
+	}
+	
+});

data/src/entityjs/math/hittest.js

@@ -0,0 +1,26 @@
+re.c('hittest')
+.inherit({
+	
+	posX:0,
+	posY:0,
+	
+	sizeX:0,
+	sizeY:0,
+	
+	/*
+	checks if the two targets intersect with each other.
+	
+	k.touches(x, y, width, height);
+	
+	*/
+	touches:function(x, y, w, h){
+		return !
+		(
+		x > this.posX + this.sizeX ||
+		x + w < this.posX ||
+		y > this.posY + this.sizeY ||
+		y + h < this.posY
+		);
+	}
+	
+});

data/src/entityjs/math/physics.js

@@ -0,0 +1,142 @@
+/*
+The Physics component adds new physical and time calculated variables to an entity.
+
+These variables will give the entity a more fluid movement in 2d space.
+
+Warning - this component is not delta time safe. It assumes a fixed timestep.
+*/
+re.physics = re.c('physics')
+.require('update')
+.global({
+	graX:0,
+	graY:0,
+	
+	//velocity lower than this will be rounded down
+	minVel:0.01
+})
+.inherit({
+	
+	posX:0,
+	posY:0,
+	
+	velX:0,
+	velY:0,
+	
+	velMaxX:100,
+	velMaxY:100,
+	
+	friX:0.9,
+	friY:0.4,
+	
+	accX:0,
+	accY:0,
+	
+	resX:0,
+	resY:0,
+	
+	masX:1,
+	masY:1,
+	
+	padX:0,
+	padY:0,
+	
+	bodX:1,
+	bodY:1
+	
+})
+.namespace({
+	
+	update:function(t){
+		
+		this.velX = this.force(this.velX, this.accX, this.friX, this.graX, this.masX, this.velMaxX);
+		this.velY = this.force(this.velY, this.accY, this.friY, this.graY, this.masY, this.velMaxY);
+		
+		//check collisions and get result
+		if(this.hitmap){
+			
+			this.aftermath(this.hitmap.checkHit(this));
+			
+		} else {
+			
+			this.aftermath(this.posX + this.velX, this.posY + this.velY);
+		}
+		
+	}
+	
+})
+.extend({
+	
+	aftermath:function(posx, posy, hitx, hity, tarx, tary){
+		
+		if(arguments.length == 1){
+			hitx = posx.hitX;
+			hity = posx.hitY;
+			
+			tarx = posx.tarX;
+			tary = posx.tarY;
+			
+			posy = posx.posY;
+			posx = posx.posX;
+		}
+		
+		this.posX = posx;
+		this.posY = posy;
+		
+		this.signal('aftermath', hitx, hity, tarx, tary);
+		
+		if(hitx){
+			this.velX = this.forceRes(this.velX, this.resX);
+		}
+		
+		if(hity){
+			this.velY = this.forceRes(this.velY, this.resY);
+		}
+		
+	},
+	
+	forceRes:function(vel, res){
+		return vel * -res;
+	},
+	
+	forceGra:function(gra, mas){
+		return gra * mas;
+	},
+	
+	forceVel:function(vel, acc, fri){
+		return (vel + acc) * fri;
+		
+	},
+	
+	force:function(vel, acc, fri, gra, mas, max){
+		
+		var v = this.forceVel(vel, acc, fri) + this.forceGra(gra, mas);
+		
+		v = Math.min(max, Math.max(-max, v));
+		
+		if(Math.abs(v) < re.physics.minVel){
+			v = 0;
+		}
+		
+		return v;
+	},
+	
+	isIdle:function(){
+		return (this.velY == 0 && this.velX == 0 && this.accX == 0 && this.accY == 0);
+	}
+	
+})
+.init(function(c){
+	
+	//setup defaults
+	this.hitmap = re.hitmap;
+	
+	this.graX = c.graX;
+	this.graY = c.graY;
+	
+	this.addSignal('update', this.physics_update);
+})
+.dispose(function(){
+	
+	this.removeSignal('update', this.physics_update);
+	
+});

data/src/entityjs/math/point.js

@@ -0,0 +1,57 @@
+/*
+The point component extends an entity that has a 2d position in space.
+This can be used for 2d calculations or most commonly 2d sprite positioning.
+
+*/
+
+re.c('point')
+.inherit({
+	
+	posX:0,
+	posY:0
+	
+})
+.extend({
+	
+	setPos:function(x, y){
+		
+		if(arguments.length == 1){
+			if(x.y)
+				this.posY = x.posY;
+			
+			if(x.x)
+				this.posX = x.posX;
+			
+		} else {
+		
+			this.posX = x;
+			this.posY = y;
+			
+		}
+		
+		return this;
+	},
+	
+	setPosX:function(x){
+		this.posX = x;
+		return this;
+	},
+	
+	setPosY:function(y){
+		this.posY = y;
+		return this;
+	},
+	
+	distanceTo:function(x, y){
+		if(arguments.length == 1){
+			y = x.posY;
+			x = x.posX;
+		}
+		var kx, ky;
+		kx = x-this.posX>>31;
+		ky = y-this.posY>>31;
+		
+		return Math.round(((x-this.posX ^kx)-kx)+((y-this.posY^ky)-ky));
+	}
+	
+});

data/src/entityjs/math/tile.js

@@ -0,0 +1,91 @@
+/*
+The tile component adds tile positioning functions and helper functions for tile based games.
+*/
+re.tile = re.c('tile')
+.global({
+	sizeX:40,
+	sizeY:40,
+	
+	roundX:function(x, size){
+		if(arguments.length == 1){
+			size = re.tile.sizeX;
+		}
+		return re.tile.roundTileX(x) * size;
+	},
+	
+	roundY:function(y, size){
+		if(arguments.length == 1){
+			size = re.tile.sizeY;
+		}
+		return re.tile.roundTileY(y) * size;
+	},
+	
+	roundTileX:function(x, size){
+		if(arguments.length == 1){
+			size = re.tile.sizeX;
+		}
+		return Math.round((x - size*0.5)/size);
+	},
+	
+	roundTileY:function(y, size){
+		if(arguments.length == 1){
+			size = re.tile.sizeY;
+		}
+		return Math.round((y - size * 0.5)/size);
+	}
+	
+})
+.inherit({
+	
+	posX:0,
+	posY:0
+	
+})
+.init(function(){
+	
+	if(!this.sizeX)
+	this.sizeX = re.tile.sizeX;
+	
+	if(!this.sizeY)
+	this.sizeY = re.tile.sizeY;
+	
+})
+.extend({
+
+	setTileFromPoint:function(x, y){
+		this.posX = re.tile.roundX(x);
+		this.posY = re.tile.roundY(y);
+		
+		return this;
+	},
+	
+	setTile:function(xt, yt){
+		this.setTileX(xt);
+		this.setTileY(yt);
+		
+		return this;
+	},
+	
+	setTileX:function(value){
+		this.posX = Math.floor(value * this.sizeX);
+		
+		return this;
+	},
+	
+	getTileX:function(){
+		return Math.floor(this.posX / this.sizeX);
+	},
+	
+	setTileY:function(value){
+		
+		this.posY = Math.floor(value * this.sizeY);
+		
+		return this;
+	},
+	
+	getTileY:function(){
+		
+		return Math.floor(this.posY / this.sizeY);
+	}
+	
+});

data/src/entityjs/media/channel.js

@@ -0,0 +1,93 @@
+/*
+The channel component allows you to play a sound component more than
+once at the sametime. This is useful for shooting or fast games.
+
+//create a new channel
+re.e('channel attack.sfx')
+.play()
+.play()
+.play();
+
+//extension sfx is created for every 
+//sound loaded regards of type
+
+//TODO
+
+//add more channels
+
+		//cloning glitch fix
+		document.body.appendChild(s);
+		
+		s.addEventListener('canplaythrough', function(e){
+			
+			//multiple channels will allow the sound to be played more at the sametime.
+			//this will load the sound multiple times sadly FIX
+			for(var i=0; i<re.load.maxChannels-1; i++){
+				channels.push(s.cloneNode(true));
+			}
+			
+			if(that._p){
+				that._p.call(that, that.current, that.total, a);
+			}
+			
+			if(that.current >= that.total){
+				
+				if(that._s){
+					that._s.call(that, that.assets);
+				}
+				
+			}
+			
+		}, false);
+*//*
+re.channel = re.c('channel')
+.require('sound')
+.inherit({
+	volume:1,
+	max:3
+})
+.extend({
+
+	play:function(loop){
+		if(!this.channels || !re.sound.enabled) return this;
+		
+		var c;
+		for(var i=0; i<this.channels.length; i++){
+			
+			c = this.channels[i];
+			if(c.ended || !c.currentTime){
+				//play new channel
+				c.play();
+				break;
+			} else if(i == this.channels[i].length-1){
+				c.currentTime = 0;
+				c.play();
+			}
+			
+		}
+		
+		if(loop){
+			
+			var l = 0;
+			
+			c.addEventListener('ended', function(){
+				
+				if(loop == -1 || l >= loop){
+					this.currentTime = 0;
+					l++;
+				}
+				
+			}, false);
+			
+		}
+		
+		return this;
+	},
+	
+	stop:function(){
+		
+		//stop all channels
+		
+	}
+	
+});*/

data/src/entityjs/media/playlist.js

@@ -0,0 +1,5 @@
+/*
+The playlist component allows you to play background music during a game.
+It has methods for adding tracks and playing through them.
+*/
+re.c('playlist');

data/src/entityjs/media/sound.js

@@ -0,0 +1,110 @@
+/*
+The sound component utilizes the new HTML5 to play sound effects in the web browser.
+It is reccommended to load two sound codecs OGG and AAC because not every browser supports
+all sound codecs at this time.
+
+//load a sound
+re.load('run.ogg run.aac');
+//BAD this will load both sounds. Even if the browser might not support one
+
+//GOOD. load just one codec of the sound
+var codec;
+if(re.support('ogg')){
+	codec = 'ogg';
+} else if(re.support('aac')){
+	codec = 'aac';
+}
+
+re.load('run.'+codec');
+
+//create sound
+re.e('sound run.'+codec);
+
+//that is a pain, so a helper method has been created
+re('sound run.'+re.support('ogg', 'aac'));
+
+Its reccomended to save the supported codec somewhere globaly
+//like so...
+re.codec = re.support('ogg', 'aac');
+
+re.load('run.'+re.codec);
+
+re.e('run.'+re.codec);
+
+WARNING: Because the sound component has generic
+method names stop, play, watchout for overwrites.
+
+Sound Tip
+//find all sounds in game and play them all!
+re('sound').method('play');
+
+
+*/
+re.sound = re.c('sound')
+.global({
+	
+	enabled:true
+	
+})
+.namespace({
+	
+	hasEvent:false,
+	loops:0
+	
+})
+.extend({
+
+	play:function(loop){
+		if(!this.sound || !re.sound.enabled) return this;
+		
+		var c = this.sound;
+		var that = this;
+		
+		c.currentTime = 0;
+	
+		c.play();
+		
+		if(loop){
+			
+			this.sound_loops = 0;
+			
+			if(!this.sound_hasEvent){
+				this.sound_hasEvent = true;
+				
+				c.addEventListener('ended', function(){
+					
+					that.signal('sounded', that.sound_loops, loop);
+					
+					if(loop == -1 || that.sound_loops < loop){
+						c.currentTime = 0;
+						that.sound_loops++;
+					}
+					
+				}, false);
+			}
+			
+		}
+		
+		return this;
+	},
+	
+	resume:function(){
+		this.sound.play();
+		return this;
+	},
+	
+	pause:function(){
+		this.sound.pause();
+		
+		return this;
+	},
+	
+	currentTime:function(){
+		return this.sound.currentTime;
+	},
+	
+	ended:function(){
+		return this.sound.ended;
+	}
+	
+});