entityjs 0.2.2 → 0.3.0

data/src/core/load.js

@@ -0,0 +1,242 @@
+(function(re){
+    
+    var b = function(assets){
+        return new re.load.init(assets);    
+    }
+    
+    b.path = "";
+    
+    b.imageExt = 'img';
+    b.soundExt = 'sfx';
+    b.images = ['gif', 'jpg', 'jpeg', 'png'];
+    b.sounds = ['wav', 'mp3', 'aac', 'ogg'];
+    
+    /*
+    Loads images, sounds and other files into components.
+    
+    All loaded assets will be put into a component with a ref to the asset.
+    
+    //example of loading assets
+    re.load('tiles.png add.js attack.mp3')
+    .complete(function(arrayOfAssets){
+        //create new bitmap of tiles.png
+        re.e('bitmap tiles.png');
+        
+        //new sound
+        re.e('sound attack.mp3');
+        
+        //access image staticaly or localy
+        re.comp('tiles.png').image;
+        re.entity('tiles.png').image;
+        
+    })
+    .error(function(assetThatCausedError){
+        //error
+    })
+    .progress(function(current, total, assetLoaded){
+        //called on loads
+    });
+    
+    @warning only supports loading images and sounds
+    
+    //load sound
+    
+    //re.support will return the supported codec
+    re.load('run.'+re.support('ogg', 'aac'));
+    
+    FUTURE remove directories from calls
+    
+    */
+    var l = function(assets){
+        
+        if(re.is(assets,'string')){
+          this.assets = assets.split(' ');
+          
+        } else if(re.is(assets,'object')){
+          this.assets = [];
+          for(var i in assets){
+            
+            if(assets.hasOwnProperty(i) && re.is(assets[i], 'array')){
+              this.assets = this.assets.concat(assets[i]);
+            }
+            
+          }
+        } else {
+          
+          this.assets = assets;
+        }
+        
+        var a;
+        for(var i=0; i<this.assets.length; i++){
+            
+            this.total++;
+            
+            a = this.assets[i];
+            
+            //copy full source path
+            var s = a;
+            
+            //remove directories
+            var d = a.lastIndexOf('/');
+            if(d != -1){
+                a = a.substr(d+1, a.length);
+            }
+            
+            //find file extension
+            var j = a.lastIndexOf('.')+1;
+            var ext = a.substr(j).toLowerCase();
+            
+            //find name
+            var n = a.substr(0, j);
+            
+            if(re.load.images.indexOf(ext) != -1){
+
+                this._loadImg(s, a, n);
+                
+            } else if(re.load.sounds.indexOf(ext) != -1){
+                
+                //check if support component exists first
+                if(!re.support || re.support(ext)){
+                  //don't load the same sound twice
+                  if(re._c[n+re.load.soundExt]){ 
+                    //remove from array
+                    this.total--;
+                    this.assets.splice(i, 1); 
+                    continue; 
+                  }
+                  
+                    this._loadSound(s, a, n);
+                }
+                
+            }
+            
+            
+        }
+        
+        return this;
+    }
+    
+    var p = l.prototype;
+    
+    p.current = 0;
+    p.total = 0;
+    
+    p._loadImg = function(src, a, n){
+        var that = this;
+        var img = new Image();
+        
+        //create new image component
+        re.c(a)
+        .alias(n+re.load.imageExt)
+        .statics({
+            image:img
+        })
+        .defines({
+            //save image for other components to copy or use
+            _image:img
+        });
+        
+        img.onload = function(){
+          re.c(a).defaults({
+            sizeX:img.width,
+            sizeY:img.height
+            })
+            .defines('bisect', img.width);
+            
+          that._loaded();
+        };
+        
+        img.onerror = function(){
+            
+            if(that._e){
+                that._e.call(that, a);
+            }
+            
+        };
+        
+        img.src = re.load.path+src;
+        
+        return this;
+    };
+    
+    p._loaded = function(){
+      this.current++;
+      
+      if(this.current <= this.total){
+        if(this._p){
+            this._p(this.current, this.total, this.assets[this.current-1]);
+        }
+      }
+      if(this.current == this.total){
+          if(this._s){
+            this._s(this.assets);
+          }
+        }
+    };
+    
+    p._loadSound = function(src, a, n){
+        var that = this;
+        
+        var s = new Audio(re.load.path+src);
+        s.src = re.load.path+src;
+        s.preload = "auto";
+        s.load();
+        
+        re.c(a)
+        //create statics codec for easy use
+        .alias(n+re.load.soundExt)
+        .statics({
+            sound:s
+        })
+        .defines({
+            _sound:s
+        });
+        
+        //s.addEventListener('load',function(){that._loaded()}, false);
+        //called multiple times in firefox
+        var f = function(){
+          that._loaded();
+          //remove after first call
+          s.removeEventListener('canplaythrough', f);
+          };
+          
+        s.addEventListener('canplaythrough',f,false);
+        
+        s.addEventListener('error',function(){
+            
+            if(that._e){
+                that._e.call(that, a);
+            }
+        },false);
+        
+    }
+    
+    p.progress = function(m){
+        
+        this._p = m;
+        
+        return this;
+    }
+    
+    p.complete = function(m){
+        
+        this._s = m;
+        
+    if(this.assets.length == 0){
+      m([]);
+    }
+    
+        return this;
+    }
+    
+    p.error = function(m){
+        
+        this._e = m;
+        
+        return this;
+    }
+    
+    re.load = b;
+    re.load.init = l;
+    
+}(re));

