package_10 alternativa.tanks.game

src/alternativa/tanks/game/Entity.as

@@ -0,0 +1,116 @@
+package alternativa.tanks.game
+{
+   public class Entity
+   {
+      private static var lastId:int;
+      
+      private var var_101:int;
+      
+      private var components:Vector.<EntityComponent>;
+      
+      private var var_100:Object;
+      
+      internal var index:int = -1;
+      
+      public function Entity(id:int)
+      {
+         super();
+         this.var_101 = id;
+         this.components = new Vector.<EntityComponent>();
+         this.var_100 = new Object();
+      }
+      
+      public static function name_74() : int
+      {
+         return ++lastId;
+      }
+      
+      public function get id() : int
+      {
+         return this.var_101;
+      }
+      
+      public function name_60(component:EntityComponent) : void
+      {
+         this.components.push(component);
+         component.method_197(this);
+      }
+      
+      public function name_64() : void
+      {
+         var entityComponent:EntityComponent = null;
+         for each(entityComponent in this.components)
+         {
+            entityComponent.initComponent();
+         }
+      }
+      
+      public function getComponent(cls:Class) : EntityComponent
+      {
+         var component:EntityComponent = null;
+         for each(component in this.components)
+         {
+            if(component is cls)
+            {
+               return component;
+            }
+         }
+         return null;
+      }
+      
+      public function getComponentStrict(cls:Class) : EntityComponent
+      {
+         var component:EntityComponent = this.getComponent(cls);
+         if(component == null)
+         {
+            throw new Error("Component " + cls + " not found");
+         }
+         return component;
+      }
+      
+      public function addToGame(gameKernel:GameKernel) : void
+      {
+         var entityComponent:EntityComponent = null;
+         for each(entityComponent in this.components)
+         {
+            entityComponent.addToGame(gameKernel);
+         }
+      }
+      
+      public function removeFromGame(gameKernel:GameKernel) : void
+      {
+         var entityComponent:EntityComponent = null;
+         for each(entityComponent in this.components)
+         {
+            entityComponent.removeFromGame(gameKernel);
+         }
+      }
+      
+      public function dispatchEvent(eventType:String, eventData:* = undefined) : void
+      {
+         var numListeners:uint = 0;
+         var i:int = 0;
+         var listeners:Vector.<Function> = this.var_100[eventType];
+         if(listeners != null)
+         {
+            numListeners = uint(listeners.length);
+            for(i = 0; i < numListeners; i++)
+            {
+               listeners[i].call(null,eventType,eventData);
+            }
+         }
+      }
+      
+      public function addEventHandler(eventType:String, handler:Function) : void
+      {
+         var handlers:Vector.<Function> = this.var_100[eventType];
+         if(handlers == null)
+         {
+            handlers = new Vector.<Function>();
+            this.var_100[eventType] = handlers;
+         }
+         handlers.push(handler);
+      }
+   }
+}
+

src/alternativa/tanks/game/EntityComponent.as

@@ -0,0 +1,30 @@
+package alternativa.tanks.game
+{
+   public class EntityComponent
+   {
+      protected var entity:Entity;
+      
+      public function EntityComponent()
+      {
+         super();
+      }
+      
+      public function method_197(entity:Entity) : void
+      {
+         this.entity = entity;
+      }
+      
+      public function initComponent() : void
+      {
+      }
+      
+      public function addToGame(gameKernel:GameKernel) : void
+      {
+      }
+      
+      public function removeFromGame(gameKernel:GameKernel) : void
+      {
+      }
+   }
+}
+

src/alternativa/tanks/game/GameEvents.as

@@ -0,0 +1,15 @@
+package alternativa.tanks.game
+{
+   public class GameEvents
+   {
+      public static const MAP_COMPLETE:String = "mapComplete";
+      
+      public static const BATTLE_FINISHED:String = "battleFinished";
+      
+      public function GameEvents()
+      {
+         super();
+      }
+   }
+}
+

src/alternativa/tanks/game/GameKernel.as

