jax 0.0.0.9 → 0.0.0.10

data/src/jax/mvc/helper.js

@@ -1,35 +0,0 @@
-/**
- * class Jax.Helper
- *
- * Jax Helpers are glorified mixins. They contain a set of methods which can then be
- * included into any Jax class.
- *
- * Defining a helper is easy, and looks a bit like this:
- *
- *     var HelloHelper = Jax.Helper.create({
- *       sayHi: function(name) { alert("Hello, "+name+"!"); }
- *     });
- *
- * Once defined, using helpers is particularly simple. In any Jax class, simply define
- * a +helpers+ function that returns an array of helpers:
- *
- *     var Liaison = Jax.Class.create({
- *       helpers: function() { return [HelloHelper]; }
- *     });
- *
- * Now the +Liaison+ class will include the +sayHi+ method which can be called just like
- * any other method:
- *
- *     var l = new Liaison();
- *     l.sayHi("World");
- *     //=> Hello, World!
- *
- **/
-Jax.Helper = {
-  instances: [],
-
-  create: function(methods) {
-    Jax.Helper.instances.push(methods);
-    return methods;
-  }
-};

data/src/jax/mvc/model.js

@@ -1,302 +0,0 @@
-/**
- * class Jax.Model
- * 
- * Models encapsulate virtually all business logic. If a Monster knows how to attack, the logic
- * that makes it do so is held within the +Monster+ model. If the terrain has trees and other
- * vegetation, the +Terrain+ model is responsible for setting that up.
- *
- * While controllers generally have only high-level code such as initial scene set-up and
- * processing of user input, models handle nearly everything else.
- *
- * Models also contain the actual game data. Jax further splits models into two components: the
- * Model itself and its Resources.
- *
- * Define a model like so:
- *
- *     var Monster = Jax.Model.create({
- *       after_initialize: function() {
- *         // code to be run automatically after a monster is instantiated
- *       },
- * 
- *       update: function(time) {
- *         // code to be run automatically every few milliseconds
- *       },
- *
- *       dealDamageTo: function(otherModel) {
- *         // custom method, called only when you invoke it
- *         otherModel.takeDamage(this.attack_damage);
- *       }
- *     });
- *
- * Once defined, you can add data easily:
- *
- *     Monster.addResources({"ogre": {
- *       hit_points: 100,
- *       attack_damage: 75
- *     }});
- *
- * You can instantiate a model whose resources already exist like so:
- *
- *     var ogre = Monster.find("ogre");
- *
- * Note that subsequent calls to +Model.find+ will return unique objects. For instance, the
- * following code will add 3 separate "ogres" to the world:
- *
- *     world.addObject(Monster.find("ogre"));
- *     world.addObject(Monster.find("ogre"));
- *     world.addObject(Monster.find("ogre"));
- * 
- **/
-(function() {
-  function initProperties(self, data) {
-    // to make sure sub-properties of data are standalone objects, so that the original data can't be tainted
-    data = Jax.Util.normalizeOptions(data, {});
-    
-    var attribute;
-        
-    if (data) {
-      for (attribute in data) {
-        switch(attribute) {
-          case 'position':    self.camera.setPosition(Jax.Util.vectorize(data[attribute])); break;
-          case 'direction':   self.camera.orient(Jax.Util.vectorize(data[attribute])); break;
-          case 'mesh':
-            if (data[attribute].isKindOf(Jax.Mesh)) self.mesh = data[attribute];
-            else throw new Error("Unexpected value for mesh:\n\n"+JSON.stringify(data[attribute]));
-            break;
-          default:
-            self[attribute] = data[attribute];
-        }
-      }
-    }
-  }
-  
-  Jax.Model = (function() {
-    return Jax.Class.create({
-      /**
-       * new Jax.Model(data)
-       * - data: a set of attributes to be assigned to this instance of the model.
-       *
-       * Anything can be in the data, or you may supply no data at all to instantiate
-       * a model with its default attributes.
-       *
-       * The following attributes have special meanings:
-       *
-       * * +position+ : sets the position of this model in world coordinates.
-       * * +direction+ : sets the direction this model is facing, in world coordinates.
-       * * +mesh+: an instance of +Jax.Mesh+
-       * * +shadow_caster+ : true or false; specifies whether this model can cast shadows.
-       * * +lit+ : true or false; specifies whether this model is affected by nearby lights.
-       *
-       **/
-      initialize: function(data) {
-        this.camera = new Jax.Camera();
-        
-        initProperties(this, Jax.Model.default_properties);
-        if (this._klass && this._klass.resources)
-          initProperties(this, this._klass.resources['default']);
-        initProperties(this, data);
-        
-        if (this.after_initialize) this.after_initialize();
-      },
-      
-      /**
-       * Jax.Model#isShadowCaster() -> Boolean
-       *
-       * Returns true if this model casts shadows upon other models in the scene. Note that
-       * even if true, shadows will only be cast upon models which utilize +Jax.Material+s that support
-       * both the +Lighting+ and +ShadowMap+ effects.
-       *
-       **/
-      isShadowCaster: function() { return this.shadow_caster; },
-
-      /**
-       * Jax.Model#render(context) -> undefined
-       * 
-       * Renders this model with the given context. If the model doesn't have a mesh,
-       * nothing is rendered.
-       **/
-      render: function(context, options) {
-        if (this.mesh)
-        {
-          var self = this;
-          context.pushMatrix(function() {
-            context.multModelMatrix(self.camera.getTransformationMatrix());
-            self.mesh.render(context, options);
-          });
-        }
-      },
-      
-      /**
-       * Jax.Model#getBoundingCube() -> Object
-       *
-       * Returns an object describing the cubic dimensions of this model.
-       * 
-       * Example:
-       *
-       *     var bounds = new Jax.Model({mesh:new Jax.Mesh.Cube()}).getBoundingCube();
-       *     // 'bounds' contains the following:
-       *     {
-       *       left: -0.5,
-       *       right: 0.5,
-       *       bottom: -0.5,
-       *       top: 0.5,
-       *       front: 0.5,
-       *       back: -0.5,
-       *       width: 1.0,
-       *       height: 1.0,
-       *       depth: 1.0
-       *     }
-       * 
-       **/
-      getBoundingCube: function() {
-        if (!this.mesh) return {left:0,right:0,bottom:0,top:0,front:0,back:0,width:0,height:0,depth:0};
-        if (!this.mesh.built) this.mesh.rebuild();
-        return this.mesh.bounds;
-      },
-      
-      /**
-       * Jax.Model#getBoundingSphereRadius() -> Number
-       *
-       * A sphere can be defined with two values: a position and a radius. A model's
-       * position is always known via its camera (see +Jax.Model#camera+).
-       *
-       * This method returns the radius of its bounding sphere. A bounding sphere is
-       * guaranteed to contain the furthest-away point from the model's position. It is less
-       * accurate than +Jax.Model#getBoundingCube+, but using it is much faster.
-       *
-       **/
-      getBoundingSphereRadius: function() {
-        var b = this.getBoundingCube();
-        return Math.max(b.width, Math.max(b.height, b.depth));
-      },
-      
-      /**
-       * Jax.Model#dispose() -> undefined
-       *
-       * Disposes of this model and its mesh.
-       *
-       * Note that both models and meshes _can_ be reused after disposal; they'll just
-       * be silently re-initialized. This means it is safe to dispose of models while
-       * they are still being used (although this is slow and not recommended if at all
-       * avoidable).
-       **/
-      dispose: function() {
-        if (this.mesh)
-          this.mesh.dispose();
-      },
-      
-      /**
-       * Jax.Model#isLit() -> Boolean
-       *
-       * Returns true if this model can be lit by other light sources. Note that even
-       * if this is true, the +Jax.Material+ used by its +Jax.Mesh+ must support the
-       * +Lighting+ effect in order to actually perform the lighting effect.
-       *
-       **/
-      isLit: function() {
-        return this.lit;
-      },
-
-      /**
-       * Jax.Model#inspect() -> String
-       * 
-       * Returns the JSON representation of the attributes in this model.
-       * Unlike JSON.stringify(), this method will omit function definitions so
-       * that only actual data elements are returned in the resulting JSON string.
-       * 
-       **/
-      inspect: function() {
-        result = {};
-        for (var i in this)
-          if (!Object.isFunction(this[i]) && i != "_klass")
-            result[i] = this[i];
-        return JSON.stringify(result);
-      }
-    });
-  })();
-  
-  var model_class_methods = {
-    /**
-     * Jax.Model.find(id) -> Jax.Model
-     * - id (String): the unique identifier of the model to be found
-     * 
-     * Finds the resource with the specified name, instantiates its model and returns it.
-     * 
-     * Note that this is a class method of the model in question, and not of Jax.Model itself.
-     * 
-     * For example, this would be correct:
-     * 
-     *     Character.find('bad_guy')
-     *     
-     * while this would be *incorrect*:
-     * 
-     *     Jax.Model.find('bad_guy')
-     *     
-     **/
-    find: function(id) {
-      for (var resource_id in this.resources) {
-        if (id == resource_id)
-          return new this(this.resources[id]);
-      }
-      throw new Error("Resource '"+id+"' not found!");
-    },
-
-    /**
-     * Jax.Model.addResources(resources) -> undefined
-     * - resources (Object): the resources to be added
-     * 
-     * Adds the resources to the specified model. These resources can then be found using
-     * Jax.Model.find(id).
-     * 
-     * Note that this is a class method of the model in question, and not of Jax.Model itself.
-     * 
-     * For example, this would be correct:
-     * 
-     *     Character.addResources({'bad_guy': {...}})
-     *     
-     * while this would be *incorrect*:
-     * 
-     *     Jax.Model.addResources({'bad_guy': {...}})
-     *     
-     **/
-    addResources: function(resources) {
-      this.resources = this.resources || {};
-      for (var id in resources)
-        if (this.resources[id]) throw new Error("Duplicate resource ID: "+id);
-        else this.resources[id] = resources[id];
-    }
-  };
-  
-  Jax.Model.default_properties = {
-    lit: true,
-    shadow_caster: true
-  };
-  
-  /**
-   * Jax.Model.create(inner) -> klass<Jax.Model>
-   * - inner (Object) - a set of methods the class will contain.
-   * Jax.Model.create(superclass, inner) -> klass<Jax.Model>
-   * - superclass (Jax.Model) - an optional superclass. Defaults to +Jax.Model+.
-   * - inner (Object) - a set of methods the class will contain.
-   * 
-   * Creates a new Jax class inheriting from Jax.Model. If a superclass is given,
-   * the model will inherit from the given superclass instead. The superclass is,
-   * in turn, expected to be a subclass of Jax.Model.
-   *
-   * Examples:
-   *
-   *     var Person = Jax.Class.create({ ... });
-   *     var Colin = Jax.Class.create(Person, { ... });
-   *
-   **/
-  Jax.Model.create = function(superclass, inner) {
-    var klass;
-    if (inner) klass = Jax.Class.create(superclass, inner);
-    else       klass = Jax.Class.create(Jax.Model, superclass);
-    
-    klass.addMethods({_klass:klass});
-
-    Object.extend(klass, model_class_methods);
-    return klass;
-  };
-})();

