entityjs 0.2.2

data/lib/entityjs/game.rb

@@ -0,0 +1,93 @@
+module Entityjs
+  
+  class Game
+    
+    def self.generate(name, comps=[])
+      @root = name
+      
+      #create directory
+      self.create_dir(name)
+      
+      Dir.chdir(Dir.pwd+'/'+name)
+      
+      #create html file
+      create_file('play.html')
+      
+      create_file('config.yml')
+      
+      #create lib
+      self.create_dir('lib')
+      
+      #create src directory
+      self.create_dir('src')
+      
+      Dir.chdir(Dir.pwd+'/src')
+      
+      self.create_file('init.js')
+      
+      self.create_dir('display')
+      
+      self.create_dir('plugins')
+      
+      self.create_dir('scenes')
+      
+      Dir.chdir(Dir.pwd+'/scenes')
+      self.create_file('load.js')
+      self.create_file('home.js')
+      
+      #create assets
+      Dir.chdir(Dir.pwd+'/../..')
+      
+      self.create_dir('assets')
+      
+      Dir.chdir(Dir.pwd+'/assets')
+      
+      self.create_dir('sounds')
+      
+      self.create_dir('images')
+      
+      self.create_dir('levels')
+      
+      #create test directory
+      Dir.chdir(Dir.pwd+'/..')
+      self.create_dir('tests')
+      
+      Dir.chdir(Dir.pwd+'/tests')
+      
+      self.create_dir('scenes')
+      self.create_dir('display')
+      
+      Entityjs::Command.run('comp', comps)
+      
+      Entityjs::Command.run('refresh')
+      
+      return true
+    end
+    
+    def self.create_file(name)
+      template = File.expand_path(File.dirname(__FILE__) + '/../blank/'+name)
+      FileUtils.cp template, name
+      
+      path = "/#{name}"
+      
+      cut = Dir.pwd.split(@root)
+      
+      if cut.length == 2
+        path = cut.pop+path
+      end
+      
+      puts "Created: #{path}"
+    end
+    
+    def self.create_dir(name)
+      begin
+        Dir::mkdir(name)
+        puts "Created: /#{name}"
+      rescue
+        puts "Directory: /#{name} already exists!"
+      end
+    end
+    
+  end
+  
+end

data/lib/entityjs/min.rb

@@ -0,0 +1,11 @@
+module Entityjs
+  
+  class Min
+    
+    def self.generate()
+      
+    end
+    
+  end
+  
+end

data/lib/entityjs/refresh.rb

@@ -0,0 +1,14 @@
+module Entityjs
+  
+  class Refresh
+    
+    def self.generate(args=nil)
+      
+      
+      
+      puts 'Refreshed debug.js'
+    end
+    
+  end
+  
+end

data/lib/entityjs/version.rb

@@ -0,0 +1,3 @@
+module Entityjs
+  VERSION = "0.2.2"
+end

data/lib/entityjs.rb

@@ -0,0 +1,6 @@
+require "entityjs/version"
+
+module Entityjs
+  
+  
+end

data/license.txt

@@ -0,0 +1 @@
+/* EntityJS v$VERSION http://entityjs.com | License http://entityjs.com/license */

data/spec/lib/entityjs/game_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe 'game' do
+  
+  it 'should generate game mygame' do
+    
+    Entityjs::Game.generate('mygame').should == true
+    
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+root = File.dirname(__FILE__)+'/../'
+
+Dir[root+"lib/entityjs/*.rb"].each {|file| require file }

data/src/entityjs/core/component.js