@@ -0,0 +1,216 @@
+package alternativa.tanks.game
+{
+   import flash.display.Stage;
+   import package_18.name_44;
+   import package_20.name_179;
+   import package_20.name_56;
+   import package_22.name_181;
+   import package_22.name_87;
+   import package_26.name_100;
+   import package_27.name_180;
+   import package_42.name_177;
+   import package_42.name_184;
+   import package_43.name_183;
+   import package_43.name_190;
+   import package_44.name_178;
+   import package_45.name_182;
+   
+   public class GameKernel
+   {
+      public static const TIME_SYSTEM_PRIORITY:int = 0;
+      
+      public static const INPUT_SYSTEM_PRIORITY:int = 1000;
+      
+      public static const EVENT_SYSTEM_PRIORITY:int = 2000;
+      
+      public static const LOGIC_SYSTEM_1_PRIORITY:int = 3000;
+      
+      public static const LOGIC_SYSTEM_2_PRIORITY:int = 3001;
+      
+      public static const PHYSICS_SYSTEM_PRIORITY:int = 4000;
+      
+      public static const RENDER_SYSTEM_PRIORITY:int = 5000;
+      
+      public static const CLEANUP_SYSTEM_PRIORITY:int = 6000;
+      
+      public const const_1:name_180 = new name_180(20);
+      
+      private var var_43:Stage;
+      
+      private var var_36:Object;
+      
+      private var var_41:IGameLogger = new DummyLogger();
+      
+      private var var_4:TaskManager;
+      
+      private var var_44:name_182;
+      
+      private var inputSystem:name_181;
+      
+      private var eventSystem:name_179;
+      
+      private var logicSystem1:name_177;
+      
+      private var logicSystem2:name_177;
+      
+      private var physicsSystem:name_178;
+      
+      private var renderSystem:name_44;
+      
+      private var var_42:name_183;
+      
+      private var var_39:Vector.<Entity>;
+      
+      private var var_38:int;
+      
+      private var var_40:name_100;
+      
+      public function GameKernel(stage:Stage, options:Object)
+      {
+         super();
+         this.var_43 = stage;
+         this.var_36 = options || {};
+         this.var_39 = new Vector.<Entity>();
+         this.var_40 = new name_100();
+         this.var_4 = new TaskManager();
+         this.var_44 = new name_182(TIME_SYSTEM_PRIORITY);
+         this.var_4.addTask(this.var_44);
+         this.inputSystem = new name_181(INPUT_SYSTEM_PRIORITY,stage);
+         this.var_4.addTask(this.inputSystem);
+         this.eventSystem = new name_179(EVENT_SYSTEM_PRIORITY);
+         this.var_4.addTask(this.eventSystem);
+         this.logicSystem1 = new name_177(LOGIC_SYSTEM_1_PRIORITY,this);
+         this.var_4.addTask(this.logicSystem1);
+         this.logicSystem2 = new name_177(LOGIC_SYSTEM_2_PRIORITY,this);
+         this.var_4.addTask(this.logicSystem2);
+         this.physicsSystem = new name_178(PHYSICS_SYSTEM_PRIORITY,this.var_40);
+         this.var_4.addTask(this.physicsSystem);
+         this.renderSystem = new name_44(RENDER_SYSTEM_PRIORITY,stage);
+         this.var_4.addTask(this.renderSystem);
+         this.var_42 = new name_183(CLEANUP_SYSTEM_PRIORITY);
+         this.var_4.addTask(this.var_42);
+      }
+      
+      public function get logger() : IGameLogger
+      {
+         return this.var_41;
+      }
+      
+      public function set logger(value:IGameLogger) : void
+      {
+         if(value == null)
+         {
+            throw new ArgumentError("Logger is null");
+         }
+         this.var_41 = value;
+      }
+      
+      public function get stage() : Stage
+      {
+         return this.var_43;
+      }
+      
+      public function get options() : Object
+      {
+         return this.var_36;
+      }
+      
+      public function method_111(command:name_190) : void
+      {
+         this.var_42.name_187(command);
+      }
+      
+      public function method_108() : name_100
+      {
+         return this.var_40;
+      }
+      
+      public function addTask(gameTask:GameTask) : void
+      {
+         this.var_4.addTask(gameTask);
+      }
+      
+      public function name_73(entity:Entity) : void
+      {
+         if(entity.index < 0)
+         {
+            entity.index = this.var_38;
+            var _loc2_:* = this.var_38++;
+            this.var_39[_loc2_] = entity;
+            entity.addToGame(this);
+            return;
+         }
+         throw new Error("Entity " + entity + " is already in game");
+      }
+      
+      public function method_109(entity:Entity) : void
+      {
+         var index:int = int(entity.index);
+         if(index < 0)
+         {
+            throw new Error("Entity " + entity + " is not in game");
+         }
+         var lastEntity:Entity = this.var_39[--this.var_38];
+         lastEntity.index = index;
+         this.var_39[index] = lastEntity;
+         this.var_39[this.var_38] = null;
+         entity.index = -1;
+         entity.removeFromGame(this);
+      }
+      
+      public function name_66() : name_87
+      {
+         return this.inputSystem;
+      }
+      
+      public function name_61() : name_56
+      {
+         return this.eventSystem;
+      }
+      
+      public function getLogicSystem1() : name_184
+      {
+         return this.logicSystem1;
+      }
+      
+      public function getLogicSystem2() : name_184
+      {
+         return this.logicSystem2;
+      }
+      
+      public function method_112() : name_178
+      {
+         return this.physicsSystem;
+      }
+      
+      public function name_5() : name_44
+      {
+         return this.renderSystem;
+      }
+      
+      public function name_51() : void
+      {
+         this.const_1.name_188();
+         this.var_4.name_185();
+         this.const_1.name_186();
+      }
+      
+      public function method_110() : void
+      {
+         this.var_4.name_189();
+         this.var_4.name_185();
+      }
+   }
+}
+
+class DummyLogger implements IGameLogger
+{
+   public function DummyLogger()
+   {
+      super();
+   }
+   
+   public function log(channel:String, text:String) : void
+   {
+   }
+}

