text: //
  // http://www.cocos2d-iphone.org
  // http://www.cocos2d-html5.org
  // http://www.cocos2d-x.org
  //
  // Javascript + cocos2d actions tests
  //
  
  require("jsb_constants.js");
  
  var TAG_TILE_MAP = 1;
  
  director = cc.Director.getInstance();
  winSize = director.getWinSize();
  centerPos = cc.p( winSize.width/2, winSize.height/2 );
  
  var scenes = [];
  var currentScene = 0;
  
  var nextScene = function () {
  	currentScene = currentScene + 1;
  	if( currentScene >= scenes.length )
  		currentScene = 0;
  
  	withTransition = true;
  	loadScene(currentScene);
  };
  
  var previousScene = function () {
  	currentScene = currentScene -1;
  	if( currentScene < 0 )
  		currentScene = scenes.length -1;
  
  	withTransition = true;
  	loadScene(currentScene);
  };
  
  var restartScene = function () {
  	loadScene( currentScene );
  };
  
  var loadScene = function (sceneIdx)
  {
  	winSize = director.getWinSize();
  	centerPos = cc.p( winSize.width/2, winSize.height/2 );
  
  	var scene = new cc.Scene();
  	scene.init();
  	var layer = new scenes[ sceneIdx ]();
  
  	scene.addChild( layer );
  
  //	scene.walkSceneGraph(0);
  
  	director.replaceScene( scene );
  //    __jsc__.garbageCollect();
  }
  
  //
  // Base Layer
  //
  
  var BaseLayer = cc.Layer.extend({
  
      prevLocation:null,
  
      ctor:function () {
                                  
          var parent = new cc.Layer();
          __associateObjWithNative(this, parent);
          this.init();
  
  //        var gradient = cc.LayerGradient.create( cc.c4b(0, 0, 0, 255), cc.c4b(0, 128, 255, 255) );
  //        this.addChild( gradient, -100 );
      },
  
      title:function () {
          return "No Title";
      },
  
      subtitle:function () {
          return "";
      },
  
      code:function () {
          return "";
      },
  
      restartCallback:function (sender) {
          restartScene();
      },
  
      nextCallback:function (sender) {
          nextScene();
      },
  
      backCallback:function (sender) {
         previousScene();
      },
  
      onEnter:function () {
          // DO NOT CALL this._super()
  //        this._super();
  
          var platform = __getPlatform();
          if( platform.substring(0,7) == 'desktop' )
              this.setMouseEnabled( true );
          else if( platform.substring(0,6) == 'mobile' )
              this.setTouchEnabled( true );
  
          // add title and subtitle
          var label = cc.LabelTTF.create(this.title(), "Arial", 28);
          this.addChild(label, 1);
          label.setPosition( cc.p(winSize.width / 2, winSize.height - 50));
  
          var strSubtitle = this.subtitle();
          if (strSubtitle != "") {
              var l = cc.LabelTTF.create(strSubtitle, "Thonburi", 16);
              this.addChild(l, 1);
              l.setPosition( cc.p(winSize.width / 2, winSize.height - 80));
          }
  
          var strCode = this.code();
          if( strCode !="" ) {
              var label = cc.LabelTTF.create(strCode, 'CourierNewPSMT', 16);
              label.setPosition( cc.p( winSize.width/2, winSize.height-100) );
              this.addChild( label,10 );
  
              var labelbg = cc.LabelTTF.create(strCode, 'CourierNewPSMT', 16);
              labelbg.setColor( cc.c3b(10,10,255) );
              labelbg.setPosition( cc.p( winSize.width/2 +1, winSize.height-100 -1) );
              this.addChild( labelbg,9);
          }
  
          // Menu
          var item1 = cc.MenuItemImage.create("b1.png", "b2.png", this, this.backCallback);
          var item2 = cc.MenuItemImage.create("r1.png", "r2.png", this, this.restartCallback);
          var item3 = cc.MenuItemImage.create("f1.png", "f2.png", this, this.nextCallback);
          var item4 = cc.MenuItemFont.create("back", this, function() { require("js/main.js"); } );
          item4.setFontSize( 22 );
  
          var menu = cc.Menu.create(item1, item2, item3, item4 );
  
          menu.setPosition( cc.p(0,0) );
          item1.setPosition( cc.p(winSize.width / 2 - 100, 30));
          item2.setPosition( cc.p(winSize.width / 2, 30));
          item3.setPosition( cc.p(winSize.width / 2 + 100, 30));
          item4.setPosition( cc.p(winSize.width - 60, winSize.height - 30 ) );
  
          this.addChild(menu, 1);
      },
      onExit:function () {
          // nothing
      },
  
      onTouchesMoved:function (touches, event) {
          this.moveTile( touches[0].getDelta() );
      },
  
      onMouseDragged : function( event ) {
          this.moveTile( event.getDelta() );
      },
  
      moveTile:function ( delta ) {
  
          var node = this.getChildByTag(TAG_TILE_MAP);
          var currentPos = node.getPosition();
          var newPos = cc.pAdd(currentPos, delta );
          node.setPosition(newPos);
      }
  });
  
  
  
  var TileMapTest = BaseLayer.extend({
      ctor:function () {
          this._super();
          var map = cc.TileMapAtlas.create("TileMaps/tiles.png", "TileMaps/levelmap.tga", 16, 16);
          map.getTexture().setAntiAliasTexParameters();
  
          // If you are not going to use the Map, you can free it now
          // NEW since v0.7
          map.releaseMap();
  
          this.addChild(map, 0, TAG_TILE_MAP);
  
          map.setAnchorPoint(cc.p(0, 0.5));
  
          var scale = cc.ScaleBy.create(4, 0.8);
          var scaleBack = scale.reverse();
  
          var seq = cc.Sequence.create(scale, scaleBack );
  
          map.runAction(cc.RepeatForever.create(seq));
      },
      title:function () {
          return "TileMapAtlas";
      }
  });
  
  var TileMapEditTest = BaseLayer.extend({
      ctor:function () {
          this._super();
          var map = cc.TileMapAtlas.create("TileMaps/tiles.png", "TileMaps/levelmap.tga", 16, 16);
          // Create an Aliased Atlas
          map.getTexture().setAliasTexParameters();
  
          // If you are not going to use the Map, you can free it now
          // [tilemap releaseMap);
          // And if you are going to use, it you can access the data with:
  
  //        this.schedule(this.updateMap, 0.2);//:@selector(updateMap:) interval:0.2f);
  
          this.addChild(map, 0, TAG_TILE_MAP);
  
          map.setAnchorPoint(cc.p(0, 0));
          map.setPosition(cc.p(-20, -200));
  
      },
      title:function () {
          return "Editable TileMapAtlas";
      },
      updateMap:function (dt) {
          // IMPORTANT
          //   The only limitation is that you cannot change an empty, or assign an empty tile to a tile
          //   The value 0 not rendered so don't assign or change a tile with value 0
  
          var tilemap = this.getChildByTag(TAG_TILE_MAP);
  
          // NEW since v0.7
          var c = tilemap.tileAt(cc.g(13, 21));
          c.r++;
          c.r %= 50;
          if (c.r == 0)
              c.r = 1;
  
          // NEW since v0.7
          tilemap.setTile(c, cc.g(13, 21));
      }
  });
  
  //------------------------------------------------------------------
  //
  // TMXOrthoTest
  //
  //------------------------------------------------------------------
  var TMXOrthoTest = BaseLayer.extend({
      ctor:function () {
          this._super();
          var map = cc.TMXTiledMap.create("TileMaps/orthogonal-test1.tmx");
          this.addChild(map, 0, TAG_TILE_MAP);
  
          var childrenArray = map.getChildren();
          for (var i = 0; i < childrenArray.length; i++) {
              var child = childrenArray[i];
              child.getTexture().setAntiAliasTexParameters();
          }
          map.runAction(cc.ScaleBy.create(2, 0.5));
      },
      title:function () {
          return "TMX Orthogonal test";
      },
  
      subtitle:function () {
          return "Simple TMX test";
      },
  
      code : function() {
          return 'var map = cc.TMXTiledMap.create("map.tmx");'
      }
  });
  
  //------------------------------------------------------------------
  //
  // TMXOrthoTest2
  //
  //------------------------------------------------------------------
  var TMXOrthoTest2 = BaseLayer.extend({
      ctor:function () {
          this._super();
          //
          // Test orthogonal with 3d camera and anti-alias textures
          //
          // it should not flicker. No artifacts should appear
          //
          var map = cc.TMXTiledMap.create("TileMaps/orthogonal-test2.tmx");
          this.addChild(map, 0, TAG_TILE_MAP);
  
          var childrenArray = map.getChildren();
          var child = null;
          for (var i = 0, len = childrenArray.length; i < len; i++) {
              child = childrenArray[i];
              child.getTexture().setAntiAliasTexParameters();
          }
  
  //        var x, y, z;
  //        map.getCamera().getEyeXYZ(x, y, z);
  //        map.getCamera().setEyeXYZ(x - 200, y, z + 300);
      },
      title:function () {
          return "TMX Orthogonal test";
      },
  
      subtitle:function () {
          return "Testing camera... NOT WORKING YET";
      },
      code : function() {
          return 'var map = cc.TMXTiledMap.create("map.tmx");'
      },
      onEnter:function () {
          this._super();
          // 3D == 1
          director.setProjection(1);
      },
      onExit:function () {
          this._super();
          // 2D == 1
          director.setProjection(0);
      }
  });
  
  
  //------------------------------------------------------------------
  //
  // TMXOrthoTest3
  //
  //------------------------------------------------------------------
  var TMXOrthoTest3 = BaseLayer.extend({
      ctor:function () {
          this._super();
          var map = cc.TMXTiledMap.create("TileMaps/orthogonal-test3.tmx");
          this.addChild(map, 0, TAG_TILE_MAP);
  
          var childrenArray = map.getChildren();
          var child = null;
          for (var i = 0, len = childrenArray.length; i < len; i++) {
              child = childrenArray[i];
              child.getTexture().setAntiAliasTexParameters();
          }
  
          map.setScale(0.2);
          map.setAnchorPoint(cc.p(0.5, 0.5));
      },
      title:function () {
          return "TMX anchorPoint test";
      }
  });
  
  //------------------------------------------------------------------
  //
  // TMXOrthoTest4
  //
  //------------------------------------------------------------------
  var TMXOrthoTest4 = BaseLayer.extend({
      elapsedTime:0,
  
      ctor:function () {
          this._super();
          var map = cc.TMXTiledMap.create("TileMaps/orthogonal-test4.tmx");
          this.addChild(map, 0, TAG_TILE_MAP);
  
          var childrenArray = map.getChildren();
          var child = null;
          for (var i = 0, len = childrenArray.length; i < len; i++) {
              child = childrenArray[i];
              child.getTexture().setAntiAliasTexParameters();
          }
  
          map.setAnchorPoint(cc.p(0, 0));
  
          var layer = map.layerNamed("Layer 0");
          var s = layer.getLayerSize();
  
          var sprite;
          sprite = layer.tileAt(cc.p(0, 0));
          sprite.setScale(2);
  
          sprite = layer.tileAt(cc.p(s.width - 1, 0));
          sprite.setScale(2);
  
          sprite = layer.tileAt(cc.p(0, s.height - 1));
          sprite.setScale(2);
  
          sprite = layer.tileAt(cc.p(s.width - 1, s.height - 1));
          sprite.setScale(2);
  
          this.scheduleUpdate();
      },
      update:function (dt) {
          this.elapsedTime += dt;
          if( this.elapsedTime > 2 ) {
              this.unscheduleUpdate();
  
              var map = this.getChildByTag(TAG_TILE_MAP);
  
              var layer = map.layerNamed("Layer 0");
              var s = layer.getLayerSize();
  
              var sprite = layer.tileAt(cc.p(s.width - 1, 0));
              cc.log( layer );
              layer.removeChild(sprite, true);
          }
      },
      title:function () {
          return "TMX width/height test";
      }
  });
  
  //------------------------------------------------------------------
  //
  // TMXReadWriteTest
  //
  //------------------------------------------------------------------
  var TMXReadWriteTest = BaseLayer.extend({
      gid:0,
      ctor:function () {
          this._super();
  
          var map = cc.TMXTiledMap.create("TileMaps/orthogonal-test2.tmx");
          this.addChild(map, 0, TAG_TILE_MAP);
  
  
          var layer = map.layerNamed("Layer 0");
          layer.getTexture().setAntiAliasTexParameters();
  
          map.setScale(1);
  
          var tile0 = layer.tileAt(cc.p(1, 63));
          var tile1 = layer.tileAt(cc.p(2, 63));
          var tile2 = layer.tileAt(cc.p(3, 62));//cc.p(1,62));
          var tile3 = layer.tileAt(cc.p(2, 62));
  
          tile0.setAnchorPoint(cc.p(0.5, 0.5));
          tile1.setAnchorPoint(cc.p(0.5, 0.5));
          tile2.setAnchorPoint(cc.p(0.5, 0.5));
          tile3.setAnchorPoint(cc.p(0.5, 0.5));
  
          var move = cc.MoveBy.create(0.5, cc.p(0, 160));
          var rotate = cc.RotateBy.create(2, 360);
          var scale = cc.ScaleBy.create(2, 5);
          var opacity = cc.FadeOut.create(2);
          var fadein = cc.FadeIn.create(2);
          var scaleback = cc.ScaleTo.create(1, 1);
          var finish = cc.CallFunc.create(this, this.removeSprite);
  
          var seq0 = cc.Sequence.create(move, rotate, scale, opacity, fadein, scaleback, finish );
  
          tile0.runAction(seq0);
          tile1.runAction(seq0.copy());
          tile2.runAction(seq0.copy());
          tile3.runAction(seq0.copy());
  
          this.gid = layer.tileGIDAt(cc.p(0, 63));
  
  //        this.schedule(this.updateCol, 2.0);
  //        this.schedule(this.repaintWithGID, 2.0);
  //        this.schedule(this.removeTiles, 1.0);
  
          this.gid2 = 0;
      },
      removeSprite:function (sender) {
          var p = sender.getParent();
          if (p) {
              p.removeChild(sender, true);
          }
      },
      updateCol:function (dt) {
          var map = this.getChildByTag(TAG_TILE_MAP);
          var layer = map.getChildByTag(0);
  
          var s = layer.getLayerSize();
  
          for (var y = 0; y < s.height; y++) {
              layer.setTileGID(this.gid2, cc.p(3, y));
          }
  
          this.gid2 = (this.gid2 + 1) % 80;
      },
      repaintWithGID:function (dt) {
          //	[self unschedule:_cmd);
  
          var map = this.getChildByTag(TAG_TILE_MAP);
          var layer = map.getChildByTag(0);
  
          var s = layer.getLayerSize();
  
          for (var x = 0; x < s.width; x++) {
              var y = s.height - 1;
              var tmpgid = layer.tileGIDAt(cc.p(x, y));
              layer.setTileGID(tmpgid + 1, cc.p(x, y));
          }
      },
      removeTiles:function (dt) {
          this.unschedule(this.removeTiles);
  
          var map = this.getChildByTag(TAG_TILE_MAP);
  
          var layer = map.getChildByTag(0);
  
          var s = layer.getLayerSize();
  
          for (var y = 0; y < s.height; y++) {
              layer.removeTileAt(cc.p(5.0, y));
          }
      },
      title:function () {
          return "TMX Read/Write test";
      }
  });
  
  //------------------------------------------------------------------
  //
  // TMXHexTest
  //
  //------------------------------------------------------------------
  var TMXHexTest = BaseLayer.extend({
      ctor:function () {
          this._super();
          var color = cc.LayerColor.create(cc.c4b(64, 64, 64, 255));
          this.addChild(color, -1);
  
          var map = cc.TMXTiledMap.create("TileMaps/hexa-test.tmx");
          this.addChild(map, 0, TAG_TILE_MAP);
      },
      title:function () {
          return "TMX Hex test";
      }
  });
  
  //------------------------------------------------------------------
  //
  // TMXIsoTest
  //
  //------------------------------------------------------------------
  var TMXIsoTest = BaseLayer.extend({
      ctor:function () {
          this._super();
          var color = cc.LayerColor.create(cc.c4b(64, 64, 64, 255));
          this.addChild(color, -1);
  
          var map = cc.TMXTiledMap.create("TileMaps/iso-test.tmx");
          this.addChild(map, 0, TAG_TILE_MAP);
  
          // move map to the center of the screen
          var ms = map.getMapSize();
          var ts = map.getTileSize();
  
          map.runAction(cc.MoveTo.create(1.0, cc.p(-ms.width * ts.width / 2, -ms.height * ts.height / 2)));
      },
      title:function () {
          return "TMX Isometric test 0";
      }
  });
  
  //------------------------------------------------------------------
  //
  // TMXIsoTest1
  //
  //------------------------------------------------------------------
  var TMXIsoTest1 = BaseLayer.extend({
      ctor:function () {
          this._super();
          var color = cc.LayerColor.create(cc.c4b(64, 64, 64, 255));
          this.addChild(color, -1);
  
          var map = cc.TMXTiledMap.create("TileMaps/iso-test1.tmx");
          this.addChild(map, 0, TAG_TILE_MAP);
  
          map.setAnchorPoint(cc.p(0.5, 0.5));
      },
      title:function () {
          return "TMX Isometric test + anchorPoint";
      }
  });
  
  //------------------------------------------------------------------
  //
  // TMXIsoTest2
  //
  //------------------------------------------------------------------
  var TMXIsoTest2 = BaseLayer.extend({
      ctor:function () {
          this._super();
          var color = cc.LayerColor.create(cc.c4b(64, 64, 64, 255));
          this.addChild(color, -1);
  
          var map = cc.TMXTiledMap.create("TileMaps/iso-test2.tmx");
          this.addChild(map, 0, TAG_TILE_MAP);
  
          // move map to the center of the screen
          var ms = map.getMapSize();
          var ts = map.getTileSize();
  
          map.runAction(cc.MoveTo.create(1.0, cc.p(-ms.width * ts.width / 2, -ms.height * ts.height / 2)));
      },
      title:function () {
          return "TMX Isometric test 2";
      }
  });
  
  //------------------------------------------------------------------
  //
  // TMXUncompressedTest
  //
  //------------------------------------------------------------------
  var TMXUncompressedTest = BaseLayer.extend({
      ctor:function () {
          this._super();
          var color = cc.LayerColor.create(cc.c4b(64, 64, 64, 255));
          this.addChild(color, -1);
  
          var map = cc.TMXTiledMap.create("TileMaps/iso-test2-uncompressed.tmx");
          this.addChild(map, 0, TAG_TILE_MAP);
  
          // move map to the center of the screen
          var ms = map.getMapSize();
          var ts = map.getTileSize();
  
          map.runAction(cc.MoveTo.create(1.0, cc.p(-ms.width * ts.width / 2, -ms.height * ts.height / 2)));
  
          // testing release map
          var childrenArray = map.getChildren();
          var layer = null;
          for (var i = 0, len = childrenArray.length; i < len; i++) {
              layer = childrenArray[i];
              if (!layer)
                  break;
  
              layer.releaseMap();
          }
      },
      title:function () {
          return "TMX Uncompressed test";
      }
  });
  
  //------------------------------------------------------------------
  //
  // TMXTilesetTest
  //
  //------------------------------------------------------------------
  var TMXTilesetTest = BaseLayer.extend({
      ctor:function () {
          this._super();
          var map = cc.TMXTiledMap.create("TileMaps/orthogonal-test5.tmx");
          this.addChild(map, 0, TAG_TILE_MAP);
  
          var layer;
          layer = map.layerNamed("Layer 0");
          layer.getTexture().setAntiAliasTexParameters();
  
          layer = map.layerNamed("Layer 1");
          layer.getTexture().setAntiAliasTexParameters();
  
          layer = map.layerNamed("Layer 2");
          layer.getTexture().setAntiAliasTexParameters();
      },
      title:function () {
          return "TMX Tileset test";
      }
  });
  
  //------------------------------------------------------------------
  //
  // TMXOrthoObjectsTest
  //
  //------------------------------------------------------------------
  var TMXOrthoObjectsTest = BaseLayer.extend({
      ctor:function () {
          this._super();
          var map = cc.TMXTiledMap.create("TileMaps/ortho-objects.tmx");
          this.addChild(map, -1, TAG_TILE_MAP);
  
          var group = map.objectGroupNamed("Object Group 1");
          var objects = group.getObjects();
  
          for (var i = 0; i < objects.length; i++) {
              var dict = objects[i];
              if (!dict)
                  break;
          }
      },
      draw:function () {
          var map = this.getChildByTag(TAG_TILE_MAP);
          var group = map.objectGroupNamed("Object Group 1");
          var objects = group.getObjects();
          for (var i = 0; i < objects.length; i++) {
              var dict = objects[i];
              if (!dict)
                  break;
  
              var x = parseInt(dict["x"]);
              var y = parseInt(dict["y"]);
              var width = parseInt(dict["width"]);
              var height = parseInt(dict["height"]);
  
              cc.renderContext.lineWidth = 3;
              cc.renderContext.strokeStyle = "#ffffff";
  
              cc.drawingUtil.drawLine(cc.p(x, y), cc.p((x + width), y));
              cc.drawingUtil.drawLine(cc.p((x + width), y), cc.p((x + width), (y + height)));
              cc.drawingUtil.drawLine(cc.p((x + width), (y + height)), cc.p(x, (y + height)));
              cc.drawingUtil.drawLine(cc.p(x, (y + height)), cc.p(x, y));
  
              cc.renderContext.lineWidth = 1;
          }
      },
      title:function () {
          return "TMX Ortho object test";
      },
      subtitle:function () {
          return "You should see a white box around the 3 platforms";
      }
  });
  
  //------------------------------------------------------------------
  //
  // TMXIsoObjectsTest
  //
  //------------------------------------------------------------------
  var TMXIsoObjectsTest = BaseLayer.extend({
      ctor:function () {
          this._super();
          var map = cc.TMXTiledMap.create("TileMaps/iso-test-objectgroup.tmx");
          this.addChild(map, -1, TAG_TILE_MAP);
  
  
          var group = map.objectGroupNamed("Object Group 1");
          var objects = group.getObjects();
  
          var dict;
          for (var i = 0, len = objects.length; i < len; i++) {
              dict = objects[i];
              if (!dict)
                  break;
          }
      },
      title:function () {
          return "TMX Iso object test";
      },
      draw:function () {
          var map = this.getChildByTag(TAG_TILE_MAP);
          var group = map.objectGroupNamed("Object Group 1");
          var objects = group.getObjects();
          var dict;
          for (var i = 0, len = objects.length; i < len; i++) {
              dict = objects[i];
              if (!dict)
                  break;
  
              var x = parseInt(dict["x"]);
              var y = parseInt(dict["y"]);
              var width = parseInt(dict["width"]);
              var height = parseInt(dict["height"]);
  
              cc.renderContext.lineWidth = 3;
              cc.renderContext.strokeStyle = "#ffffff";
  
              cc.drawingUtil.drawLine(cc.p(x, y), cc.p(x + width, y));
              cc.drawingUtil.drawLine(cc.p(x + width, y), cc.p(x + width, y + height));
              cc.drawingUtil.drawLine(cc.p(x + width, y + height), cc.p(x, y + height));
              cc.drawingUtil.drawLine(cc.p(x, y + height), cc.p(x, y));
  
              cc.renderContext.lineWidth = 1;
          }
      },
      subtitle:function () {
          return "You need to parse them manually. See bug #810";
      }
  });
  
  //------------------------------------------------------------------
  //
  // TMXResizeTest
  //
  //------------------------------------------------------------------
  var TMXResizeTest = BaseLayer.extend({
      ctor:function () {
          this._super();
          var map = cc.TMXTiledMap.create("TileMaps/orthogonal-test5.tmx");
          this.addChild(map, 0, TAG_TILE_MAP);
  
  
          var layer;
          layer = map.layerNamed("Layer 0");
  
          var ls = layer.getLayerSize();
  
          for (var y = 0; y < ls.height; y++) {
              for (var x = 0; x < ls.width; x++) {
                  layer.setTileGID(1, cc.p(x, y));
              }
          }
      },
      title:function () {
          return "TMX resize test";
      },
      subtitle:function () {
          return "Should not crash. Testing issue #740";
      }
  });
  
  //------------------------------------------------------------------
  //
  // TMXIsoZorder
  //
  //------------------------------------------------------------------
  var TMXIsoZorder = BaseLayer.extend({
      tamara:null,
      ctor:function () {
          this._super();
          var map = cc.TMXTiledMap.create("TileMaps/iso-test-zorder.tmx");
          this.addChild(map, 0, TAG_TILE_MAP);
  
          var s = map.getContentSize();
          map.setPosition(cc.p(-s.width / 2, 0));
  
          this.tamara = cc.Sprite.create("grossinis_sister1.png");
          map.addChild(this.tamara, map.getChildren().length);
  
          // move map to the center of the screen
          var ms = map.getMapSize();
          var ts = map.getTileSize();
  
          var mapWidth = ms.width * ts.width;
          this.tamara.setPosition(cc.p(mapWidth / 2, 0));
          this.tamara.setAnchorPoint(cc.p(0.5, 0));
  
  
          var move = cc.MoveBy.create(10, cc.pMult(cc.p(300, 250), 1 ));
          var back = move.reverse();
          var seq = cc.Sequence.create(move, back );
          this.tamara.runAction(cc.RepeatForever.create(seq));
  
          this.scheduleUpdate();
      },
      title:function () {
          return "TMX Iso Zorder";
      },
      subtitle:function () {
          return "Sprite should hide behind the trees";
      },
      onExit:function () {
          this.unschedule(this.repositionSprite);
          this._super();
      },
      update:function (dt) {
          var p = this.tamara.getPosition();
  
          var map = this.getChildByTag(TAG_TILE_MAP);
  
          // there are only 4 layers. (grass and 3 trees layers)
          // if tamara < 48, z=4
          // if tamara < 96, z=3
          // if tamara < 144,z=2
  
          var newZ = 4 - (p.y / 48);
          newZ = Math.max(newZ, 0);
  
          map.reorderChild(this.tamara, newZ);
      }
  });
  
  //------------------------------------------------------------------
  //
  // TMXOrthoZorder
  //
  //------------------------------------------------------------------
  var TMXOrthoZorder = BaseLayer.extend({
      tamara:null,
      ctor:function () {
          this._super();
          var map = cc.TMXTiledMap.create("TileMaps/orthogonal-test-zorder.tmx");
          this.addChild(map, 0, TAG_TILE_MAP);
  
          var s = map.getContentSize();
  
          this.tamara = cc.Sprite.create("grossinis_sister1.png");
          map.addChild(this.tamara, map.getChildren().length, TAG_TILE_MAP);
          this.tamara.setAnchorPoint(cc.p(0.5, 0));
  
          var move = cc.MoveBy.create(10, cc.pMult(cc.p(400, 450), 1 ));
          var back = move.reverse();
          var seq = cc.Sequence.create(move, back );
          this.tamara.runAction(cc.RepeatForever.create(seq));
  
          this.scheduleUpdate();
      },
      title:function () {
          return "TMX Ortho Zorder";
      },
      subtitle:function () {
          return "Sprite should hide behind the trees";
      },
      update:function (dt) {
          var p = this.tamara.getPosition();
          var map = this.getChildByTag(TAG_TILE_MAP);
  
          // there are only 4 layers. (grass and 3 trees layers)
          // if tamara < 81, z=4
          // if tamara < 162, z=3
          // if tamara < 243,z=2
  
          // -10: customization for this particular sample
          var newZ = 4 - ((p.y - 10) / 81);
          newZ = Math.max(newZ, 0);
  
          map.reorderChild(this.tamara, newZ);
      }
  });
  
  //------------------------------------------------------------------
  //
  // TMXIsoVertexZ
  //
  //------------------------------------------------------------------
  var TMXIsoVertexZ = BaseLayer.extend({
      tamara:null,
      tamara1:null,
      ctor:function () {
          this._super();
          var map = cc.TMXTiledMap.create("TileMaps/iso-test-vertexz.tmx");
          this.addChild(map, 0, TAG_TILE_MAP);
  
          var s = map.getContentSize();
          map.setPosition(cc.p(-s.width / 2, 0));
  
          // because I'm lazy, I'm reusing a tile as an sprite, but since this method uses vertexZ, you
          // can use any cc.Sprite and it will work OK.
          var layer = map.layerNamed("Trees");
          this.tamara = layer.tileAt(cc.p(29, 29));
  
          var move = cc.MoveBy.create(10, cc.pMult(cc.p(300, 250), 1 ));
          var back = move.reverse();
          var seq = cc.Sequence.create(move, back );
          this.tamara.runAction(cc.RepeatForever.create(seq));
  
          this.scheduleUpdate();
      },
      title:function () {
          return "TMX Iso VertexZ";
      },
      subtitle:function () {
          return "Sprite should hide behind the trees (enable DepthBuffer)";
      },
      onEnter:function () {
          this._super();
          // TIP: 2d projection should be used
          // 0 == 2D
          director.setProjection(0);
      },
      onExit:function () {
  // At exit use any other projection.
          // 1 == 3D
          // director.setProjection(1);
          this._super();
      },
      update:function (dt) {
          // tile height is 64x32
          // map size: 30x30
          var p = this.tamara.getPosition();
          this.tamara.setVertexZ(-( (p.y + 32) / 16));
      }
  });
  
  //------------------------------------------------------------------
  //
  // TMXOrthoVertexZ
  //
  //------------------------------------------------------------------
  var TMXOrthoVertexZ = BaseLayer.extend({
      tamara:null,
      ctor:function () {
          this._super();
          var map = cc.TMXTiledMap.create("TileMaps/orthogonal-test-vertexz.tmx");
          this.addChild(map, 0, TAG_TILE_MAP);
  
  
          // because I'm lazy, I'm reusing a tile as an sprite, but since this method uses vertexZ, you
          // can use any cc.Sprite and it will work OK.
          var layer = map.layerNamed("trees");
          this.tamara = layer.tileAt(cc.p(0, 11));
          cc.log("vertexZ: " + this.tamara.getVertexZ());
  
          var move = cc.MoveBy.create(10, cc.pMult(cc.p(400, 450), 1 ));
          var back = move.reverse();
          var seq = cc.Sequence.create(move, back );
          this.tamara.runAction(cc.RepeatForever.create(seq));
  
          this.scheduleUpdate();
      },
      title:function () {
          return "TMX Ortho vertexZ";
      },
      subtitle:function () {
          return "Sprite should hide behind the trees (enable Depth Buffer!!)";
      },
      onEnter:function () {
          this._super();
  
          // TIP: 2d projection should be used
          // 2d = 0
          director.setProjection(0);
      },
      onExit:function () {
          // At exit use any other projection.
          // 3d = 1
          // director.setProjection(1);
          this._super();
      },
      update:function (dt) {
          // tile height is 101x81
          // map size: 12x12
          var p = this.tamara.getPosition();
          this.tamara.setVertexZ( -( (p.y + 81) / 81) );
      }
  });
  
  //------------------------------------------------------------------
  //
  // TMXIsoMoveLayer
  //
  //------------------------------------------------------------------
  var TMXIsoMoveLayer = BaseLayer.extend({
      ctor:function () {
          this._super();
          var map = cc.TMXTiledMap.create("TileMaps/iso-test-movelayer.tmx");
          this.addChild(map, 0, TAG_TILE_MAP);
          map.setPosition(cc.p(-700, -50));
  
      },
      title:function () {
          return "TMX Iso Move Layer";
      },
      subtitle:function () {
          return "Trees should be horizontally aligned";
      }
  });
  
  //------------------------------------------------------------------
  //
  // TMXOrthoMoveLayer
  //
  //------------------------------------------------------------------
  var TMXOrthoMoveLayer = BaseLayer.extend({
      ctor:function () {
          this._super();
          var map = cc.TMXTiledMap.create("TileMaps/orthogonal-test-movelayer.tmx");
          this.addChild(map, 0, TAG_TILE_MAP);
  
      },
      title:function () {
          return "TMX Ortho Move Layer";
      },
      subtitle:function () {
          return "Trees should be horizontally aligned";
      }
  });
  
  //------------------------------------------------------------------
  //
  // TMXBug987
  //
  //------------------------------------------------------------------
  var TMXBug987 = BaseLayer.extend({
      ctor:function () {
          this._super();
          var map = cc.TMXTiledMap.create("TileMaps/orthogonal-test6.tmx");
          this.addChild(map, 0, TAG_TILE_MAP);
  
          var s = map.getContentSize();
          cc.log("ContentSize:" + s.width + "," + s.height);
  
          var childs = map.getChildren();
          var node = null;
          for (var i = 0, len = childs.length; i < len; i++) {
              node = childs[i];
              node.getTexture().setAntiAliasTexParameters();
          }
  
          map.setAnchorPoint(cc.p(0, 0));
          var layer = map.layerNamed("Tile Layer 1");
          layer.setTileGID(3, cc.p(2, 2));
      },
      title:function () {
          return "TMX Bug 987";
      },
      subtitle:function () {
          return "You should see an square";
      }
  });
  
  //------------------------------------------------------------------
  //
  // TMXBug787
  //
  //------------------------------------------------------------------
  var TMXBug787 = BaseLayer.extend({
      ctor:function () {
          this._super();
          var map = cc.TMXTiledMap.create("TileMaps/iso-test-bug787.tmx");
          this.addChild(map, 0, TAG_TILE_MAP);
  
          map.setScale(0.25);
      },
      title:function () {
          return "TMX Bug 787";
      },
      subtitle:function () {
          return "You should see a map";
      }
  });
  
  var TMXGIDObjectsTest = BaseLayer.extend({
      ctor:function () {
          this._super();
          var map = cc.TMXTiledMap.create("TileMaps/test-object-layer.tmx");
          this.addChild(map, -1, TAG_TILE_MAP);
  
          var s = map.getContentSize();
          cc.log("ContentSize:" + s.width + "," + s.height);
          cc.log("---. Iterating over all the group objets");
      },
      title:function () {
          return "TMX GID objects";
      },
      subtitle:function () {
          return "Tiles are created from an object group";
      },
      draw:function () {
          var map = this.getChildByTag(TAG_TILE_MAP);
          var group = map.objectGroupNamed("Object Layer 1");
  
          var array = group.getObjects();
          var dict;
          for (var i = 0, len = array.length; i < len; i++) {
              dict = array[i];
              if (!dict)
                  break;
              var key = "x";
              var x = parseInt(dict[key]);
              key = "y";
              var y = parseInt(dict[key]);
              key = "width";
              var width = parseInt(dict[key]);
              key = "height";
              var height = parseInt(dict[key]);
  
              cc.renderContext.lineWidth = 3;
              cc.renderContext.strokeStyle = "#ffffff";
  
              cc.drawingUtil.drawLine(cc.p(x, y), cc.p((x + width), y));
              cc.drawingUtil.drawLine(cc.p((x + width), y), cc.p((x + width), (y + height)));
              cc.drawingUtil.drawLine(cc.p((x + width), (y + height)), cc.p(x, (y + height)));
              cc.drawingUtil.drawLine(cc.p(x, (y + height)), cc.p(x, y));
  
              cc.renderContext.lineWidth = 1;
          }
      }
  });
  
  
  //
  // Order of tests
  //
  scenes.push( TMXOrthoTest );
  scenes.push( TMXOrthoTest2 );
  scenes.push( TMXOrthoTest3 );
  scenes.push( TMXOrthoTest4 );
  scenes.push( TMXReadWriteTest );
  scenes.push( TMXHexTest );
  scenes.push( TMXIsoTest );
  scenes.push( TMXIsoTest1 );
  scenes.push( TMXIsoTest2 );
  scenes.push( TMXUncompressedTest );
  scenes.push( TMXTilesetTest );
  scenes.push( TMXOrthoObjectsTest );
  scenes.push( TMXIsoObjectsTest );
  scenes.push( TMXResizeTest );
  scenes.push( TMXIsoZorder );
  scenes.push( TMXOrthoZorder );
  scenes.push( TMXIsoVertexZ );
  scenes.push( TMXOrthoVertexZ );
  scenes.push( TMXIsoMoveLayer );
  scenes.push( TMXOrthoMoveLayer );
  scenes.push( TMXBug987 );
  scenes.push( TMXBug787 );
  scenes.push( TMXGIDObjectsTest );
  
  
  //------------------------------------------------------------------
  //
  // Main entry point
  //
  //------------------------------------------------------------------
  function run()
  {
      var scene = cc.Scene.create();
      var layer = new scenes[currentScene]();
      scene.addChild( layer );
  
      var runningScene = director.getRunningScene();
      if( runningScene == null )
          director.runWithScene( scene );
      else
          director.replaceScene( cc.TransitionFade.create(0.5, scene ) );
  }
  
  run();
  
  