data/src/core/query.js

@@ -0,0 +1,354 @@
+(function(re){
+    
+    /*
+    Searches through all entities using the selector conditions
+    
+    //identifiers
+    * identifies all
+    ^ identifies a bind
+    # identifies an id
+    ! identifies not
+    
+    //select all entities
+    re('*');
+    
+    //select all entities with 2d and ai components
+    re('2d ai');
+    
+    //select all 2d entities without the monster component
+    re('2d -monster');
+    
+    //select all draw entities and entities with the id equal to asset
+    re('draw #asset')
+    //returns a random entity
+    .random();
+    
+    //select all entities with id of bob and player
+    //warning you cannot query for two ids
+    re('#bob player')
+    //takes values from all objects and returns an array
+    .pluck('width height');
+    
+    //find all bitmap entities with update bind.
+    re('bitmap ^update');
+    
+    //add color comp to all text components
+    re('text').comp('color');
+    
+    //custom entity search
+    re(function(index){
+        
+        if(entity.has('health') && entity.health > 0){
+            //add to query
+            return true;
+        }
+        
+        //skip entity
+        return false;
+    })
+    //calls reset method on all entities
+    .method('reset');
+    
+    //returns direct reference to first entity with id of player
+    re('#player').health = 100;
+    
+    */
+    var q = function(selector){
+        
+        if(selector){
+            this.query(selector);
+        }
+    }
+    
+    /*
+    Sort a query string into objects
+    */
+    q._toObj = function(query){
+        if(q.c[query]){
+            return q.c[query];
+        }
+        
+        //convert to object
+        var temp = query.split(' ');
+        var comps = [];
+        var binds = [];
+        var minus = [];
+        var id = '';
+        
+        //split string
+        var fl;
+        var val;
+        for(var j = temp.length; j--;){
+            fl = temp[j].charAt(0);
+            val = temp[j].substr(1);
+            
+            if(fl == '^'){
+                binds.push(val);
+            } else if(fl == '!'){
+                minus.push(val);
+            } else if(fl == '#'){
+                id = val;
+            } else {
+                comps.push(temp[j]);
+            }
+        }
+        
+        var comp = {
+            comp:comps,
+            on:binds,
+            not:minus,
+            id:id
+        };    
+        
+        q.c[query] = comp;
+        
+        return comp;
+    }
+    
+    q.c = {};
+    
+    var p = q.prototype = new Array;
+    
+    p.query = function(select){
+        select = select || '';
+        var l = re._e.length, i = -1, e;
+        
+        if(re.is(select, 'string')){
+            
+            if(select == '*'){
+                
+                this.push.apply(this, re._e.slice());
+                
+                return this;
+            }
+            
+            //optimize search and cache
+            var obj = q._toObj(select);
+            
+            while(++i < l && (e = re._e[i])){
+                if(e.has(obj)) this.push(e);
+            }
+            
+        } else if(re.is(select, 'function')){
+            
+            while(++i < l && (e = re._e[i])){
+               if(select.call(e, i, l)) this.push(e);
+            }
+            
+        }
+        
+        return this;
+    }
+    
+    /*
+    Calls the given method name on all entities.
+    
+    re('enemies').method('rest');
+    */
+    p.method = function(m){
+        var b = Array.prototype.slice.call(arguments, 1);
+        return this.each(function(){
+        
+            this[m].apply(this, b);
+        });
+        
+    }
+    
+    /*
+    example
+    re('draw').each(function(index, length){
+        
+    });
+    
+    returning false will break the loop
+    */
+    p.each = function(m){
+        var l = this.length, i = -1, e;
+        
+        while(++i < l && (e = this[i]) && m.call(e, i, l) !== false);
+        
+        return this;
+    }
+    
+    /*
+    The map method allows multidimensional loops.
+    
+    //map through and increase y every 3 entities.
+    
+    re('draw').tilemap(3, function(x, y){
+        this.x(x * width);
+        this.y(Y * height);
+    });
+    
+    //so instead of getting this back
+    [e,e,e,e,e...]
+    
+    //you will get this
+    [
+    [e,e,e],
+    [e,e,e],
+    [e,e,e]
+    ...
+    ]
+    
+    returning false will break the loop
+    
+    */
+    p.tilemap = function(w, method){
+        var x = 0;
+        var y = 0;
+        
+        return this.each(function(i, l){
+            
+            if(method.call(this[i], x, y, i, l) == false) return false;
+            
+            x++;
+            
+            if(x == w){
+                x = 0;
+                y++;    
+            }
+        });
+    }
+    
+    /*
+    Returns an array of all components in the query.
+    */
+    p.comps = function(){
+        var l = [];
+        
+        this.each(function(){
+          var k = this.comps();
+          for(var i=0; i<k.length; i++){
+            if(l.indexOf(k[i]) == -1){
+              l.push(k[i])
+            }
+          }
+        });
+        
+        return l;
+    }
+    
+    /*
+    Returns a random entity.
+    */
+    p.random = function(){
+        return this[~~(Math.random()*this.length)];
+    }
+    
+    /*
+    The pluck method returns all values from all entities in an array.
+    
+    //will return all pos objs from all entities.
+    re('point').pluck('pos visible');
+    
+    //if we print...
+    
+    [
+    {pos:0, visible:0}
+    ...
+    ]
+    
+    */
+    p.pluck = function(value){
+        var t = [];
+        
+        var k = value.split(' ');
+        
+        this.each(function(){
+            var o = {};
+            
+            for(var p in k){
+                if(k.hasOwnProperty(p)){
+                    o[k[p]] = this[k[p]];
+                }
+            }
+            
+            t.push(o);
+            
+        });
+        
+        return t;
+    }
+    
+    p.defines = function(){
+      throw 'Deprecated use attr'
+    }
+    
+    p.attr = function(obj, value){
+        return this.each(function(){
+            this.attr(obj,value);
+        });
+        
+    }
+    
+    p.defaults = function(){
+      throw 'Deprecated use def'
+    }
+    
+    p.def = function(obj, value){
+        return this.each(function(){
+            this.def(obj, value);
+        });
+        
+    }
+    
+    p.comp = function(c){
+        
+        return this.each(function(ref){
+            this.comp(c);
+        });
+        
+    }
+    
+    p.removeComp = function(c){
+        return this.each(function(ref){
+          this.removeComp(c);
+        });
+    }
+    
+    p.on = function(type, method){
+        
+        return this.each(function(){
+            this.on(type,method);
+        });
+        
+    }
+    
+    p.off = function(type, method){
+        return this.each(function(){
+            this.off(type, method);
+        });
+    }
+    
+        p.trigger = function(){
+            var p = arguments;
+            return this.each(function(){
+                this.trigger.apply(this, p);
+            });
+        }
+    
+    p.has = function(comp){
+        
+        for(var i=0; i<this.length; i++){
+            if(!this[i].has(comp)){
+                return false;
+            }
+        }
+        
+        return this.length != 0;
+    }
+    
+    p.dispose = function(){
+        
+        return this.each(function(){
+            
+            this.dispose();
+            
+        });
+        
+    }
+    
+    re.query = q;
+    
+}(re));

