package_2 alternativa.tanks.game.entities.map

src/alternativa/tanks/InitBattleTask.as

@@ -10,7 +10,7 @@ package alternativa.tanks
    import package_15.name_55;
    import package_18.name_44;
    import package_19.name_53;
-   import package_2.A3DMapComponent;
+   import alternativa.tanks.game.entities.map.A3DMapComponent;
    import package_9.name_20;
    
    public class InitBattleTask extends GameTask
@@ -72,10 +72,10 @@ package alternativa.tanks
 }
 
 import alternativa.tanks.game.GameEvents;
-import package_2.class_2;
+import alternativa.tanks.game.entities.map.IA3DMapComponentListener;
 import package_20.name_56;
 
-class MapListener implements class_2
+class MapListener implements IA3DMapComponentListener
 {
    private var eventSystem:name_56;
    

src/alternativa/tanks/game/entities/map/A3DMapBuilder.as

@@ -0,0 +1,444 @@
+package alternativa.tanks.game.entities.map
+{
+   import alternativa.engine3d.alternativa3d;
+   import flash.display.BitmapData;
+   import flash.events.Event;
+   import flash.events.EventDispatcher;
+   import flash.utils.ByteArray;
+   import package_116.name_529;
+   import package_116.name_530;
+   import package_116.name_641;
+   import package_15.name_55;
+   import package_19.name_117;
+   import package_19.name_380;
+   import package_19.name_91;
+   import package_21.name_116;
+   import package_21.name_78;
+   import package_27.name_170;
+   import package_27.name_642;
+   import package_28.name_129;
+   import package_28.name_167;
+   import package_28.name_241;
+   import package_28.name_259;
+   import package_28.name_93;
+   import package_3.name_10;
+   import package_4.name_643;
+   import package_76.name_235;
+   import package_86.name_257;
+   
+   use namespace alternativa3d;
+   
+   public class A3DMapBuilder extends EventDispatcher
+   {
+      public static const MAIN_FILE:String = "main.a3d";
+      
+      public static const ADDITIONAL_FILES_START:String = "part";
+      
+      public static const TREES_FILE:String = "trees.a3d";
+      
+      public static const MARKET_FILE:String = "market.a3d";
+      
+      public static const PHYSICS_FILE:String = "physics.a3d";
+      
+      public static const BEAMS_FILE:String = "beams.a3d";
+      
+      public static const LIGHTS_FILE:String = "lights.dae";
+      
+      private static const COLLISION_MASK:int = 255;
+      
+      private static var fakeEmissionTextureResource:name_93 = new name_93(new BitmapData(1,1,false,8355711));
+      
+      private static var fakeBumpTextureResource:name_93 = new name_93(new BitmapData(1,1,false,8355839));
+      
+      private var var_346:Vector.<name_78> = new Vector.<name_78>();
+      
+      private var var_569:Vector.<name_235>;
+      
+      private var var_16:Vector.<name_116>;
+      
+      private var var_406:Vector.<name_91> = new Vector.<name_91>();
+      
+      private var var_570:name_170;
+      
+      private var mapFiles:name_55;
+      
+      private var collector:Vector.<name_78>;
+      
+      private var var_571:name_259 = new name_259(new BitmapData(1,1,false,16711680),new BitmapData(1,1,false,16711680),new BitmapData(1,1,false,16711680),new BitmapData(1,1,false,16711680),new BitmapData(1,1,false,16711680),new BitmapData(1,1,false,16711680));
+      
+      public function A3DMapBuilder()
+      {
+         super();
+      }
+      
+      public function get objects() : Vector.<name_78>
+      {
+         return this.var_346;
+      }
+      
+      public function get collisionPrimitives() : Vector.<name_235>
+      {
+         return this.var_569;
+      }
+      
+      public function get lights() : Vector.<name_116>
+      {
+         return this.var_16;
+      }
+      
+      public function get decals() : Vector.<name_91>
+      {
+         return this.var_406;
+      }
+      
+      public function name_385(mapFiles:name_55) : void
+      {
+         var geometryFileName:String = null;
+         this.mapFiles = mapFiles;
+         var mapGeometryFiles:Vector.<String> = this.getMapGeometryFiles(mapFiles);
+         this.collector = new Vector.<name_78>();
+         this.var_570 = new name_170();
+         for each(geometryFileName in mapGeometryFiles)
+         {
+            this.var_570.addTask(new GeometryBuildTask(mapFiles.name_248(geometryFileName),this.collector));
+         }
+         this.var_570.addEventListener(Event.COMPLETE,this.onGeometryComplete);
+         this.var_570.run();
+      }
+      
+      private function onGeometryComplete(event:Event) : void
+      {
+         var surface:name_117 = null;
+         var object:name_78 = null;
+         var mesh:name_380 = null;
+         var meshName:String = null;
+         var decal:name_91 = null;
+         var resourceCache:Object = {};
+         for each(object in this.collector)
+         {
+            mesh = object as name_380;
+            if(mesh != null)
+            {
+               meshName = mesh.name.toLowerCase();
+               if(meshName.indexOf("decal") >= 0)
+               {
+                  decal = new name_91(1.5);
+                  decal.name = meshName;
+                  decal.useShadow = true;
+                  decal.geometry = mesh.geometry;
+                  decal.alternativa3d::var_92 = mesh.alternativa3d::var_92;
+                  decal.alternativa3d::var_93 = mesh.alternativa3d::var_93;
+                  for each(surface in decal.alternativa3d::var_92)
+                  {
+                     surface.alternativa3d::object = decal;
+                  }
+                  decal.boundBox = mesh.boundBox;
+                  decal.matrix = mesh.matrix;
+                  mesh = decal;
+                  this.var_406.push(decal);
+               }
+               mesh.calculateBoundBox();
+               this.setupMaterials(mesh,resourceCache);
+               this.var_346.push(mesh);
+            }
+         }
+         this.collector = null;
+         this.var_570 = null;
+         this.parseTrees(this.mapFiles.name_248(TREES_FILE));
+         this.parseReflections(this.mapFiles.name_248(MARKET_FILE));
+         this.parseBeams(this.mapFiles.name_248(BEAMS_FILE));
+         this.parseLights(this.mapFiles.name_248(LIGHTS_FILE));
+         this.parseCollisionGeometry(this.mapFiles.name_248(PHYSICS_FILE));
+         dispatchEvent(new Event(Event.COMPLETE));
+      }
+      
+      private function parseReflections(data:ByteArray) : void
+      {
+         var parser:name_529 = null;
+         var resourceCache:Object = null;
+         var object:name_78 = null;
+         var mesh:name_380 = null;
+         var i:int = 0;
+         var surface:name_117 = null;
+         var material:name_641 = null;
+         var diffName:String = null;
+         var diffuse:name_129 = null;
+         var bump:name_129 = null;
+         var opacity:name_129 = null;
+         var emission:name_129 = null;
+         var reflection:name_129 = null;
+         var envMaterial:name_643 = null;
+         if(data != null)
+         {
+            parser = new name_529();
+            parser.method_314(data);
+            resourceCache = {};
+            for each(object in parser.objects)
+            {
+               mesh = object as name_380;
+               if(mesh != null)
+               {
+                  for(i = 0; i < mesh.method_217; )
+                  {
+                     surface = mesh.method_216(i);
+                     if(surface.material != null)
+                     {
+                        material = name_641(surface.material);
+                        diffName = name_167(material.textures["diffuse"]).url;
+                        diffuse = this.getCompressedTextureResource(material.textures["diffuse"],resourceCache,this.mapFiles);
+                        bump = this.getCompressedTextureResource(material.textures["bump"],resourceCache,this.mapFiles);
+                        opacity = this.getCompressedTextureResource(material.textures["transparent"],resourceCache,this.mapFiles);
+                        emission = this.getCompressedTextureResource(material.textures["emission"],resourceCache,this.mapFiles);
+                        if(diffName.indexOf("vetrino01") >= 0)
+                        {
+                           reflection = this.getCompressedTextureResource(new name_167("vetrino_rfl.atf"),resourceCache,this.mapFiles);
+                           envMaterial = new name_643(diffuse,this.var_571,null,reflection,emission,opacity);
+                           envMaterial.reflection = 0.4;
+                           surface.material = envMaterial;
+                        }
+                        else
+                        {
+                           surface.material = new MapMaterial(diffuse,emission,1,opacity);
+                        }
+                     }
+                     i++;
+                  }
+                  this.var_346.push(mesh);
+               }
+            }
+         }
+      }
+      
+      private function setupMaterials(mesh:name_380, resourceCache:Object) : void
+      {
+         var surface:name_117 = null;
+         var parserMaterial:name_641 = null;
+         var diffuseTextureResource:name_129 = null;
+         var emissionTextureResource:name_129 = null;
+         var opacityTextureResource:name_129 = null;
+         var material:MapMaterial = null;
+         for each(surface in mesh.alternativa3d::var_92)
+         {
+            parserMaterial = surface.material as name_641;
+            if(parserMaterial != null)
+            {
+               diffuseTextureResource = this.getCompressedTextureResource(parserMaterial.textures["diffuse"],resourceCache,this.mapFiles);
+               emissionTextureResource = this.getCompressedTextureResource(parserMaterial.textures["emission"],resourceCache,this.mapFiles);
+               opacityTextureResource = this.getCompressedTextureResource(parserMaterial.textures["transparent"],resourceCache,this.mapFiles);
+               if(emissionTextureResource == null)
+               {
+                  material = new MapMaterial(diffuseTextureResource,fakeEmissionTextureResource,0,opacityTextureResource);
+               }
+               else
+               {
+                  material = new MapMaterial(diffuseTextureResource,emissionTextureResource,1,opacityTextureResource);
+               }
+               surface.material = material;
+            }
+         }
+      }
+      
+      private function getMapGeometryFiles(mapFiles:name_55) : Vector.<String>
+      {
+         var name:String = null;
+         var names:Vector.<String> = new Vector.<String>();
+         names.push(MAIN_FILE);
+         for(name in mapFiles.data)
+         {
+            if(name.indexOf(ADDITIONAL_FILES_START) == 0 && name.indexOf(".a3d") > 0)
+            {
+               names.push(name);
+            }
+         }
+         return names;
+      }
+      
+      private function parseTrees(data:ByteArray) : void
+      {
+         var parser:name_529 = null;
+         var resourceCache:Object = null;
+         var object:name_78 = null;
+         var mesh:name_380 = null;
+         var i:int = 0;
+         var surface:name_117 = null;
+         var material:name_641 = null;
+         var diffuse:name_129 = null;
+         var bump:name_129 = null;
+         var opacity:name_129 = null;
+         var trMaterial:name_10 = null;
+         if(data != null)
+         {
+            parser = new name_529();
+            parser.method_314(data);
+            resourceCache = {};
+            for each(object in parser.objects)
+            {
+               mesh = object as name_380;
+               if(mesh != null)
+               {
+                  for(i = 0; i < mesh.method_217; )
+                  {
+                     surface = mesh.method_216(i);
+                     if(surface.material != null)
+                     {
+                        material = name_641(surface.material);
+                        diffuse = this.getCompressedTextureResource(material.textures["diffuse"],resourceCache,this.mapFiles);
+                        bump = this.getCompressedTextureResource(material.textures["bump"],resourceCache,this.mapFiles);
+                        opacity = this.getCompressedTextureResource(material.textures["transparent"],resourceCache,this.mapFiles);
+                        trMaterial = new name_10(diffuse,fakeBumpTextureResource,null,null,opacity);
+                        trMaterial.var_25 = 0;
+                        trMaterial.alphaThreshold = 0.2;
+                        surface.material = trMaterial;
+                     }
+                     i++;
+                  }
+                  this.var_346.push(mesh);
+               }
+            }
+         }
+      }
+      
+      private function parseBeams(data:ByteArray) : void
+      {
+         var object:name_78 = null;
+         var mesh:name_380 = null;
+         var i:int = 0;
+         var surface:name_117 = null;
+         var material:name_641 = null;
+         var diffuse:name_129 = null;
+         var opacity:name_129 = null;
+         if(data == null)
+         {
+            return;
+         }
+         var parser:name_529 = new name_529();
+         parser.method_314(data);
+         var resourceCache:Object = {};
+         for each(object in parser.objects)
+         {
+            mesh = object as name_380;
+            if(mesh != null)
+            {
+               for(i = 0; i < mesh.method_217; )
+               {
+                  surface = mesh.method_216(i);
+                  if(surface.material != null)
+                  {
+                     material = name_641(surface.material);
+                     diffuse = this.getCompressedTextureResource(material.textures["diffuse"],resourceCache,this.mapFiles);
+                     opacity = this.getCompressedTextureResource(material.textures["transparent"],resourceCache,this.mapFiles);
+                     surface.material = new VisibleLightMaterial(opacity);
+                  }
+                  i++;
+               }
+               this.var_346.push(mesh);
+            }
+         }
+      }
+      
+      private function parseLights(lightsData:ByteArray) : void
+      {
+         var parserCollada:name_530 = null;
+         var numLights:uint = 0;
+         var i:int = 0;
+         if(lightsData != null)
+         {
+            parserCollada = new name_530();
+            parserCollada.method_314(XML(lightsData.toString()));
+            numLights = uint(parserCollada.lights.length);
+            this.var_16 = new Vector.<name_116>(numLights);
+            for(i = 0; i < numLights; i++)
+            {
+               this.var_16[i] = parserCollada.lights[i];
+               name_116(this.var_16[i]).alternativa3d::removeFromParent();
+            }
+         }
+      }
+      
+      private function getCompressedTextureResource(fileTextureResource:name_167, resourceCache:Object, mapFiles:name_55) : name_241
+      {
+         var textureName:String = null;
+         var resource:name_241 = null;
+         var textureData:ByteArray = null;
+         if(fileTextureResource != null && Boolean(fileTextureResource.url))
+         {
+            textureName = fileTextureResource.url.toLowerCase();
+            textureName = textureName.replace(".png",".atf");
+            textureName = textureName.replace(".jpg",".atf");
+            if(mapFiles.name_248(textureName) != null)
+            {
+               resource = resourceCache[textureName];
+               if(resource == null)
+               {
+                  textureData = mapFiles.name_248(textureName);
+                  resource = new name_241(textureData);
+                  resourceCache[textureName] = resource;
+               }
+               return resource;
+            }
+            trace("[WARN] texture not found:",fileTextureResource.url.toLowerCase());
+         }
+         return null;
+      }
+      
+      private function parseCollisionGeometry(a3dData:ByteArray) : void
+      {
+         var object:name_78 = null;
+         var objectName:String = null;
+         var parserA3D:name_529 = new name_529();
+         parserA3D.method_314(a3dData);
+         this.var_569 = new Vector.<name_235>();
+         for each(object in parserA3D.objects)
+         {
+            if(object is name_380)
+            {
+               objectName = object.name.toLowerCase();
+               if(objectName.indexOf("tri") == 0)
+               {
+                  name_642.name_644(name_380(object),this.var_569,name_257.STATIC,COLLISION_MASK);
+               }
+               else if(objectName.indexOf("box") == 0)
+               {
+                  name_642.name_646(name_380(object),this.var_569,name_257.STATIC,COLLISION_MASK);
+               }
+               else if(objectName.indexOf("plane") == 0)
+               {
+                  name_642.name_645(name_380(object),this.var_569,name_257.STATIC,COLLISION_MASK);
+               }
+            }
+         }
+      }
+   }
+}
+
+import flash.utils.ByteArray;
+import flash.utils.setTimeout;
+import package_116.name_529;
+import package_21.name_78;
+import package_27.class_7;
+
+class GeometryBuildTask extends class_7
+{
+   private var data:ByteArray;
+   
+   private var collector:Vector.<name_78>;
+   
+   public function GeometryBuildTask(data:ByteArray, collector:Vector.<name_78>)
+   {
+      super();
+      this.data = data;
+      this.collector = collector;
+   }
+   
+   override public function run() : void
+   {
+      var object:name_78 = null;
+      var parser:name_529 = new name_529();
+      parser.method_314(this.data);
+      for each(object in parser.objects)
+      {
+         this.collector.push(object);
+      }
+      setTimeout(method_102,0);
+   }
+}

src/alternativa/tanks/game/entities/map/A3DMapComponent.as

@@ -0,0 +1,421 @@
+package alternativa.tanks.game.entities.map
+{
+   import alternativa.engine3d.alternativa3d;
+   import flash.display.BitmapData;
+   import flash.events.Event;
+   import flash.ui.Keyboard;
+   import flash.utils.ByteArray;
+   import flash.utils.setTimeout;
+   import alternativa.tanks.game.EntityComponent;
+   import alternativa.tanks.game.GameKernel;
+   import package_109.name_377;
+   import package_109.name_378;
+   import package_109.name_381;
+   import package_15.name_55;
+   import package_18.name_44;
+   import package_18.name_79;
+   import package_18.name_89;
+   import package_19.name_380;
+   import package_19.name_53;
+   import package_19.name_91;
+   import package_21.name_116;
+   import package_21.name_126;
+   import package_21.name_77;
+   import package_21.name_78;
+   import package_22.name_83;
+   import package_24.DirectionalLight;
+   import package_24.OmniLight;
+   import package_24.SpotLight;
+   import package_24.name_376;
+   import package_28.name_119;
+   import package_28.name_241;
+   import package_28.name_93;
+   import package_4.class_4;
+   import package_4.class_5;
+   import package_4.name_313;
+   import package_44.name_178;
+   import package_46.Matrix4;
+   import package_46.name_194;
+   import alternativa.osgi.OSGi;
+   import alternativa.osgi.service.console.IConsole;
+   import package_76.name_235;
+   import package_96.name_279;
+   
+   use namespace alternativa3d;
+   
+   public class A3DMapComponent extends EntityComponent
+   {
+      public static const PHYSICS_GEOMETRY:String = "physicsGeometry";
+      
+      private var files:name_55;
+      
+      private var skyboxFiles:name_55;
+      
+      private var skyboxSize:Number;
+      
+      private var var_89:A3DMapBuilder;
+      
+      private var gameKernel:GameKernel;
+      
+      private var var_90:Number = 1.5;
+      
+      private var listener:IA3DMapComponentListener;
+      
+      private var var_91:Boolean = true;
+      
+      public function A3DMapComponent(files:name_55, skyboxFiles:name_55, skyboxSize:Number, listener:IA3DMapComponentListener)
+      {
+         super();
+         this.files = files;
+         this.skyboxFiles = skyboxFiles;
+         this.skyboxSize = skyboxSize;
+         this.listener = listener;
+      }
+      
+      override public function initComponent() : void
+      {
+      }
+      
+      override public function addToGame(gameKernel:GameKernel) : void
+      {
+         this.gameKernel = gameKernel;
+         this.createSkybox();
+         gameKernel.name_66().name_94(name_83.KEY_DOWN,this.onKeyDown);
+         if(gameKernel.options[MapOptions.FAKE_MAP] != null)
+         {
+            this.buildFakeMap();
+         }
+         else
+         {
+            this.buildRealMap();
+         }
+      }
+      
+      private function createSkybox() : void
+      {
+         var skyBox:name_53 = null;
+         var surfaceIds:Array = null;
+         var surfaceId:String = null;
+         var renderSystem:name_44 = null;
+         var container:name_78 = null;
+         var texture:ByteArray = null;
+         var textureResource:name_241 = null;
+         if(this.skyboxFiles != null)
+         {
+            skyBox = new name_53(this.skyboxSize);
+            surfaceIds = [name_53.BACK,name_53.BOTTOM,name_53.FRONT,name_53.LEFT,name_53.RIGHT,name_53.TOP];
+            for each(surfaceId in surfaceIds)
+            {
+               texture = this.skyboxFiles.name_248(surfaceId);
+               textureResource = new name_241(texture);
+               skyBox.name_383(surfaceId).material = new name_79(textureResource);
+            }
+            renderSystem = this.gameKernel.name_5();
+            renderSystem.method_32(skyBox.getResources(true));
+            container = renderSystem.method_40(name_44.SKYBOX_CONTAINER_ID);
+            container.addChild(skyBox);
+         }
+      }
+      
+      override public function removeFromGame(gameKernel:GameKernel) : void
+      {
+         var object:name_78 = null;
+         var lights:name_89 = null;
+         var light:name_116 = null;
+         var renderSystem:name_44 = gameKernel.name_5();
+         var mapGeometryContainer:name_78 = renderSystem.method_68();
+         for each(object in this.var_89.objects)
+         {
+            mapGeometryContainer.removeChild(object);
+         }
+         renderSystem.method_31(mapGeometryContainer.getResources(true));
+         lights = renderSystem.lights;
+         for each(light in this.var_89.lights)
+         {
+            if(light is DirectionalLight)
+            {
+               lights.directionalLigths.remove(DirectionalLight(light));
+            }
+            else if(light is name_376)
+            {
+               lights.ambientLight = null;
+            }
+            else if(light is SpotLight)
+            {
+               lights.spotLights.remove(SpotLight(light));
+            }
+            else if(light is OmniLight)
+            {
+               lights.omniLigths.remove(OmniLight(light));
+            }
+         }
+         gameKernel.name_66().name_384(name_83.KEY_DOWN,this.onKeyDown);
+         this.gameKernel = null;
+      }
+      
+      private function buildRealMap() : void
+      {
+         this.var_89 = new A3DMapBuilder();
+         this.var_89.addEventListener(Event.COMPLETE,this.onBuildingComplete);
+         this.var_89.name_385(this.files);
+      }
+      
+      private function onBuildingComplete(event:Event) : void
+      {
+         var staticShadowLight:DirectionalLight = this.initLights();
+         this.initGraphics(staticShadowLight);
+         this.initPhysics();
+         this.complete();
+      }
+      
+      private function complete() : void
+      {
+         this.gameKernel.name_5().method_58();
+         if(this.listener != null)
+         {
+            this.listener.onA3DMapComplete();
+         }
+      }
+      
+      private function initLights() : DirectionalLight
+      {
+         var staticShadowLight:DirectionalLight = null;
+         var light:name_116 = null;
+         if(Boolean(this.gameKernel.options["fakelight"]))
+         {
+            this.initFakeLight();
+            return null;
+         }
+         var renderSystem:name_44 = this.gameKernel.name_5();
+         var lights:name_89 = renderSystem.lights;
+         for each(light in this.var_89.lights)
+         {
+            if(light is DirectionalLight)
+            {
+               if(staticShadowLight == null)
+               {
+                  staticShadowLight = DirectionalLight(light);
+               }
+               lights.directionalLigths.add(DirectionalLight(light));
+            }
+            else if(light is name_376)
+            {
+               lights.ambientLight = name_376(light);
+            }
+            else if(light is SpotLight)
+            {
+               lights.spotLights.add(SpotLight(light));
+            }
+            else if(light is OmniLight)
+            {
+               lights.omniLigths.add(OmniLight(light));
+            }
+            if(light is name_376 || light is DirectionalLight)
+            {
+               light.intensity *= 2;
+            }
+            if(light is DirectionalLight || light is name_376)
+            {
+               light.boundBox = null;
+            }
+            else
+            {
+               light.calculateBoundBox();
+            }
+         }
+         return staticShadowLight;
+      }
+      
+      private function initFakeLight() : void
+      {
+         this.gameKernel.name_5().lights.ambientLight = new name_376(16777215);
+      }
+      
+      private function initGraphics(staticShadowLight:DirectionalLight) : void
+      {
+         var object:name_78 = null;
+         var renderSystem:name_44 = this.gameKernel.name_5();
+         var mapGeometryContainer:name_78 = renderSystem.method_68();
+         for each(object in this.var_89.objects)
+         {
+            mapGeometryContainer.addChild(object);
+         }
+         renderSystem.method_32(mapGeometryContainer.getResources(true));
+         if(staticShadowLight != null)
+         {
+            renderSystem.method_71(staticShadowLight);
+         }
+      }
+      
+      private function initPhysics() : void
+      {
+         var renderSystem:name_44 = null;
+         var physicsContainer:name_78 = null;
+         var physicsSystem:name_178 = this.gameKernel.method_112();
+         physicsSystem.name_382(this.var_89.collisionPrimitives);
+         if(this.gameKernel.options[MapOptions.VISUALIZE_PHYSICS] != null)
+         {
+            renderSystem = this.gameKernel.name_5();
+            physicsContainer = this.createPhysicsVisualObjects(this.var_89.collisionPrimitives);
+            physicsContainer.visible = false;
+            renderSystem.method_47(PHYSICS_GEOMETRY,physicsContainer,true);
+         }
+      }
+      
+      private function createPhysicsVisualObjects(collisionPrimitives:Vector.<name_235>) : name_78
+      {
+         var collisionPrimitive:name_235 = null;
+         var physicsVisualContainer:name_78 = new name_78();
+         var boxMaterial:name_313 = new name_313(11141120);
+         var triangleMaterial:name_313 = new name_313(43520);
+         var numCollisionPrimitives:int = int(collisionPrimitives.length);
+         for(var i:int = 0; i < numCollisionPrimitives; )
+         {
+            collisionPrimitive = collisionPrimitives[i];
+            if(collisionPrimitive is name_377)
+            {
+               physicsVisualContainer.addChild(this.createPhysicsVisualBox(name_377(collisionPrimitive),boxMaterial));
+            }
+            else if(collisionPrimitive is name_378)
+            {
+               physicsVisualContainer.addChild(this.createPhysicsVisualTriangle(name_378(collisionPrimitive),triangleMaterial));
+            }
+            i++;
+         }
+         return physicsVisualContainer;
+      }
+      
+      private function createPhysicsVisualBox(collisionBox:name_377, material:class_4) : name_279
+      {
+         var size:name_194 = collisionBox.hs.clone().scale(2);
+         var box:name_279 = new name_279(size.x,size.y,size.z);
+         box.setMaterialToAllSurfaces(material);
+         this.setPhysicsTransform(collisionBox,box);
+         return box;
+      }
+      
+      private function createPhysicsVisualTriangle(collisionTriangle:name_378, material:class_4) : name_380
+      {
+         var mesh:name_380 = new name_380();
+         var geometry:name_119 = new name_119();
+         var attributes:Array = [];
+         attributes[0] = name_126.POSITION;
+         attributes[1] = name_126.POSITION;
+         attributes[2] = name_126.POSITION;
+         geometry.addVertexStream(attributes);
+         geometry.numVertices = 3;
+         var values:Vector.<Number> = new Vector.<Number>(9);
+         values[0] = collisionTriangle.v0.x;
+         values[1] = collisionTriangle.v0.y;
+         values[2] = collisionTriangle.v0.z;
+         values[3] = collisionTriangle.v1.x;
+         values[4] = collisionTriangle.v1.y;
+         values[5] = collisionTriangle.v1.z;
+         values[6] = collisionTriangle.v2.x;
+         values[7] = collisionTriangle.v2.y;
+         values[8] = collisionTriangle.v2.z;
+         geometry.setAttributeValues(name_126.POSITION,values);
+         geometry.indices = Vector.<uint>([0,1,2]);
+         mesh.geometry = geometry;
+         mesh.addSurface(material,0,1);
+         mesh.calculateBoundBox();
+         this.setPhysicsTransform(collisionTriangle,mesh);
+         return mesh;
+      }
+      
+      private function setPhysicsTransform(collisionPrimitive:name_235, object:name_78) : void
+      {
+         var t:Matrix4 = collisionPrimitive.transform;
+         var eulerAngles:name_194 = new name_194();
+         t.name_341(eulerAngles);
+         object.x = t.d;
+         object.y = t.h;
+         object.z = t.l;
+         object.rotationX = eulerAngles.x;
+         object.rotationY = eulerAngles.y;
+         object.rotationZ = eulerAngles.z;
+      }
+      
+      private function buildFakeMap() : void
+      {
+         var collisionRect:name_381 = new name_381(new name_194(20000,20000),1,255);
+         var collisionPrimitives:Vector.<name_235> = Vector.<name_235>([collisionRect]);
+         this.gameKernel.method_112().name_382(collisionPrimitives);
+         var renderSystem:name_44 = this.gameKernel.name_5();
+         renderSystem.method_40(name_44.LIGHTS_CONTAINER_ID).addChild(new name_376(16777215));
+         this.addZeroMarker(renderSystem);
+         var bitmapData:BitmapData = new BitmapData(512,512);
+         bitmapData.perlinNoise(10,10,3,13,false,true);
+         var bitmapTextureResource:name_93 = new name_93(bitmapData);
+         var box:name_279 = new name_279(2 * 20000,2 * 20000,10);
+         box.setMaterialToAllSurfaces(new class_5(bitmapTextureResource));
+         box.z = -5;
+         renderSystem.method_68().addChild(box);
+         renderSystem.method_32(box.getResources());
+         setTimeout(this.complete,0);
+      }
+      
+      private function addZeroMarker(renderSystem:name_44) : void
+      {
+         var resource:name_77 = null;
+         var box:name_279 = new name_279(50,50,50);
+         box.setMaterialToAllSurfaces(new name_313(11141120));
+         for each(resource in box.getResources())
+         {
+            renderSystem.method_29(resource);
+         }
+         renderSystem.method_68().addChild(box);
+      }
+      
+      private function onKeyDown(eventType:name_83, keyCode:uint) : void
+      {
+         switch(keyCode)
+         {
+            case Keyboard.F1:
+            case Keyboard.F2:
+            case Keyboard.F3:
+            case Keyboard.NUMBER_6:
+            case Keyboard.COMMA:
+            case Keyboard.PERIOD:
+            case Keyboard.SEMICOLON:
+            case Keyboard.QUOTE:
+         }
+      }
+      
+      private function toggleDecals() : void
+      {
+         var d:name_91 = null;
+         this.var_91 = !this.var_91;
+         for each(d in this.var_89.decals)
+         {
+            d.visible = this.var_91;
+         }
+      }
+      
+      private function get decalsOffset() : Number
+      {
+         return this.var_90;
+      }
+      
+      private function set decalsOffset(value:Number) : void
+      {
+         var decal:name_91 = null;
+         this.var_90 = value;
+         for each(decal in this.var_89.decals)
+         {
+            decal.offset = this.var_90;
+         }
+         IConsole(OSGi.name_8().name_30(IConsole)).name_145("Decals offset: " + this.var_90);
+      }
+      
+      private function toggleGeometry(containerId:String) : void
+      {
+         var container:name_78 = this.gameKernel.name_5().method_40(containerId);
+         if(container != null)
+         {
+            container.visible = !container.visible;
+         }
+      }
+   }
+}
+

src/alternativa/tanks/game/entities/map/IA3DMapComponentListener.as

@@ -0,0 +1,8 @@
+package alternativa.tanks.game.entities.map
+{
+   public interface IA3DMapComponentListener
+   {
+      function onA3DMapComplete() : void;
+   }
+}
+

src/alternativa/tanks/game/entities/map/MapMaterial.as

@@ -0,0 +1,391 @@
+package alternativa.tanks.game.entities.map
+{
+   import alternativa.engine3d.alternativa3d;
+   import avmplus.getQualifiedClassName;
+   import flash.display.BitmapData;
+   import flash.display3D.Context3DBlendFactor;
+   import flash.display3D.Context3DProgramType;
+   import flash.display3D.VertexBuffer3D;
+   import flash.utils.Dictionary;
+   import flash.utils.getDefinitionByName;
+   import package_19.name_117;
+   import package_21.name_116;
+   import package_21.name_124;
+   import package_21.name_126;
+   import package_21.name_128;
+   import package_21.name_135;
+   import package_21.name_139;
+   import package_21.name_78;
+   import package_23.name_103;
+   import package_28.name_119;
+   import package_28.name_129;
+   import package_28.name_93;
+   import package_30.name_114;
+   import package_30.name_115;
+   import package_30.name_121;
+   import package_4.class_4;
+   import package_4.name_28;
+   
+   use namespace alternativa3d;
+   
+   public class MapMaterial extends class_4
+   {
+      private static var fogTexture:name_129;
+      
+      public static const DISABLED:int = 0;
+      
+      public static const SIMPLE:int = 1;
+      
+      public static const ADVANCED:int = 2;
+      
+      public static var fogMode:int = DISABLED;
+      
+      public static var fogNear:Number = 1000;
+      
+      public static var fogFar:Number = 5000;
+      
+      public static var fogMaxDensity:Number = 1;
+      
+      public static var fogColorR:Number = 200 / 255;
+      
+      public static var fogColorG:Number = 162 / 255;
+      
+      public static var fogColorB:Number = 200 / 255;
+      
+      private static var _programs:Dictionary = new Dictionary();
+      
+      private static const getLightMapProcedure:name_114 = name_114.name_140(["#v0=vUV1","#s0=sLightMap","tex o0, v0, s0 <2d,repeat,linear,mipnone>"],"getLightMap");
+      
+      private static const minShadowProcedure:name_114 = name_114.name_140(["min o0, o0, i0"],"minShadowProc");
+      
+      private static const mulShadowProcedure:name_114 = name_114.name_140(["mul o0, o0, i0"],"mulShadowProc");
+      
+      private static const applyLightMapProcedure:name_114 = name_114.name_140(["add i1, i1, i1","mul i0.xyz, i0.xyz, i1.xyz","mov o0, i0"],"applyLightMap");
+      
+      private static const _passLightMapUVProcedure:name_114 = new name_114(["#a0=aUV1","#v0=vUV1","mov v0, a0"],"passLightMapUV");
+      
+      private static const passSimpleFogConstProcedure:name_114 = new name_114(["#v0=vZDistance","#c0=cFogSpace","dp4 t0.z, i0, c0","mov v0, t0.zzzz","sub v0.y, i0.w, t0.z"],"passSimpleFogConst");
+      
+      private static const applyLightMapAndSimpleFogProcedure:name_114 = new name_114(["#v0=vZDistance","#c0=cFogColor","#c1=cFogRange","add i1, i1, i1","mul i0.xyz, i0.xyz, i1.xyz","min t0.xy, v0.xy, c1.xy","max t0.xy, t0.xy, c1.zw","mul i0.xyz, i0.xyz, t0.y","mul t0.xyz, c0.xyz, t0.x","add i0.xyz, i0.xyz, t0.xyz","mov o0, i0"],"applyLightMapAndSimpleFog");
+      
+      private static const passAdvancedFogConstProcedure:name_114 = new name_114(["#v0=vZDistance","#c0=cFogSpace","dp4 t0.z, i0, c0","mov v0, t0.zzzz","sub v0.y, i0.w, t0.z","mov v0.zw, i1.xwxw","mov o0, i1"],"projAndPassAdvancedFogConst");
+      
+      private static const applyLightMapAndAdvancedFogProcedure:name_114 = new name_114(["#v0=vZDistance","#c0=cFogConsts","#c1=cFogRange","#s0=sFogTexture","add i1, i1, i1","mul i0.xyz, i0.xyz, i1.xyz","min t0.xy, v0.xy, c1.xy","max t0.xy, t0.xy, c1.zw","mul i0.xyz, i0.xyz, t0.y","mov t1.xyzw, c0.yyzw","div t0.z, v0.z, v0.w","mul t0.z, t0.z, c0.x","add t1.x, t1.x, t0.z","tex t1, t1, s0 <2d, repeat, linear, miplinear>","mul t0.xyz, t1.xyz, t0.x","add i0.xyz, i0.xyz, t0.xyz","mov o0, i0"],"applyLightMapAndAdvancedFog");
+      
+      alternativa3d static const outputOpacity:name_114 = new name_114(["#v0=vUV","#s0=sTexture","#s1=sOpacity","#c0=cAlpha","tex t0, v0, s0 <2d, linear,repeat, miplinear>","tex t1, v0, s1 <2d, linear,repeat, miplinear>","mov t0.w, t1.x","sub t1.x, t1.x, c0.w","kil t1.x","mov o0, t0"],"samplerSetProcedureOpacity");
+      
+      private static const passUVProcedure:name_114 = new name_114(["#v0=vUV","#a0=aUV","mov v0, a0"],"passUVProcedure");
+      
+      private static const diffuseProcedure:name_114 = new name_114(["#v0=vUV","#s0=sTexture","#c0=cAlpha","tex t0, v0, s0 <2d, linear,repeat, miplinear>","mov t0.w, c0.w","mov o0, t0"],"diffuseProcedure");
+      
+      private static const diffuseOpacityProcedure:name_114 = new name_114(["#v0=vUV","#s0=sTexture","#s1=sOpacity","#c0=cAlpha","tex t0, v0, s0 <2d, linear,repeat, miplinear>","tex t1, v0, s1 <2d, linear,repeat, miplinear>","mov t0.w, t1.x","mul t0.w, t0.w, c0.w","mov o0, t0"],"diffuseOpacityProcedure");
+      
+      public var diffuseMap:name_129;
+      
+      public var lightMap:name_129;
+      
+      public var lightMapChannel:uint = 0;
+      
+      public var opacityMap:name_129;
+      
+      public var alpha:Number = 1;
+      
+      public function MapMaterial(diffuseMap:name_129, lightMap:name_129, lightMapChannel:uint = 0, opacityMap:name_129 = null)
+      {
+         super();
+         this.diffuseMap = diffuseMap;
+         this.lightMap = lightMap;
+         this.lightMapChannel = lightMapChannel;
+         this.opacityMap = opacityMap;
+      }
+      
+      public static function method_33(texture:name_129) : void
+      {
+         fogTexture = texture;
+      }
+      
+      override alternativa3d function fillResources(resources:Dictionary, resourceType:Class) : void
+      {
+         super.alternativa3d::fillResources(resources,resourceType);
+         if(this.diffuseMap != null && Boolean(name_28.alternativa3d::name_131(getDefinitionByName(getQualifiedClassName(this.diffuseMap)) as Class,resourceType)))
+         {
+            resources[this.diffuseMap] = true;
+         }
+         if(this.lightMap != null && Boolean(name_28.alternativa3d::name_131(getDefinitionByName(getQualifiedClassName(this.lightMap)) as Class,resourceType)))
+         {
+            resources[this.lightMap] = true;
+         }
+         if(this.opacityMap != null && Boolean(name_28.alternativa3d::name_131(getDefinitionByName(getQualifiedClassName(this.opacityMap)) as Class,resourceType)))
+         {
+            resources[this.opacityMap] = true;
+         }
+      }
+      
+      private function setupProgram(targetObject:name_78, shadows:Vector.<name_103>, numShadows:int) : MapMaterialProgram
+      {
+         var i:int = 0;
+         var renderer:name_103 = null;
+         var sProc:name_114 = null;
+         var vertexLinker:name_121 = new name_121(Context3DProgramType.VERTEX);
+         var positionVar:String = "aPosition";
+         vertexLinker.name_120(positionVar,name_115.ATTRIBUTE);
+         if(targetObject.alternativa3d::transformProcedure != null)
+         {
+            positionVar = alternativa3d::method_74(targetObject.alternativa3d::transformProcedure,vertexLinker);
+         }
+         vertexLinker.name_123(alternativa3d::_projectProcedure);
+         vertexLinker.name_118(alternativa3d::_projectProcedure,positionVar);
+         vertexLinker.name_123(passUVProcedure);
+         vertexLinker.name_123(_passLightMapUVProcedure);
+         if(fogMode == SIMPLE)
+         {
+            vertexLinker.name_123(passSimpleFogConstProcedure);
+            vertexLinker.name_118(passSimpleFogConstProcedure,positionVar);
+         }
+         else if(fogMode == ADVANCED)
+         {
+            vertexLinker.name_120("tProjected");
+            vertexLinker.name_125(alternativa3d::_projectProcedure,"tProjected");
+            vertexLinker.name_123(passAdvancedFogConstProcedure);
+            vertexLinker.name_118(passAdvancedFogConstProcedure,positionVar,"tProjected");
+         }
+         var fragmentLinker:name_121 = new name_121(Context3DProgramType.FRAGMENT);
+         var procedure:name_114 = this.opacityMap == null ? diffuseProcedure : diffuseOpacityProcedure;
+         fragmentLinker.name_120("tOutColor");
+         fragmentLinker.name_123(procedure);
+         fragmentLinker.name_125(procedure,"tOutColor");
+         if(shadows != null)
+         {
+            fragmentLinker.name_120("tLight");
+            fragmentLinker.name_123(getLightMapProcedure);
+            fragmentLinker.name_125(getLightMapProcedure,"tLight");
+            fragmentLinker.name_120("tShadow");
+            for(i = 0; i < numShadows; i++)
+            {
+               renderer = shadows[i];
+               vertexLinker.name_123(renderer.getVShader(i));
+               sProc = renderer.getFShader(i);
+               fragmentLinker.name_123(sProc);
+               fragmentLinker.name_125(sProc,"tShadow");
+               if(renderer.alternativa3d::name_372)
+               {
+                  fragmentLinker.name_123(mulShadowProcedure);
+                  fragmentLinker.name_118(mulShadowProcedure,"tShadow");
+                  fragmentLinker.name_125(mulShadowProcedure,"tLight");
+               }
+               else
+               {
+                  fragmentLinker.name_123(minShadowProcedure);
+                  fragmentLinker.name_118(minShadowProcedure,"tShadow");
+                  fragmentLinker.name_125(minShadowProcedure,"tLight");
+               }
+            }
+         }
+         else
+         {
+            fragmentLinker.name_120("tLight");
+            fragmentLinker.name_123(getLightMapProcedure);
+            fragmentLinker.name_125(getLightMapProcedure,"tLight");
+         }
+         if(fogMode == SIMPLE)
+         {
+            fragmentLinker.name_123(applyLightMapAndSimpleFogProcedure);
+            fragmentLinker.name_118(applyLightMapAndSimpleFogProcedure,"tOutColor","tLight");
+         }
+         else if(fogMode == ADVANCED)
+         {
+            fragmentLinker.name_123(applyLightMapAndAdvancedFogProcedure);
+            fragmentLinker.name_118(applyLightMapAndAdvancedFogProcedure,"tOutColor","tLight");
+         }
+         else
+         {
+            fragmentLinker.name_123(applyLightMapProcedure);
+            fragmentLinker.name_118(applyLightMapProcedure,"tOutColor","tLight");
+         }
+         fragmentLinker.name_133(vertexLinker);
+         return new MapMaterialProgram(vertexLinker,fragmentLinker);
+      }
+      
+      override alternativa3d function collectDraws(camera:name_124, surface:name_117, geometry:name_119, lights:Vector.<name_116>, lightsLength:int, objectRenderPriority:int = -1) : void
+      {
+         var i:int = 0;
+         var renderer:name_103 = null;
+         var lm:name_139 = null;
+         var dist:Number = NaN;
+         var cLocal:name_139 = null;
+         var halfW:Number = NaN;
+         var leftX:Number = NaN;
+         var leftY:Number = NaN;
+         var rightX:Number = NaN;
+         var rightY:Number = NaN;
+         var angle:Number = NaN;
+         var dx:Number = NaN;
+         var dy:Number = NaN;
+         var len:Number = NaN;
+         var uScale:Number = NaN;
+         var uRight:Number = NaN;
+         var bmd:BitmapData = null;
+         if(this.diffuseMap == null || this.diffuseMap.alternativa3d::_texture == null || this.lightMap == null || this.lightMap.alternativa3d::_texture == null)
+         {
+            return;
+         }
+         if(this.opacityMap != null && this.opacityMap.alternativa3d::_texture == null)
+         {
+            return;
+         }
+         var positionBuffer:VertexBuffer3D = geometry.alternativa3d::getVertexBuffer(name_126.POSITION);
+         var uvBuffer:VertexBuffer3D = geometry.alternativa3d::getVertexBuffer(name_126.TEXCOORDS[0]);
+         var lightMapUVBuffer:VertexBuffer3D = geometry.alternativa3d::getVertexBuffer(name_126.TEXCOORDS[this.lightMapChannel]);
+         if(positionBuffer == null || uvBuffer == null || lightMapUVBuffer == null)
+         {
+            return;
+         }
+         var object:name_78 = surface.alternativa3d::object;
+         var optionsPrograms:Vector.<MapMaterialProgram> = _programs[object.alternativa3d::transformProcedure];
+         if(optionsPrograms == null)
+         {
+            optionsPrograms = new Vector.<MapMaterialProgram>(32,true);
+            _programs[object.alternativa3d::transformProcedure] = optionsPrograms;
+         }
+         var index:int = this.opacityMap == null ? 0 : 1;
+         if(fogMode > 0)
+         {
+            index |= 1 << fogMode;
+         }
+         var numShadows:int = int(object.alternativa3d::numShadowRenderers);
+         index |= numShadows << 3;
+         var program:MapMaterialProgram = optionsPrograms[index];
+         if(program == null)
+         {
+            program = this.setupProgram(object,object.alternativa3d::shadowRenderers,numShadows);
+            program.upload(camera.alternativa3d::context3D);
+            optionsPrograms[index] = program;
+         }
+         var drawUnit:name_135 = camera.alternativa3d::renderer.alternativa3d::name_137(object,program.program,geometry.alternativa3d::name_132,surface.indexBegin,surface.numTriangles,program);
+         drawUnit.alternativa3d::setVertexBufferAt(program.aPosition,positionBuffer,geometry.alternativa3d::_attributesOffsets[name_126.POSITION],name_126.alternativa3d::FORMATS[name_126.POSITION]);
+         drawUnit.alternativa3d::setVertexBufferAt(program.aUV,uvBuffer,geometry.alternativa3d::_attributesOffsets[name_126.TEXCOORDS[0]],name_126.alternativa3d::FORMATS[name_126.TEXCOORDS[0]]);
+         drawUnit.alternativa3d::setVertexBufferAt(program.aUV1,lightMapUVBuffer,geometry.alternativa3d::_attributesOffsets[name_126.TEXCOORDS[this.lightMapChannel]],name_126.alternativa3d::FORMATS[name_126.TEXCOORDS[this.lightMapChannel]]);
+         object.alternativa3d::setTransformConstants(drawUnit,surface,program.vertexShader,camera);
+         drawUnit.alternativa3d::name_136(camera,program.cProjMatrix,object.alternativa3d::localToCameraTransform);
+         drawUnit.alternativa3d::name_134(program.cAlpha,0,0,0,this.alpha);
+         drawUnit.alternativa3d::setTextureAt(program.sTexture,this.diffuseMap.alternativa3d::_texture);
+         drawUnit.alternativa3d::setTextureAt(program.sLightMap,this.lightMap.alternativa3d::_texture);
+         if(this.opacityMap != null)
+         {
+            drawUnit.alternativa3d::setTextureAt(program.sOpacity,this.opacityMap.alternativa3d::_texture);
+         }
+         for(i = 0; i < numShadows; )
+         {
+            renderer = object.alternativa3d::shadowRenderers[i];
+            renderer.applyShader(drawUnit,program,object,camera,i);
+            i++;
+         }
+         if(fogMode == SIMPLE || fogMode == ADVANCED)
+         {
+            lm = object.alternativa3d::localToCameraTransform;
+            dist = fogFar - fogNear;
+            drawUnit.alternativa3d::name_144(program.cFogSpace,lm.i / dist,lm.j / dist,lm.k / dist,(lm.l - fogNear) / dist);
+            drawUnit.alternativa3d::name_134(program.cFogRange,fogMaxDensity,1,0,1 - fogMaxDensity);
+         }
+         if(fogMode == SIMPLE)
+         {
+            drawUnit.alternativa3d::name_134(program.cFogColor,fogColorR,fogColorG,fogColorB);
+         }
+         if(fogMode == ADVANCED)
+         {
+            if(fogTexture == null)
+            {
+               bmd = new BitmapData(32,1,false,16711680);
+               for(i = 0; i < 32; i++)
+               {
+                  bmd.setPixel(i,0,i / 32 * 255 << 16);
+               }
+               fogTexture = new name_93(bmd);
+               fogTexture.upload(camera.alternativa3d::context3D);
+            }
+            cLocal = camera.alternativa3d::localToGlobalTransform;
+            halfW = camera.view.width / 2;
+            leftX = -halfW * cLocal.a + camera.alternativa3d::focalLength * cLocal.c;
+            leftY = -halfW * cLocal.e + camera.alternativa3d::focalLength * cLocal.g;
+            rightX = halfW * cLocal.a + camera.alternativa3d::focalLength * cLocal.c;
+            rightY = halfW * cLocal.e + camera.alternativa3d::focalLength * cLocal.g;
+            angle = Math.atan2(leftY,leftX) - Math.PI / 2;
+            if(angle < 0)
+            {
+               angle += Math.PI * 2;
+            }
+            dx = rightX - leftX;
+            dy = rightY - leftY;
+            len = Number(Math.sqrt(dx * dx + dy * dy));
+            leftX /= len;
+            leftY /= len;
+            rightX /= len;
+            rightY /= len;
+            uScale = Math.acos(leftX * rightX + leftY * rightY) / Math.PI / 2;
+            uRight = angle / Math.PI / 2;
+            drawUnit.alternativa3d::name_134(program.cFogConsts,0.5 * uScale,0.5 - uRight,0);
+            drawUnit.alternativa3d::setTextureAt(program.sFogTexture,fogTexture.alternativa3d::_texture);
+         }
+         if(this.opacityMap != null || this.alpha < 1)
+         {
+            drawUnit.alternativa3d::blendSource = Context3DBlendFactor.SOURCE_ALPHA;
+            drawUnit.alternativa3d::blendDestination = Context3DBlendFactor.ONE_MINUS_SOURCE_ALPHA;
+            camera.alternativa3d::renderer.alternativa3d::name_130(drawUnit,objectRenderPriority >= 0 ? objectRenderPriority : name_128.TRANSPARENT_SORT);
+         }
+         else
+         {
+            camera.alternativa3d::renderer.alternativa3d::name_130(drawUnit,objectRenderPriority >= 0 ? objectRenderPriority : name_128.OPAQUE);
+         }
+      }
+   }
+}
+
+import package_30.name_121;
+import package_4.name_127;
+
+class MapMaterialProgram extends name_127
+{
+   public var aPosition:int;
+   
+   public var aUV:int;
+   
+   public var aUV1:int;
+   
+   public var cProjMatrix:int;
+   
+   public var cAlpha:int;
+   
+   public var sTexture:int;
+   
+   public var sLightMap:int;
+   
+   public var sOpacity:int;
+   
+   public var cFogSpace:int;
+   
+   public var cFogRange:int;
+   
+   public var cFogColor:int;
+   
+   public var cFogConsts:int;
+   
+   public var sFogTexture:int;
+   
+   public function MapMaterialProgram(vertex:name_121, fragment:name_121)
+   {
+      super(vertex,fragment);
+      this.aPosition = vertex.name_207("aPosition");
+      this.aUV = vertex.name_207("aUV");
+      this.aUV1 = vertex.name_207("aUV1");
+      this.cProjMatrix = vertex.name_207("cProjMatrix");
+      this.cAlpha = fragment.name_207("cAlpha");
+      this.sTexture = fragment.name_207("sTexture");
+      this.sLightMap = fragment.name_207("sLightMap");
+      this.sOpacity = fragment.name_207("sOpacity");
+      this.cFogSpace = vertex.name_207("cFogSpace");
+      this.cFogRange = fragment.name_207("cFogRange");
+      this.cFogColor = fragment.name_207("cFogColor");
+      this.cFogConsts = fragment.name_207("cFogConsts");
+      this.sFogTexture = fragment.name_207("sFogTexture");
+   }
+}

src/alternativa/tanks/game/entities/map/MapOptions.as

@@ -0,0 +1,15 @@
+package alternativa.tanks.game.entities.map
+{
+   public class MapOptions
+   {
+      public static const FAKE_MAP:String = "fakemap";
+      
+      public static const VISUALIZE_PHYSICS:String = "visualizePhysics";
+      
+      public function MapOptions()
+      {
+         super();
+      }
+   }
+}
+

src/alternativa/tanks/game/entities/map/VisibleLightMaterial.as

@@ -0,0 +1,134 @@
+package alternativa.tanks.game.entities.map
+{
+   import alternativa.engine3d.alternativa3d;
+   import flash.display3D.Context3DBlendFactor;
+   import flash.display3D.Context3DProgramType;
+   import flash.display3D.VertexBuffer3D;
+   import flash.utils.Dictionary;
+   import flash.utils.getDefinitionByName;
+   import flash.utils.getQualifiedClassName;
+   import package_19.name_117;
+   import package_21.name_116;
+   import package_21.name_124;
+   import package_21.name_126;
+   import package_21.name_128;
+   import package_21.name_135;
+   import package_21.name_139;
+   import package_21.name_78;
+   import package_28.name_119;
+   import package_28.name_129;
+   import package_30.name_114;
+   import package_30.name_115;
+   import package_30.name_121;
+   import package_4.class_4;
+   import package_4.name_127;
+   import package_4.name_28;
+   
+   use namespace alternativa3d;
+   
+   public class VisibleLightMaterial extends class_4
+   {
+      public static var fadeRadius:Number = 100;
+      
+      public static var spotAngle:Number = 0;
+      
+      public static var fallofAngle:Number = Math.PI;
+      
+      private static var _programs:Dictionary = new Dictionary();
+      
+      private static const passColorProcedure:name_114 = new name_114(["#a0=aUV","#v0=vUV","#v1=vCameraPos","#v2=vNormal","#c0=cCameraPos","mov v0, a0","sub v1, c0, i0","mov v2, i1"],"passColor");
+      
+      private static const outputProcedure:name_114 = new name_114(["#v0=vUV","#v1=vCameraPos","#v2=vNormal","#c0=cZone","#s0=sTexture","dp3 t1.w, v1, v1","rsq t1.w, t1.w","mul t0.xyz, v1.xyz, t1.w","nrm t1.xyz, v2","dp3 t1.x, t0.xyz, t1.xyz","add t1.x, t1.x, c0.z","mul t1.x, t1.x, c0.y","sat t1.x, t1.x","div t1.w, c0.x, t1.w","sat t1.w, t1.w","mul t1.x, t1.x, t1.w","tex t0, v0, s0 <2d, clamp, linear, miplinear>","mul t0, t0.x, t1.x","mov o0, t0"],"output");
+      
+      public var texture:name_129;
+      
+      public function VisibleLightMaterial(texture:name_129)
+      {
+         super();
+         this.texture = texture;
+      }
+      
+      override alternativa3d function fillResources(resources:Dictionary, resourceType:Class) : void
+      {
+         super.alternativa3d::fillResources(resources,resourceType);
+         if(this.texture != null && Boolean(name_28.alternativa3d::name_131(getDefinitionByName(getQualifiedClassName(this.texture)) as Class,resourceType)))
+         {
+            resources[this.texture] = true;
+         }
+      }
+      
+      private function setupProgram(targetObject:name_78) : name_127
+      {
+         var vertexLinker:name_121 = new name_121(Context3DProgramType.VERTEX);
+         var fragmentLinker:name_121 = new name_121(Context3DProgramType.FRAGMENT);
+         var positionVar:String = "aPosition";
+         vertexLinker.name_120(positionVar,name_115.ATTRIBUTE);
+         if(targetObject.alternativa3d::transformProcedure != null)
+         {
+            positionVar = alternativa3d::method_74(targetObject.alternativa3d::transformProcedure,vertexLinker);
+         }
+         vertexLinker.name_123(alternativa3d::_projectProcedure);
+         vertexLinker.name_118(alternativa3d::_projectProcedure,positionVar);
+         var normalVar:String = "aNormal";
+         vertexLinker.name_120(normalVar,name_115.ATTRIBUTE);
+         if(targetObject.alternativa3d::deltaTransformProcedure != null)
+         {
+            vertexLinker.name_120("tTransformedNormal");
+            vertexLinker.name_123(targetObject.alternativa3d::deltaTransformProcedure);
+            vertexLinker.name_118(targetObject.alternativa3d::deltaTransformProcedure,normalVar);
+            vertexLinker.name_125(targetObject.alternativa3d::deltaTransformProcedure,"tTransformedNormal");
+            normalVar = "tTransformedNormal";
+         }
+         vertexLinker.name_123(passColorProcedure);
+         vertexLinker.name_118(passColorProcedure,positionVar,normalVar);
+         fragmentLinker.name_123(outputProcedure);
+         fragmentLinker.name_133(vertexLinker);
+         vertexLinker.name_142();
+         fragmentLinker.name_142();
+         return new name_127(vertexLinker,fragmentLinker);
+      }
+      
+      override alternativa3d function collectDraws(camera:name_124, surface:name_117, geometry:name_119, lights:Vector.<name_116>, lightsLength:int, objectRenderPriority:int = -1) : void
+      {
+         if(this.texture == null || this.texture.alternativa3d::_texture == null)
+         {
+            return;
+         }
+         var positionBuffer:VertexBuffer3D = geometry.alternativa3d::getVertexBuffer(name_126.POSITION);
+         var uvBuffer:VertexBuffer3D = geometry.alternativa3d::getVertexBuffer(name_126.TEXCOORDS[0]);
+         var normalsBuffer:VertexBuffer3D = geometry.alternativa3d::getVertexBuffer(name_126.NORMAL);
+         if(positionBuffer == null || uvBuffer == null || normalsBuffer == null)
+         {
+            return;
+         }
+         var object:name_78 = surface.alternativa3d::object;
+         var program:name_127 = _programs[object.alternativa3d::transformProcedure];
+         if(program == null)
+         {
+            program = this.setupProgram(object);
+            program.upload(camera.alternativa3d::context3D);
+            _programs[object.alternativa3d::transformProcedure] = program;
+         }
+         var drawUnit:name_135 = camera.alternativa3d::renderer.alternativa3d::name_137(object,program.program,geometry.alternativa3d::name_132,surface.indexBegin,surface.numTriangles,program);
+         drawUnit.alternativa3d::setVertexBufferAt(program.vertexShader.getVariableIndex("aPosition"),positionBuffer,geometry.alternativa3d::_attributesOffsets[name_126.POSITION],name_126.alternativa3d::FORMATS[name_126.POSITION]);
+         drawUnit.alternativa3d::setVertexBufferAt(program.vertexShader.getVariableIndex("aUV"),uvBuffer,geometry.alternativa3d::_attributesOffsets[name_126.TEXCOORDS[0]],name_126.alternativa3d::FORMATS[name_126.TEXCOORDS[0]]);
+         drawUnit.alternativa3d::setVertexBufferAt(program.vertexShader.getVariableIndex("aNormal"),normalsBuffer,geometry.alternativa3d::_attributesOffsets[name_126.NORMAL],name_126.alternativa3d::FORMATS[name_126.NORMAL]);
+         object.alternativa3d::setTransformConstants(drawUnit,surface,program.vertexShader,camera);
+         drawUnit.alternativa3d::name_136(camera,program.vertexShader.getVariableIndex("cProjMatrix") << 2,object.alternativa3d::localToCameraTransform);
+         var tm:name_139 = object.alternativa3d::cameraToLocalTransform;
+         drawUnit.alternativa3d::name_144(program.vertexShader.getVariableIndex("cCameraPos"),tm.d,tm.h,tm.l);
+         var offset:Number = Number(Math.cos(fallofAngle / 2));
+         var mul:Number = Math.cos(spotAngle / 2) - offset;
+         if(mul < 0.00001)
+         {
+            mul = 0.00001;
+         }
+         drawUnit.alternativa3d::name_134(program.fragmentShader.getVariableIndex("cZone"),1 / fadeRadius,(1 - offset) / mul,-offset);
+         drawUnit.alternativa3d::setTextureAt(program.fragmentShader.getVariableIndex("sTexture"),this.texture.alternativa3d::_texture);
+         drawUnit.alternativa3d::blendSource = Context3DBlendFactor.ONE;
+         drawUnit.alternativa3d::blendDestination = Context3DBlendFactor.ONE;
+         camera.alternativa3d::renderer.alternativa3d::name_130(drawUnit,objectRenderPriority >= 0 ? objectRenderPriority : name_128.TRANSPARENT_SORT);
+      }
+   }
+}
+