src/alternativa/tanks/game/GameTask.as

@@ -0,0 +1,73 @@
+package alternativa.tanks.game
+{
+   public class GameTask
+   {
+      public var var_4:TaskManager;
+      
+      public var priority:int;
+      
+      protected var var_3:Boolean;
+      
+      public function GameTask(priority:int)
+      {
+         super();
+         this.priority = priority;
+      }
+      
+      public function start() : void
+      {
+      }
+      
+      public function stop() : void
+      {
+      }
+      
+      public function run() : void
+      {
+      }
+      
+      final public function get method_20() : Boolean
+      {
+         return this.var_3;
+      }
+      
+      final public function set method_20(value:Boolean) : void
+      {
+         if(value)
+         {
+            this.method_21();
+         }
+         else
+         {
+            this.method_22();
+         }
+      }
+      
+      final public function method_21() : void
+      {
+         if(!this.var_3)
+         {
+            this.var_3 = true;
+            this.onPause();
+         }
+      }
+      
+      final public function method_22() : void
+      {
+         if(this.var_3)
+         {
+            this.var_3 = false;
+            this.onResume();
+         }
+      }
+      
+      protected function onPause() : void
+      {
+      }
+      
+      protected function onResume() : void
+      {
+      }
+   }
+}
+

src/alternativa/tanks/game/IGameLogger.as.as

@@ -0,0 +1,8 @@
+package alternativa.tanks.game
+{
+   public interface IGameLogger
+   {
+      function log(param1:String, param2:String) : void;
+   }
+}
+

src/alternativa/tanks/game/ObjectController.as