data/src/core/re.js

@@ -0,0 +1,74 @@
+/*
+EntityJS Javascript Game Engine
+Copyright 2011, Ben D'Angelo 
+http://entityjs.com
+
+Licensed under MIT http://entityjs.com/license
+
+*/
+re = function(selector){
+    return new re.query(selector);
+};
+
+//automatically filled when compiled
+re.version = "$VERSION";
+    
+//contains all entities
+re._e = [];
+//contains all components
+re._c = {};
+
+re.ready = function(r){
+    re.ready.c.push(r);
+    
+    window.onload = function(){
+        for(var k in re.ready.c){
+            re.ready.c[k].call(re);
+        }
+    };
+};
+re.ready.c = [];
+
+/*
+The $ method is used for selecting ids and tags.
+*/
+re.$ = function(s){
+  return re.$.c[s] = re.$.c[s] || ((s.charAt(0) == '#') ? document.getElementById(s.substr(1)) : document.getElementsByTagName(s)[0]);
+};
+//caches dom queries
+re.$.c = {};
+
+re.$new = function(n){
+    return document.createElement(n);
+};
+
+/*
+Special polyfills and object additions
+*/
+re.listener = function(t, c){
+    if(window.addEventListener){
+        window.addEventListener(t, c, true);
+    } else {
+        document.attachEvent('on'+t, c);
+    }
+};
+
+/*
+Checks the existance of a variable or 
+*/
+re.is = function(obj, type){
+  if(arguments.length==1) return obj != null;
+  
+  return obj != null && Object.prototype.toString.call(obj).slice(8, -1).toLowerCase() == type.toLowerCase();
+};
+
+if(!Array.prototype.indexOf){
+    Array.prototype.indexOf = function(o){
+        for(var i=0; i<this.length; i++){
+            if(this[i]==o){
+                return i;
+            }
+        }
+        return -1;
+    }
+}