Merge pull request phaserjs#11 from HackManiac/amd

Automatic creation of UMD wrapped variant of Phaser

Author: photonstorm

GruntFile.js

@@ -2,7 +2,7 @@ module.exports = function (grunt) {
     grunt.loadNpmTasks('grunt-typescript');
     grunt.loadNpmTasks('grunt-contrib-watch');
     grunt.loadNpmTasks('grunt-contrib-copy');
- 
+
     grunt.initConfig({
         pkg: grunt.file.readJSON('package.json'),
         typescript: {
@@ -14,18 +14,45 @@ module.exports = function (grunt) {
                 }
             }
         },
-	copy: {
-	    main: {
-	    files: [
-		{src: 'build/phaser.js', dest: 'Tests/phaser.js'}
-	    ]}
-	},
-        watch: {
+		copy: {
+			main: {
+				files: [{
+					src: 'build/phaser.js',
+					dest: 'Tests/phaser.js'
+				}]
+			},
+			amd: {
+				files: [{
+					src: 'build/phaser.js',
+					dest: 'build/phaser.amd.js'
+				}],
+				options: {
+					processContent: function(content) {
+						var replacement = [
+							'(function (root, factory) {',
+							'    if (typeof exports === \'object\') {',
+							'        module.exports = factory();',
+							'    } else if (typeof define === \'function\' && define.amd) {',
+							'        define(factory);',
+							'    } else {',
+							'        root.Phaser = factory();',
+							'  }',
+							'}(this, function () {',
+							content,
+							'return Phaser;',
+							'}));'
+						];
+						return replacement.join('\n');
+					}
+				}
+			}
+		},
+		watch: {
             files: '**/*.ts',
             tasks: ['typescript', 'copy']
         }
     });
- 
+
     grunt.registerTask('default', ['watch']);
- 
+
 }

Phaser/Collision.ts

@@ -35,6 +35,9 @@
 *
 * This is where the magic happens. The Game object is the heart of your game, 
 * providing quick access to common functions and handling the boot process.
+*
+* "Hell, there are no rules here - we're trying to accomplish something."
+*                                                       Thomas A. Edison
 */
 
 module Phaser {
@@ -313,8 +316,7 @@ module Phaser {
             }
             else
             {
-                throw Error("Invalid State object given. Must contain at least a create or update function.");
-                return;
+                throw new Error("Invalid State object given. Must contain at least a create or update function.");
             }
 
         }
@@ -416,8 +418,8 @@ module Phaser {
             return this.tweens.create(obj);
         }
 
-        public collide(ObjectOrGroup1: Basic = null, ObjectOrGroup2: Basic = null, NotifyCallback = null): bool {
-            return this.collision.overlap(ObjectOrGroup1, ObjectOrGroup2, NotifyCallback, Collision.separate);
+        public collide(objectOrGroup1: Basic = null, objectOrGroup2: Basic = null, notifyCallback = null): bool {
+            return this.collision.overlap(objectOrGroup1, objectOrGroup2, notifyCallback, Collision.separate);
         }
 
     }

Phaser/Game.ts

@@ -450,7 +450,7 @@ module Phaser {
             }
         }
 