@@ -0,0 +1,306 @@
+
+	/*
+	Quick way to convert sentences to arrays.
+	*/
+	var __z = function(n, r){
+        this._checkFinal();
+		
+		if(!this[n]){
+			this[n] = [];
+		}
+		
+		if(typeof r == 'string'){
+			this[n] = this[n].concat(r.split(' '));
+		} else {
+			this[n] = this[n].concat(r);
+		}
+		
+		return this;
+	};
+	
+    /*
+	If component exists, the component will NOT be overwritten.
+	
+	@return component reference
+	*/
+	re.comp = re.c = function(title){
+		
+		if(!re._c[title]){
+			re._c[title] = new re.comp.init(title);
+		}
+		
+		return re._c[title];
+	};
+	
+	re.comp.init = function(name){
+		
+		this.name = name;
+		this._re_signals = {};
+		this._re_inherits = {};
+		this._re_extends = {};
+		this._re_final = false;
+	};
+	
+	/*
+	p._re_requires = null;
+	
+	p._re_init = null;
+	
+	p._re_dispose = null;
+	
+	p._re_asserts = null;
+	
+	p._re_interface = null;
+	*/
+	
+re.comp.init.prototype = {
+	
+    _checkFinal:function(){
+        
+        if(this._re_final){
+            throw this.name+' is final.';
+        }
+    },
+    
+	global:function(obj, value){
+        this._checkFinal();
+        
+		if(arguments.length == 1){
+			
+			for(var type in obj){
+				this[type] = obj[type];	
+			}
+			
+		} else {
+			this[obj] = value;	
+		}
+		
+		return this;
+	},
+	
+	
+	require:function(r){
+		return __z.call(this, '_re_requires', r);
+	},
+	
+	/*
+	Upon component init it will throw an error 
+	if one of the listed components exist.
+	
+	This prevents incompatible components from colliding.
+	*/
+	assert:function(r){
+		return __z.call(this, '_re_asserts', r);
+	},
+	
+	/*
+	The implement method checks and enforces implmentation
+	of the given keys. This can create interface components
+	for organization and query searches.
+	
+	Forcing an interface on components will allow instant
+	runtime errors and save time.
+	
+	//reccommended to put an i infront to represent an interface
+	re.c('ienemy')
+	//create an enemy interface
+	.interface('moveTo spawn attack runAway');
+	
+	*/
+	implement:function(r){
+		return __z.call(this, '_re_implments', r);
+	},
+    
+	/*
+	Creates new names for a component.
+	
+	//create a new alias of draw
+	re.c('draw')
+	.alias('bob');
+	
+	//remove alias
+	re.c('draw')
+	.alias('-bob');
+	
+	//aliases can even delete components itself
+	re.c('draw').alias('-draw');
+	
+	//add two aliases
+	re.c('draw').alias('dr bob');
+	
+	*/
+	alias:function(s){
+        this._checkFinal();
+        
+        var p = s.split(' ');
+		
+		if(p.length > 1){
+			
+			for(var i in p){
+				this.alias(p[i]);	
+			}
+			
+			return this;	
+		}
+		
+		if(s.charAt(0) == '-'){
+			//only remove if its a reference
+			if(re._c[s.substr(1)] == this){
+				delete re._c[s.substr(1)];
+			}
+		} else {
+		
+			re._c[s] = this;
+		}
+		
+		return this;
+	},
+	
+	addSignal:function(){
+		return re.e.init.prototype.addSignal.apply(this, arguments);
+	},
+	
+	removeSignal:function(){
+		return re.e.init.prototype.removeSignal.apply(this, arguments);
+	},
+	
+	/*
+	Adds signal functionality to components.
+	All components will automatically call two signals, init and dispose.
+	
+	Init on entity creation and dispose on entitiy disposition.
+	
+	This is useful for 'watch tower' components that keep a list of
+	all entities that have its component. Check the cycle directory.
+	
+	*/
+	signal:function(){
+		return re.e.init.prototype.signal.apply(this, arguments);
+	},
+	
+	/*
+	Default adds onto but doesn't overwrite values.
+	*/
+	inherit:function(d, value){
+        this._checkFinal();
+        
+		if(arguments.length == 1){
+			
+			for(var k in d){
+				this._re_inherits[k] = d[k];	
+			}
+			
+		} else {
+			
+			this._re_inherits[d] = value;
+				
+		}
+		
+		return this;
+	},
+	
+    /*
+    The namespace method is used to put private component variables
+    in its own space. This prevents unwanted overrites.
+    
+    re.c('draw')
+    .namespace({
+    pos:0,
+    type:'none'
+    
+    });
+    
+    //or
+    re.c('draw')
+    .namespace("pos", 0);
+    
+    //Will cast to 
+    this.draw_pos = 10;
+    this.draw_type = 'none';
+    
+    */
+    namespace:function(obj, value){
+        this._checkFinal();
+        var name = this.name+'_';
+        
+        if(arguments.length == 1){
+        
+            for(var k in obj){
+            	this._re_extends[name+k] = obj[k];
+            }
+        
+        } else {
+            this._re_extends[name+obj] = value;
+        }
+        
+        return this;
+    },
+    
+	/*
+	extend overrides everything.
+	*/
+	extend:function(d, value){
+        this._checkFinal();
+        
+		if(!this._re_extends){
+			this._re_extends = {};
+		}
+		if(arguments.length == 1){
+			
+			for(var k in d){
+				this._re_extends[k] = d[k];	
+			}
+			
+		} else {
+			this._re_extends[d] = value;
+		}
+		
+		return this;	
+	},
+	
+	init:function(method){
+        this._checkFinal();
+        
+        this._re_init = method;
+		
+		return this;	
+	},
+	
+	dispose:function(method){
+        this._checkFinal();
+        
+        this._re_dispose = method;
+		
+		return this;	
+	},
+	
+	/*
+	The lock method prevents modification to the component.
+	
+	This is handy to stop unexpected changes to a component.
+	*/
+	lock:function(){
+        this._checkFinal();
+		
+        this._re_final = true;
+		
+		return this;
+	},
+	
+	/*
+	The run method allows a function to be ran in the context
+	of the component.
+	
+	Useful to keep everything in one big component.
+	*/
+	run:function(method){
+		this._checkFinal();
+		
+		//re.ready(function(){
+			method.call(this);
+		//});
+		
+		return this;
+	}
+	
+};