entityjs 0.2.2 → 0.3.0

data/src/core/system.js

@@ -0,0 +1,121 @@
+/*
+The system component contains all information and references to the entity js engine.
+Such as the canvas context, fps, start, stop, canvas.
+
+You can add the component to entities for quick reference to variables.
+
+FUTURE
+-add entity definess to allow local usage.
+-perhaps allow users to override the system class for their own custom usage. (new arrays of entities and components)
+*/
+re.c('system')
+.defaults({
+    
+    clearColor:'#f9f9f9',
+    
+    stepSize:0.03,
+    maxTick:0.05,
+    
+    running:false,
+    
+    sizeX:10,
+    sizeY:10
+    
+})
+.defines({
+    
+    clear:function(color){
+        
+        if(color){
+            this.context.fillStyle = color;
+            this.context.fillRect(0, 0, this.sizeX, this.sizeY);
+        } else {
+            this.context.clearRect(0, 0, this.sizeX, this.sizeY);
+        }
+        
+        return this;
+    },
+    
+    start:function(){
+        if(!this.running){
+            this.running = true;
+            
+            var that = this;
+            (function m(){
+              
+              that.system_loop();
+              if(that.running){
+                that.requestAnimationFrame(m, that.canvas);
+              }
+            })();
+            
+        }
+        
+        return this;
+    },
+    
+    loop:function(m){
+        
+        this.system_loop = m;
+    
+        return this;
+    },
+    
+    stop:function(){
+        this.running = false;
+        return this;
+    },
+    
+    //scale is currently not implemented!
+    init:function(canvasId, scale, contextType){
+        //init listeners
+        if(re._c.keyboard){
+          re._c.keyboard.i();
+        }
+        if(re._c.mouse){
+          re._c.mouse.i();
+        }
+        if(re._c.touch){
+          re._c.touch.i();
+        }
+        
+        //add comps here because system is defined earlier than other comps
+        this.comp('polyfill tick timestep');
+        
+        //setup canvas
+        this.canvas = re.$(canvasId);
+        
+        this.scale = scale || 1;
+        
+        this.context = this.canvas.getContext(contextType || '2d');
+        var s = re.screen = re.e('screen');
+        
+        this.sizeX = s.sizeX = this.canvas.width;
+        this.sizeY = s.sizeY = this.canvas.height;
+        
+        return this;
+    },
+    
+    /*
+    Default main loop
+    */
+    system_loop:function(){
+        
+        this.timestep(Math.min(this.tick() / 1000, this.maxTick), function(){
+            //update
+            re._c.update.update(this.stepSize);
+        });
+        
+        //clear
+        this.clear(this.clearColor);
+        re._c.draw.draw(this.context);
+    }
+    
+    
+})
+.run(function(){
+    
+    //create default system
+    re.system = re.sys = re.e('system');
+    
+});

data/src/cycle/draw.js