data/src/jax/mvc/route_set.js

@@ -1,125 +0,0 @@
-/**
- * class Jax.RouteSet
- * 
- * Manages routing for Jax. All routes are mapped through the route set, and
- * the route set is responsible for recognizing routes and dispatching them
- * to the appropriate destination.
- * 
- * A route is generally represented as a string of the form
- * "controller_name/action_name", where controller_name is the short name of
- * the controller and the action name is the action to be triggered. For
- * example, a route matching the #index action of the WelcomeController
- * would look like:
- * 
- *     "welcome/index"
- *   
- * A special case is the root route, which is always mapped to "/". This is
- * used to give Jax applications a default starting point. If omitted, it
- * will be necessary to invoke the appropriate controller manually. You
- * can do this by calling Jax.RouteSet#dispatch.
- **/
-Jax.RouteSet = (function() {
-  function set_route(self, path, route_descriptor) {
-    return self._map[path] = route_descriptor;
-  }
-  
-  function find_route(self, path) {
-    return self._map[path] || null;
-  }
-  
-  return Jax.Class.create({
-    initialize: function() {
-      this.clear();
-    },
-    
-    clear: function() {
-      this._map = {};
-    },
-
-    /**
-     * Jax.RouteSet#root(controller, actionName) -> undefined
-     * - controller (Jax.Controller): the controller that will be routed to
-     * - actionName (String): the name of the action to be invoked by this route
-     * 
-     * Note that the controller is expected to be a subclass of Jax.Controller.
-     * 
-     * Example:
-     * 
-     *     Jax.routes.root(WelcomeController, "index");
-     * 
-     **/
-    root: function() {
-      var args = [];
-      for (var i = 0; i < arguments.length; i++) args.push(arguments[i]);
-      set_route(this, "/", this.getRouteDescriptor.apply(this, args));
-    },
-    
-    /**
-     * Jax.RouteSet#map(path, controller, actionName) -> undefined
-     **/
-    map: function(path) {
-      var args = [];
-      for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
-      set_route(this, path, this.getRouteDescriptor.apply(this, args));
-    },
-    
-    getRouteDescriptor: function() {
-      var route_descriptor;
-      switch(arguments.length) {
-        case 1:
-          if (typeof(arguments[0]) == "object")
-          {
-            route_descriptor = arguments[0];
-            if (!route_descriptor.action) route_descriptor.action = "index";
-            return arguments[0];
-          }
-          else return { controller: arguments[0], action: "index" };
-        case 2: return { controller: arguments[0], action: arguments[1] };
-        case 3:
-          route_descriptor = arguments[3];
-          route_descriptor.controller = arguments[0];
-          route_descriptor.action = arguments[1];
-          return route_descriptor;
-        default: throw new Error("Invalid arguments");
-      };
-    },
-    
-    /**
-     * Jax.RouteSet#recognize_route(path) -> Object
-     * - path (String): the route path to be recognized
-     * 
-     * Recognizes the specified path, returning an object with properties
-     * 'controller' and 'action'. If the route cannot be recognized, an
-     * error is thrown.
-     **/
-    recognize_route: function(path) {
-      var route = find_route(this, path) || find_route(this, path+"/index");
-      if (!route) throw new Error("Route not recognized: '"+path+"'");
-      return route;
-    },
-
-    /**
-     * Jax.RouteSet#isRouted(path) -> Boolean
-     * - path (String): the route path to be recognized
-     * 
-     * Returns true if the specified path can be routed, false otherwise.
-     **/
-    isRouted: function(path) {
-      return !!find_route(this, path);
-    },
-
-    /**
-     * Jax.RouteSet#dispatch(path) -> Jax.Controller
-     * - path (String): the route path to be recognized
-     * 
-     * Recognizes the given path as a route and invokes its controller and action.
-     * After the controller has been invoked, the controller instance itself is
-     * returned.
-     **/
-    dispatch: function(path, context) {
-      var route = this.recognize_route(path);
-      
-      return route.controller.invoke(route.action, context);
-    }
-  });
-})();