@@ -0,0 +1,84 @@
+package alternativa.tanks.game
+{
+   import package_21.name_124;
+   import package_21.name_78;
+   import package_46.Matrix3;
+   import package_46.name_194;
+   
+   public class ObjectController
+   {
+      private static var matrix:Matrix3 = new Matrix3();
+      
+      private static var vector:name_194 = new name_194();
+      
+      private var var_234:name_78;
+      
+      public function ObjectController()
+      {
+         super();
+      }
+      
+      public function get object() : name_78
+      {
+         return this.var_234;
+      }
+      
+      public function set object(value:name_78) : void
+      {
+         this.var_234 = value;
+      }
+      
+      public function name_201(x:Number, y:Number, z:Number) : void
+      {
+         this.var_234.x = x;
+         this.var_234.y = y;
+         this.var_234.z = z;
+      }
+      
+      public function method_368(rx:Number, ry:Number, rz:Number) : void
+      {
+         this.var_234.rotationX = rx;
+         this.var_234.rotationY = ry;
+         this.var_234.rotationZ = rz;
+      }
+      
+      public function method_367(dx:Number, dy:Number, dz:Number) : void
+      {
+         matrix.name_196(this.var_234.rotationX,this.var_234.rotationY,this.var_234.rotationZ);
+         vector.reset(dx,dy,dz);
+         vector.transform3(matrix);
+         this.var_234.x += vector.x;
+         this.var_234.y += vector.y;
+         this.var_234.z += vector.z;
+      }
+      
+      public function move(dx:Number, dy:Number, dz:Number) : void
+      {
+         this.var_234.x += dx;
+         this.var_234.y += dy;
+         this.var_234.z += dz;
+      }
+      
+      public function rotate(rdx:Number, rdy:Number, rdz:Number) : void
+      {
+         this.var_234.rotationX += rdx;
+         this.var_234.rotationY += rdy;
+         this.var_234.rotationZ += rdz;
+      }
+      
+      public function name_76(x:Number, y:Number, z:Number) : void
+      {
+         var dx:Number = x - this.var_234.x;
+         var dy:Number = y - this.var_234.y;
+         var dz:Number = z - this.var_234.z;
+         this.var_234.rotationX = Math.atan2(dz,Math.sqrt(dx * dx + dy * dy));
+         if(this.var_234 is name_124)
+         {
+            this.var_234.rotationX -= 0.5 * Math.PI;
+         }
+         this.var_234.rotationY = 0;
+         this.var_234.rotationZ = -Math.atan2(dx,dy);
+      }
+   }
+}
+

src/alternativa/tanks/game/TaskManager.as

@@ -0,0 +1,175 @@
+package alternativa.tanks.game
+{
+   import flash.utils.Dictionary;
+   import flash.utils.describeType;
+   import flash.utils.getDefinitionByName;
+   import package_108.name_373;
+   import package_108.name_374;
+   
+   public class TaskManager
+   {
+      private var var_85:name_374 = new name_374();
+      
+      private var var_87:TaskArray = new TaskArray();
+      
+      private var var_86:TaskArray = new TaskArray();
+      
+      private var var_88:Dictionary = new Dictionary();
+      
+      public function TaskManager()
+      {
+         super();
+      }
+      
+      public function addTask(task:GameTask) : void
+      {
+         if(this.var_85.contains(task))
+         {
+            throw new Error("Task is already active");
+         }
+         if(this.var_87.contains(task))
+         {
+            throw new Error("Task has been already scheduled for addition");
+         }
+         this.var_87.add(task);
+      }
+      
+      public function killTask(task:GameTask) : void
+      {
+         if(this.var_85.contains(task) && !this.var_86.contains(task))
+         {
+            this.var_86.add(task);
+         }
+      }
+      
+      public function name_185() : void
+      {
+         var task:GameTask = null;
+         this.startAddedTasks();
+         var iterator:name_373 = this.var_85.listIterator();
+         while(iterator.hasNext())
+         {
+            task = GameTask(iterator.next());
+            if(!task.method_20)
+            {
+               task.run();
+            }
+         }
+         this.removeKilledTasks();
+      }
+      
+      public function getTaskInterface(taskInterface:Class) : Object
+      {
+         return this.var_88[taskInterface];
+      }
+      
+      public function name_189() : void
+      {
+         var task:GameTask = null;
+         var listIterator:name_373 = this.var_85.listIterator();
+         while(listIterator.hasNext())
+         {
+            task = GameTask(listIterator.next());
+            this.killTask(task);
+         }
+      }
+      
+      private function startAddedTasks() : void
+      {
+         var task:GameTask = null;
+         var taskInterfaces:Vector.<Class> = null;
+         var taskInterface:Class = null;
+         var activeTasksIterator:name_373 = null;
+         var activeTask:GameTask = null;
+         for(var i:int = 0; i < this.var_87.numTasks; i++)
+         {
+            task = this.var_87.tasks[i];
+            task.var_4 = this;
+            task.start();
+            taskInterfaces = this.getObjectInterfaces(task);
+            for each(taskInterface in taskInterfaces)
+            {
+               this.var_88[taskInterface] = task;
+            }
+            activeTasksIterator = this.var_85.listIterator();
+            while(activeTasksIterator.hasNext())
+            {
+               activeTask = GameTask(activeTasksIterator.next());
+               if(activeTask.priority > task.priority)
+               {
+                  activeTasksIterator.name_375();
+                  break;
+               }
+            }
+            activeTasksIterator.add(task);
+         }
+         this.var_87.clear();
+      }
+      
+      private function removeKilledTasks() : void
+      {
+         var task:GameTask = null;
+         var taskInterfaces:Vector.<Class> = null;
+         var taskInterface:Class = null;
+         for(var i:int = 0; i < this.var_86.numTasks; i++)
+         {
+            task = this.var_86.tasks[i];
+            this.var_85.remove(task);
+            task.stop();
+            taskInterfaces = this.getObjectInterfaces(task);
+            for each(taskInterface in taskInterfaces)
+            {
+               delete this.var_88[taskInterface];
+            }
+            task.var_4 = null;
+         }
+         this.var_86.clear();
+      }
+      
+      private function getObjectInterfaces(object:Object) : Vector.<Class>
+      {
+         var interfaceXML:XML = null;
+         var interfaceClass:Object = null;
+         var result:Vector.<Class> = new Vector.<Class>();
+         var xml:XML = describeType(object);
+         for each(interfaceXML in xml.implementsInterface)
+         {
+            interfaceClass = getDefinitionByName(interfaceXML.@type);
+            result.push(interfaceClass);
+         }
+         return result;
+      }
+   }
+}
+
+class TaskArray
+{
+   public var tasks:Vector.<GameTask> = new Vector.<GameTask>();
+   
+   public var numTasks:int;
+   
+   public function TaskArray()
+   {
+      super();
+   }
+   
+   public function add(task:GameTask) : void
+   {
+      var _loc2_:* = this.numTasks++;
+      this.tasks[_loc2_] = task;
+   }
+   
+   public function clear() : void
+   {
+      for(var i:int = 0; i < this.numTasks; i++)
+      {
+         this.tasks[i] = null;
+      }
+      this.numTasks = 0;
+   }
+   
+   public function contains(task:GameTask) : Boolean
+   {
+      return this.tasks.indexOf(task) >= 0;
+   }
+}