-        public forEach(callback, Recurse: bool = false) {
+        public forEach(callback, recursive: bool = false) {
 
             var basic;
             var i: number = 0;
@@ -461,7 +461,7 @@ module Phaser {
 
                 if (basic != null)
                 {
-                    if (Recurse && (basic.isGroup == true))
+                    if (recursive && (basic.isGroup == true))
                     {
                         basic.forEach(callback, true);
                     }
@@ -474,6 +474,30 @@ module Phaser {
 
         }
 
+        public forEachAlive(callback, recursive: bool = false) {
+
+            var basic;
+            var i: number = 0;
+
+            while (i < this.length)
+            {
+                basic = this.members[i++];
+
+                if (basic != null && basic.alive)
+                {
+                    if (recursive && (basic.isGroup == true))
+                    {
+                        basic.forEachAlive(callback, true);
+                    }
+                    else
+                    {
+                        callback.call(this, basic);
+                    }
+                }
+            }
+
+        }
+
         /**
          * Call this function to retrieve the first object with exists == false in the group.
          * This is handy for recycling in general, e.g. respawning enemies.

Phaser/Group.ts

@@ -1,7 +1,7 @@
 /**
 * Phaser
 *
-* v0.9.3 - April 24th 2013
+* v0.9.4 - April 24th 2013
 *
 * A small and feature-packed 2D canvas game framework born from the firey pits of Flixel and Kiwi.
 *
@@ -16,6 +16,6 @@
 
 module Phaser {
 
-    export var VERSION: string = 'Phaser version 0.9.3';
+    export var VERSION: string = 'Phaser version 0.9.4';
 
 }

Phaser/Phaser.ts

@@ -43,8 +43,8 @@ module Phaser {
             this.scaleMode = StageScaleMode.NO_SCALE;
             this.scale = new StageScaleMode(this._game);
 
-            //document.addEventListener('visibilitychange', (event) => this.visibilityChange(event), false);
-            //document.addEventListener('webkitvisibilitychange', (event) => this.visibilityChange(event), false);
+            document.addEventListener('visibilitychange', (event) => this.visibilityChange(event), false);
+            document.addEventListener('webkitvisibilitychange', (event) => this.visibilityChange(event), false);
             window.onblur = (event) => this.visibilityChange(event);
             window.onfocus = (event) => this.visibilityChange(event);
 
@@ -96,6 +96,8 @@ module Phaser {
         //if (document['hidden'] === true || document['webkitHidden'] === true)
         private visibilityChange(event) {
 
+            //console.log(event);
+
             if (this.disablePauseScreen)
             {
                 return;

Phaser/Stage.ts

@@ -89,6 +89,8 @@ module Phaser {
         //  rotationOffset to 90 and it would correspond correctly with Phasers rotation system
         public rotationOffset: number = 0;
 
+        public renderRotation: bool = true;
+
         //  Physics properties
         public immovable: bool;
 

Phaser/gameobjects/GameObject.ts

@@ -229,7 +229,7 @@ module Phaser {
                 this._game.stage.context.save();
                 this._game.stage.context.translate(this._dx + (this._dw / 2), this._dy + (this._dh / 2));
 
-                if (this.angle !== 0 || this.rotationOffset !== 0)
+                if (this.renderRotation == true &&  (this.angle !== 0 || this.rotationOffset !== 0))
                 {
                     this._game.stage.context.rotate((this.rotationOffset + this.angle) * (Math.PI / 180));
                 }

Phaser/gameobjects/Sprite.ts

@@ -1,6 +1,7 @@
 /// <reference path="../Game.ts" />
 /// <reference path="GameObject.ts" />
 /// <reference path="../system/TilemapLayer.ts" />
+/// <reference path="../system/Tile.ts" />
 
 /**
 * Phaser - Tilemap
@@ -19,7 +20,8 @@ module Phaser {
 
             this.isGroup = false;
 
-            this._layers = [];
+            this.tiles = [];
+            this.layers = [];
 
             this.mapFormat = format;
 
@@ -41,11 +43,11 @@ module Phaser {
 
         }
 
-        private _layers : TilemapLayer[];
-
         public static FORMAT_CSV: number = 0;
         public static FORMAT_TILED_JSON: number = 1;
 
+        public tiles : Tile[];
+        public layers : TilemapLayer[];
         public currentLayer: TilemapLayer;
         public mapFormat: number;
 
@@ -57,17 +59,17 @@ module Phaser {
             if (this.cameraBlacklist.indexOf(camera.ID) == -1)
             {
                 //  Loop through the layers
-                for (var i = 0; i < this._layers.length; i++)
+                for (var i = 0; i < this.layers.length; i++)
                 {
-                    this._layers[i].render(camera, cameraOffsetX, cameraOffsetY);
+                    this.layers[i].render(camera, cameraOffsetX, cameraOffsetY);
                 }
             }
 
         }
 
         private parseCSV(data: string, key: string, tileWidth: number, tileHeight: number) {
 
-            var layer: TilemapLayer = new TilemapLayer(this._game, key, Tilemap.FORMAT_CSV, 'TileLayerCSV' + this._layers.length.toString(), tileWidth, tileHeight);
+            var layer: TilemapLayer = new TilemapLayer(this._game, this, key, Tilemap.FORMAT_CSV, 'TileLayerCSV' + this.layers.length.toString(), tileWidth, tileHeight);
 
             //  Trim any rogue whitespace from the data
             data = data.trim();
@@ -85,10 +87,13 @@ module Phaser {
             }
 
             layer.updateBounds();
+            var tileQuantity = layer.parseTileOffsets();
 
             this.currentLayer = layer;
 
-            this._layers.push(layer);
+            this.layers.push(layer);
+
+            this.generateTiles(tileQuantity);
 
         }
 
@@ -101,10 +106,12 @@ module Phaser {
 
             for (var i = 0; i < json.layers.length; i++)
             {
-                var layer: TilemapLayer = new TilemapLayer(this._game, key, Tilemap.FORMAT_TILED_JSON, json.layers[i].name, json.tilewidth, json.tileheight);
+                var layer: TilemapLayer = new TilemapLayer(this._game, this, key, Tilemap.FORMAT_TILED_JSON, json.layers[i].name, json.tilewidth, json.tileheight);
 
                 layer.alpha = json.layers[i].opacity;
                 layer.visible = json.layers[i].visible;
+                layer.tileMargin = json.tilesets[0].margin;
+                layer.tileSpacing = json.tilesets[0].spacing;
 
                 var c = 0;
                 var row;
@@ -129,10 +136,23 @@ module Phaser {
 
                 layer.updateBounds();
 
+                var tileQuantity = layer.parseTileOffsets();
+
                 this.currentLayer = layer;
 
-                this._layers.push(layer);
+                this.layers.push(layer);
+
+            }
+
+            this.generateTiles(tileQuantity);
+
+        }
+
+        private generateTiles(qty:number) {
 
+            for (var i = 0; i < qty; i++)
+            {
+                this.tiles.push(new Tile(this._game, this, i, this.currentLayer.tileWidth, this.currentLayer.tileHeight));
             }
 
         }
@@ -145,9 +165,81 @@ module Phaser {
             return this.currentLayer.heightInPixels;
         }
 
+        //  Tile Collision
+
+        public setCollisionRange(start: number, end: number, collision?:number = Collision.ANY) {
+
+            for (var i = start; i < end; i++)
+            {
+                this.tiles[i].allowCollisions = collision;
+            }
+
+        }
+
+        public setCollisionByIndex(values:number[], collision?:number = Collision.ANY) {
+
+            for (var i = 0; i < values.length; i++)
+            {
+                this.tiles[values[i]].allowCollisions = collision;
+            }
+
+        }
+
+        //  Tile Management
+
+        public getTile(x: number, y: number, layer?: number = 0):Tile {
+
+            return this.tiles[this.layers[layer].getTileIndex(x, y)];
+
+        }
+
+        public getTileFromWorldXY(x: number, y: number, layer?: number = 0):Tile {
+
+            return this.tiles[this.layers[layer].getTileFromWorldXY(x, y)];
+
+        }
+
+        public getTileFromInputXY(layer?: number = 0):Tile {
+
+            return this.tiles[this.layers[layer].getTileFromWorldXY(this._game.input.worldX, this._game.input.worldY)];
+
+        }
+
+        public getTileOverlaps(object: GameObject) {
+
+            return this.currentLayer.getTileOverlaps(object);
+
+        }
+
+        //  COLLIDE
+        public collide(objectOrGroup = null, callback = null): bool {
+
+            if (objectOrGroup == null)
+            {
+                objectOrGroup = this._game.world.group;
+            }
+
+            //  Group?
+            if (objectOrGroup.isGroup == false)
+            {
+                if (objectOrGroup.exists && objectOrGroup.allowCollisions != Collision.NONE)
+                {
+                    this.currentLayer.getTileOverlaps(objectOrGroup);
+                }
+            }
+            else
+            {
+                // todo
+                objectOrGroup.forEachAlive(this.currentLayer.getTileOverlaps);
+            }
+
+            return true;
+
+        }
+
+
         //  Set current layer
         //  Set layer order?
-        //  Get tile from x/y
         //  Get block of tiles
         //  Swap tiles around
         //  Delete tiles of certain type