@@ -0,0 +1,178 @@
+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);
+    
+})
+.dispose(function(c){
+    
+    c.l.splice(c.l.indexOf(this), 1);
+    
+})
+.defaults({
+    screenable:true,
+    drawable:true,
+    rotation:0,
+    alpha:1,
+    
+    scaleX:1,
+    scaleY:1,
+    
+    posX:0,
+    posY:0,
+    
+    sizeX:10,
+    sizeY:10,
+    
+    regX:0,
+    regY:0
+    
+})
+.defines({
+    
+    cache:function(){
+        if(!this.image) return this;
+        
+        this.clearCache();
+        
+        var c = re.$new('canvas');
+        var s = Math.max(this.image.width, this.image.height);
+        c.width = s;
+        c.height = s;
+        
+        this.draw_render(c.getContext(re.sys.contextType));
+        
+        this.canvasCache = c;
+        
+        return this;
+    },
+    
+    clearCache:function(){
+        this.canvasCache = null;
+    },
+    
+    drawFirst:function(){
+        var l = re.c('draw').l;
+        
+        l.splice(l.indexOf(this), 1);
+        
+        l.unshift(this);
+        return this;
+    },
+    
+    drawLast:function(){
+        var l = re.c('draw').l;
+        
+        l.splice(l.indexOf(this), 1);
+        
+        l.push(this);
+        return this;
+    },
+    
+    drawAfter:function(en){
+        var l = re.c('draw').l;
+        var him = l.indexOf(en);
+        var me = l.indexOf(this);
+        
+        if(him > me){
+            //swap
+            var t = l[him];
+            l[him] = l[me];
+            l[me] = t;
+        }
+        
+        return this;
+    },
+    
+    drawBefore:function(en){
+        
+        var l = re.c('draw').l;
+        var him = l.indexOf(en);
+        var me = l.indexOf(this);
+        
+        if(him < me){
+            //swap    
+            var t = l[him];
+            l[him] = l[me];
+            l[me] = t;
+        }
+        
+        return this;
+    },
+    
+    screenX:function(x){
+        if(x){
+            this.posX = x + re.screen.posX;
+            return this;
+        }
+        return this.posX - re.screen.posX;
+    },
+    
+    screenY:function(y){
+        if(y){
+            this.posY = y + re.screen.posY;
+            return this;
+        }
+        return this.posY - re.screen.posY;
+    },
+    
+    /*
+    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);
+        
+    }
+    
+})
+.namespaces({
+    
+    render:function(c){
+        
+        this.draw_before(c);
+            this.draw(c);
+        this.draw_after(c);
+    },
+    
+    before:function(c){
+        
+        c.save();
+        
+        if(this.alpha != 1)
+            c.staticsAlpha = this.alpha;
+        
+      if(this.screenable)
+        c.translate(this.screenX(), this.screenY());
+      else
+        c.translate(this.posX, this.posY);
+        
+        if(this.rotation)
+            c.rotate(this.rotation * Math.PI / 180);
+        
+        
+        if(this.scaleX != 1 || this.scaleY != 1)
+            c.scale(this.scaleX, this.scaleY);
+        
+    },
+    
+    after:function(c){
+        c.restore();
+    }
+    
+});

data/src/cycle/tick.js

@@ -0,0 +1,25 @@
+/*
+The tick component is a stop watch cyclier. It will return the milliseconds in time
+between tick() calls.
+
+var tick = re.e('tick');
+//wait 200 milliseconds
+tick.tick(); //200
+//wait 10 milliseconds
+tick.tick(); //10
+*/
+re.c('tick')
+.init(function(){
+	this.lastTime = Date.now();
+})
+.defines({
+
+	tick:function(){
+		var wall = Date.now();
+		var last = this.lastTime;
+		this.lastTime = wall;
+    
+		return wall - last;
+	}
+	
+});

data/src/{entityjs/cycle → cycle}/tween.js

@@ -1,61 +1,61 @@
-/*
-The tween component tweens properties of entities to the given value over a period of time.
-
-This is useful for animations.
-
-re.e('tween')
-.tween(0.8, {x:10});
-
-*/
-re.c('tween')
-.require('update')
-.global({
-	
-	tween:function(obj, time, props){
-		return obj.comp('tween')
-		.tween(time, props);
-	}
-	
-})
-.namespace({
-
-	update:function(t){
-		
-		
-		
-	}
-
-})
-.inherit({
-	
-	tweening:false
-	
-})
-.extend({
-	
-	tween:function(time, props){
-		this.time = time || 5;
-		
-		if(this.tweening){
-			this.removeSignal('update', this.tween_update);
-		}
-		
-		//collect properties
-		for(var i in props){
-			
-			if(!props.hasOwnProperty(i)) continue;
-			
-			this.tween_props[i] = {s:re.sys.stepSize, i:props[i]};
-			
-		}
-		
-		return this;
-	}
-	
-})
-.init(function(){
-	
-	this.tween_props = {};
-	
-});
+/*
+The tween component tweens properties of entities to the given value over a period of time.
+
+This is useful for animations.
+
+re.e('tween')
+.tween(0.8, {x:10});
+
+*/
+re.c('tween')
+.requires('update')
+.statics({
+	
+	tween:function(obj, time, props){
+		return obj.comp('tween')
+		.tween(time, props);
+	}
+	
+})
+.namespaces({
+
+	update:function(t){
+		
+		
+		
+	}
+
+})
+.defaults({
+	
+	tweening:false
+	
+})
+.defines({
+	
+	tween:function(time, props){
+		this.time = time || 5;
+		
+		if(this.tweening){
+			this.unbind('update', this.tween_update);
+		}
+		
+		//collect properties
+		for(var i in props){
+			
+			if(!props.hasOwnProperty(i)) continue;
+			
+			this.tween_props[i] = {s:re.sys.stepSize, i:props[i]};
+			
+		}
+		
+		return this;
+	}
+	
+})
+.init(function(){
+	
+	this.tween_props = {};
+	
+});
 re.tween = re.c('tween').tween;

data/src/{entityjs/cycle → cycle}/update.js

@@ -1,86 +1,87 @@
-/*
-The update component calls update signals to all listening entities.
-*/
-re.c('update')
-.global({
-	listeners:[],
-	update:function(s,t){
-		var l = this.listeners;
-		
-		for(var k=0, le = l.length, b; k < le; ++k){
-			b = l[k];
-			
-			if(b && b.sys == s && b.updating){
-				b.signal('update', t, s.time);
-			}
-		}
-		
-	}
-})
-.inherit({
-	updating:true,
-	sys:re.sys
-})
-.extend(function(){
-	
-	var l = re.c('update').listeners;
-	
-	return {
-	updateFirst:function(){
-		
-		l.splice(l.indexOf(this), 1);
-		
-		l.unshift(this);
-		
-		return this;
-	},
-	
-	updateLast:function(){
-		
-		l.splice(l.indexOf(this), 1);
-		
-		l.push(l);
-		
-		return this;
-	},
-	
-	updateAfter:function(e){
-		
-		var him = l.indexOf(e);
-		var me = l.indexOf(this);
-		
-		if(him > me){
-			//swap
-			var t = l[him];
-			l[him] = l[me];
-			l[me] = t;
-		}
-		
-		return this;
-	},
-	
-	updateBefore:function(e){
-		
-		var him = l.indexOf(e);
-		var me = l.indexOf(this);
-		
-		if(him < me){
-			//swap	
-			var t = l[him];
-			l[him] = l[me];
-			l[me] = t;
-		}
-		
-		return this;
-	}
-	
-	};
-	
-}())
-.init(function(c){
-	c.listeners.push(this);
-})
-.dispose(function(c){
-	
-	c.listeners.splice(c.listeners.indexOf(this), 1);
+/*
+The update component calls update signals to all listening entities.
+*/
+re.c('update')
+.statics({
+	l:[],
+	update:function(t){
+		var l = this.l;
+		
+		for(var k=0, b; k<l.length; k++){
+			b = l[k];
+      
+			if(b && b.updatable){
+        b.trigger('update', t);
+      }
+      
+		}
+		
+	}
+})
+.defaults({
+	updatable:true
+})
+.defines(function(){
+	
+	var l = re.c('update').l;
+	
+	return {
+  
+	updateFirst:function(){
+		
+		l.splice(l.indexOf(this), 1);
+		
+		l.unshift(this);
+		
+		return this;
+	},
+	
+	updateLast:function(){
+		
+		l.splice(l.indexOf(this), 1);
+		
+		l.push(this);
+		
+		return this;
+	},
+	
+	updateAfter:function(e){
+		
+		var him = l.indexOf(e);
+		var me = l.indexOf(this);
+		
+		if(him > me){
+			//swap
+			var t = l[him];
+			l[him] = l[me];
+			l[me] = t;
+		}
+		
+		return this;
+	},
+	
+	updateBefore:function(e){
+		
+		var him = l.indexOf(e);
+		var me = l.indexOf(this);
+		
+		if(him < me){
+			//swap	
+			var t = l[him];
+			l[him] = l[me];
+			l[me] = t;
+		}
+		
+		return this;
+	}
+	
+	};
+	
+}())
+.init(function(c){
+	c.l.push(this);
+})
+.dispose(function(c){
+	
+	c.l.splice(c.l.indexOf(this), 1);
 });

data/src/{entityjs/cycle → cycle}/wait.js

@@ -1,22 +1,23 @@
-/*
-The wait component delays function calls.
-*/
-re.c('wait')
-.require('update')
-.extend({
-	
-	wait:function(time, callback){
-		var c = 0;
-		
-		this.addSignal('update',  function(t){
-			c += t;
-			
-			if(c >= time){
-				this.callback.apply(this, Array.prototype.slice.call(arguments, 2));
-				return false;
-			}
-		});
-		
-	}
-	
+/*
+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;
+			}
+		});
+		
+    return this;
+	}
+	
 });

data/src/{entityjs/cycle → cycle}/worker.js

@@ -1,9 +1,9 @@
-/*
-The worker component will contain an interface for the new HTML5 webworker.
-
-TODO
-*//*
-re.c('worker')
-.init(function(){
-	throw 'Not implemented';
+/*
+The worker component will contain an interface for the new HTML5 webworker.
+
+TODO
+*//*
+re.c('worker')
+.init(function(){
+	throw 'Not implemented';
 });*/