src/alternativa/tanks/game/usertitle/component/name_245.as

@@ -3,8 +3,8 @@ package alternativa.tanks.game.usertitle.component
    import alternativa.tanks.game.usertitle.name_607;
    import alternativa.tanks.game.usertitle.name_610;
    import alternativa.tanks.game.usertitle.name_613;
-   import package_10.class_17;
-   import package_10.name_17;
+   import alternativa.tanks.game.EntityComponent;
+   import alternativa.tanks.game.GameKernel;
    import package_114.name_488;
    import package_18.name_44;
    import package_18.name_82;
@@ -14,7 +14,7 @@ package alternativa.tanks.game.usertitle.component
    import package_74.class_25;
    import package_75.name_236;
    
-   public class name_245 extends class_17 implements name_82
+   public class name_245 extends EntityComponent implements name_82
    {
       private static const REMOTE_LABEL_OFFSET_Z:int = 200;
       
@@ -30,7 +30,7 @@ package alternativa.tanks.game.usertitle.component
       
       private var var_424:name_488;
       
-      private var gameKernel:name_17;
+      private var gameKernel:GameKernel;
       
       private var var_426:Boolean;
       
@@ -93,13 +93,13 @@ package alternativa.tanks.game.usertitle.component
          this.setHealth(Number(data));
       }
       
-      override public function addToGame(gameKernel:name_17) : void
+      override public function addToGame(gameKernel:GameKernel) : void
       {
          this.gameKernel = gameKernel;
          this.var_505.name_612(gameKernel.name_5());
       }
       
-      override public function removeFromGame(gameKernel:name_17) : void
+      override public function removeFromGame(gameKernel:GameKernel) : void
       {
          this.var_424.name_493.stop();
          this.removeFromScene();

src/alternativa/tanks/game/usertitle/name_610.as

@@ -1,11 +1,11 @@
 package alternativa.tanks.game.usertitle
 {
    import alternativa.tanks.game.usertitle.component.name_245;
-   import package_10.name_54;
+   import alternativa.tanks.game.Entity;
    
    public interface name_610
    {
-      function name_614(param1:name_54, param2:name_245) : void;
+      function name_614(param1:Entity, param2:name_245) : void;
    }
 }