[common] add PackId

CHANGELOG.md

@@ -0,0 +1,29 @@
+0.15.0
+------
+* Added display tank player name in `Render`
+* Fixed join game after relogin
+* Updated `CreateGamePopup` for any screen sizes
+* Fixed tank destroy zero score label
+* Added custom size map support
+* Fixed clock bonus for spawned tanks
+
+0.14.0
+------
+* Added `CreateGamePopup`
+* Fixed null tank color
+* Updated `Ticker`
+
+0.13.0
+------
+* Added `Ticker`
+* Fixed `PacketQueue` stream reading
+* Added `PlayerControl` and `ControlPreset`
+* Added `BaseControlFactory`
+
+0.12.0
+------
+* Added `GameRoomFrame`
+* Improved websocket connection with using binary protocol instead of text
+* Added `GameListFrame`
+* Added `DesktopConnection` for linux client build
+* Updated `SoundManager`

WORK.md

@@ -1,73 +1,12 @@
-* build
-  * gulp 100%
-  * linux 100%
-  * deb-package 100%
-  * windows 0%
-  * exe-package 0% (inno setup)
-  
-* deploy
-  * capistrano 100%
-
-* ui
-  * auth frame 0%
-  * select game frame 100% (classic 1/2 player, dota singe/coop/vs)
-  * select level frame 10%
-  * game frame 50%
-
-* engine
-  * config 100%
-  * map 100%
-  * tanks 100%
-  * bullets 100%
-  * boxes 100%
-  * map changes 100%
-  * bonuses 100%
-  * eagle 100%
-  
-* game
-  * classic
-    * state 50%
-    * bot 50%
-    * human 100%
-  * dota
-    * state 50%
-    * bot 10%
-    * human 100%
-
-* bonus
-  * star 50%
-  * grenade 0%
-  * helm 0%
-  * clock 0%
-  * shovel 0%
-    
-* state
-  * score 0%
-  * human tank 0%
-  * save/load 0%
-  * export/import 0%
-  
-* render
-  * map 100%
-  * tanks 100%
-  * bullet 100%
-  * calc redraw 50%
-  * animations
-    * tank spawn 0%
-    * tank move 100%
-    * map water 100%
-    * bullet boom 90%
-    * tank boom 90%
-  * bonuses 100%
-  * html5 50%
-  
-* proto
-  ...
-  
-* editor
-  * level
-    * open 100%
-    * edit 50%
-    * save 100%
-  * tank
-    * color 10%  
+* **shovel** bonus with armor bricks
+* bonuses in dota/death mod
+* tanks and bullets speed balancing
+* result frame update (next game select, only human player info)
+* network game series
+* map packs (create in editor, import in game, save imported in local storage)
+* update bots
+* improve bonuses system
+* gamepad support
+* screen gamepad on mobiles
+* resize render on mobiles
+* [bug] game progress broken

gulpfile.js

@@ -1,4 +1,6 @@
 const gulp = require('gulp');
+const zip = require('gulp-zip');
+const foreach = require('gulp-foreach');
 const gulpClean = require('gulp-clean');
 const Config = require('./config.json');
 const packageInfo = require('./package.json');
@@ -25,6 +27,19 @@ exports.generate = function generate()  {
     });
 };
 
+exports.levels = function () {
+    return gulp.src("./src/common/level/*").pipe(foreach(function (stream, file) {
+        const type = file.path.substr(file.path.lastIndexOf("/") + 1);
+        gulp.src("./src/common/level/" + type + "/*").pipe(foreach(function (stream, file) {
+            const name = file.path.substr(file.path.lastIndexOf("/") + 1);
+            gulp.src("./src/common/level/" + type + "/" + name + "/*")
+                .pipe(zip(`${type}_${name}.zip`))
+                .pipe(gulp.dest("./target/levels"));
+        }));
+        return stream;
+    }));
+};
+
 /**
  * ToDo:
  * windows target
@@ -46,7 +61,11 @@ const config = new Project.Config({
         'src-gen/haxe',
     ],
     assets: [
-        'src/common/resources'
+        'src/common/resources',
+        'target/levels'
+    ],
+    flags: [
+        //'proto_debug',
     ],
     macros: [
         `CompilationOption.set('build','${dateformat(new Date(), 'yyyy-mm-dd HH:MM:ss')}')`,
@@ -141,6 +160,7 @@ const server = new Project(
  */
 module.exports.default = gulp.series(
     exports.clean,
+    exports.levels,
     module.exports['client:flash:build'],
     module.exports['client:flash:html'],
     module.exports['client:html5:build'],

package.json

@@ -1,13 +1,15 @@
 {
     "name": "tankz",
-    "version": "0.12.0",
+    "version": "0.15.0",
     "private": true,
     "devDependencies": {
         "dateformat": "^3.0.3",
         "gulp": "^4.0.0",
         "gulp-add": "0.0.2",
         "gulp-clean": "^0.4.0",
+        "gulp-foreach": "^0.1.0",
         "gulp-haxetool": "^0.0.19",
+        "gulp-zip": "^5.0.0",
         "yargs": "^13.2.4"
     },
     "haxeDependencies": {

protohx.json

@@ -3,9 +3,10 @@
   "protoFiles": [
     "src/common/proto/core.proto",
     "src/common/proto/game.proto",
+    "src/common/proto/room.proto",
     "src/common/proto/pack.proto"
   ],
   "cleanOut": true,
   "haxeOut": "src-gen/haxe",
   "javaOut": null
-}
+}

src/client/haxe/ru/m/control/ControlBus.hx

@@ -0,0 +1,43 @@
+package ru.m.control;
+
+import haxework.signal.Signal;
+import ru.m.control.IControlBus;
+
+class ControlBus implements IControlBus {
+
+    private static inline var TAG = "control";
+
+    public var devices(default, null):Array<IControlDevice>;
+
+    public var signal(default, null):Signal3<DeviceType, DeviceAction, Bool>;
+    public var devicesSignal(default, null):Signal<Array<IControlDevice>>;
+
+    private var connections:Map<DeviceType, DeviceAction->Bool->Void>;
+
+    public function new() {
+        devices = [];
+        signal = new Signal3();
+        devicesSignal = new Signal();
+        connections = new Map();
+    }
+
+    public function connect(device:IControlDevice):Void {
+        var connector = function(action:DeviceAction, on:Bool):Void {
+            //L.d("TAG", '${device.type}, ${action}, ${on}');
+            signal.emit(device.type, action, on);
+        }
+        connections.set(device.type, connector);
+        device.signal.connect(connector);
+        devices.push(device);
+        devicesSignal.emit(devices);
+    }
+
+    public function disconnect(device:IControlDevice):Void {
+        if (connections.exists(device.type)) {
+            device.signal.disconnect(connections.get(device.type));
+            connections.remove(device.type);
+            devices.remove(device);
+            devicesSignal.emit(devices);
+        }
+    }
+}

src/client/haxe/ru/m/control/DeviceAction.hx

@@ -0,0 +1,8 @@
+package ru.m.control;
+
+import ru.m.geom.Direction;
+
+enum DeviceAction {
+    DIRECTION(direction:Direction);
+    KEY(code:Int);
+}

src/client/haxe/ru/m/control/DeviceType.hx

@@ -0,0 +1,7 @@
+package ru.m.control;
+
+enum DeviceType {
+    NONE;
+    KEYBOARD;
+    GAMEPAD(id:Int);
+}

src/client/haxe/ru/m/control/IControlBus.hx

@@ -0,0 +1,13 @@
+package ru.m.control;
+
+import haxework.signal.Signal;
+
+interface IControlBus {
+    public var devices(default, null):Array<IControlDevice>;
+
+    public var signal(default, null):Signal3<DeviceType, DeviceAction, Bool>;
+    public var devicesSignal(default, null):Signal<Array<IControlDevice>>;
+
+    public function connect(device:IControlDevice):Void;
+    public function disconnect(device:IControlDevice):Void;
+}

src/client/haxe/ru/m/control/IControlDevice.hx

@@ -0,0 +1,10 @@
+package ru.m.control;
+
+import haxework.signal.Signal;
+
+interface IControlDevice {
+    public var type(default, null):DeviceType;
+    public var signal(default, null):Signal2<DeviceAction, Bool>;
+
+    public function dispose():Void;
+}

src/client/haxe/ru/m/control/JoystickDevice.hx

@@ -0,0 +1,62 @@
+package ru.m.control;
+
+import haxework.signal.Signal;
+import lime.ui.Joystick;
+import ru.m.control.DeviceAction;
+import ru.m.control.DeviceType;
+import ru.m.geom.Direction;
+
+class JoystickDevice implements IControlDevice {
+
+    public var type(default, null):DeviceType;
+    public var signal(default, null):Signal2<DeviceAction, Bool>;
+
+    private var joystick:Joystick;
+    private var axisState:Map<Int, Direction>;
+
+    public function new(joystick:Joystick) {
+        this.joystick = joystick;
+        type = GAMEPAD(joystick.id);
+        signal = new Signal2();
+        axisState = new Map();
+        joystick.onButtonDown.add(onButtonDown);
+        joystick.onButtonUp.add(onButtonUp);
+        joystick.onAxisMove.add(onAxisMove);
+    }
+
+    private function onButtonDown(code:Int):Void {
+        signal.emit(KEY(code), true);
+    }
+
+    private function onButtonUp(code:Int):Void {
+        signal.emit(KEY(code), false);
+    }
+
+    private function onAxisMove(axis:Int, position:Float):Void {
+        var direction:Direction = switch [axis, position] {
+            case [0, 1]: Direction.RIGHT;
+            case [0, -1]: Direction.LEFT;
+            case [1, 1]: Direction.BOTTOM;
+            case [1, -1]: Direction.TOP;
+            case _: null;
+        }
+        if (direction != null) {
+            axisState.set(axis, direction);
+            signal.emit(DIRECTION(direction), true);
+        } else if (position == 0) {
+            if (axisState.exists(axis)) {
+                signal.emit(DIRECTION(axisState.get(axis)), false);
+                axisState.remove(axis);
+            }
+        }
+    }
+
+    public function dispose():Void {
+        if (joystick != null) {
+            joystick.onButtonDown.remove(onButtonDown);
+            joystick.onButtonUp.remove(onButtonUp);
+            joystick.onAxisMove.remove(onAxisMove);
+            joystick = null;
+        }
+    }
+}

src/client/haxe/ru/m/control/KeyboardDevice.hx

@@ -0,0 +1,38 @@
+package ru.m.control;
+
+import flash.display.Stage;
+import flash.events.KeyboardEvent;
+import haxework.signal.Signal;
+import ru.m.control.DeviceAction;
+
+class KeyboardDevice implements IControlDevice {
+
+    public var type(default, null):DeviceType;
+    public var signal(default, null):Signal2<DeviceAction, Bool>;
+
+    private var stage:Stage;
+
+    public function new(stage:Stage) {
+        this.stage = stage;
+        type = DeviceType.KEYBOARD;
+        signal = new Signal2();
+        stage.addEventListener(KeyboardEvent.KEY_DOWN, onKeyDown);
+        stage.addEventListener(KeyboardEvent.KEY_UP, onKeyUp);
+    }
+
+    private function onKeyDown(event:KeyboardEvent):Void {
+        signal.emit(KEY(event.keyCode), true);
+    }
+
+    private function onKeyUp(event:KeyboardEvent):Void {
+        signal.emit(KEY(event.keyCode), false);
+    }
+
+    public function dispose():Void {
+        if (stage != null) {
+            stage.removeEventListener(KeyboardEvent.KEY_DOWN, onKeyDown);
+            stage.removeEventListener(KeyboardEvent.KEY_UP, onKeyUp);
+            stage = null;
+        }
+    }
+}

src/client/haxe/ru/m/display/DisplayObjectContainerExtender.hx

@@ -0,0 +1,14 @@
+package ru.m.display;
+
+import flash.display.DisplayObject;
+import flash.display.DisplayObjectContainer;
+
+class DisplayObjectContainerExtender {
+
+    public static function removeChildSafety(self:DisplayObjectContainer, child:DisplayObject):DisplayObject {
+        if (self.contains(child)) {
+            return self.removeChild(child);
+        }
+        return null;
+    }
+}

src/client/haxe/ru/m/tankz/Init.hx

@@ -1,23 +1,28 @@
 package ru.m.tankz;
 
+import flash.Lib;
 import haxework.animate.FadeAnimate;
 import haxework.animate.UnFadeAnimate;
 import haxework.resources.IResources;
 import haxework.resources.Resources;
 import haxework.view.popup.PopupManager;
+import lime.ui.Gamepad;
+import lime.ui.Joystick;
 import ru.m.connect.IConnection;
+import ru.m.control.ControlBus;
+import ru.m.control.IControlBus;
+import ru.m.control.JoystickDevice;
+import ru.m.control.KeyboardDevice;
 import ru.m.tankz.bundle.ConfigBundle;
 import ru.m.tankz.bundle.IConfigBundle;
 import ru.m.tankz.bundle.ILevelBundle;
 import ru.m.tankz.bundle.LevelBundle;
-import ru.m.tankz.control.ClientControlFactory;
-import ru.m.tankz.control.IControlFactory;
 import ru.m.tankz.network.NetworkManager;
 import ru.m.tankz.proto.pack.Request;
 import ru.m.tankz.proto.pack.Response;
 import ru.m.tankz.sound.SoundManager;
 import ru.m.tankz.storage.GameStorage;
-import ru.m.tankz.storage.MultiplayerStorage;
+import ru.m.tankz.storage.NetworkStorage;
 import ru.m.tankz.storage.RecordStorage;
 import ru.m.tankz.storage.SettingsStorage;
 
@@ -27,14 +32,14 @@ class Init {
     @:provide static var levelBundle:ILevelBundle;
     @:provide static var configBundle:IConfigBundle;
     @:provide static var settingsStorage:SettingsStorage;
-    @:provide static var multiplayerStorage:MultiplayerStorage;
+    @:provide static var multiplayerStorage:NetworkStorage;
     @:provide static var gameStorage:GameStorage;
     @:provide static var recordStorage:RecordStorage;
     @:provide static var soundManager:SoundManager;
     @:provide static var networkManager:NetworkManager;
-    @:provide static var controlFactory:IControlFactory;
     @:provide static var popupManager:PopupManager;
     @:provide static var connection:IConnection<Request, Response>;
+    @:provide static var bus:IControlBus;
 
     private static function buildConnection():IConnection<Request, Response> {
         var host:String = CompilationOption.get("host");
@@ -54,11 +59,10 @@ class Init {
         levelBundle = new LevelBundle();
         configBundle = new ConfigBundle();
         settingsStorage = new SettingsStorage();
-        multiplayerStorage = new MultiplayerStorage();
+        multiplayerStorage = new NetworkStorage();
         gameStorage = new GameStorage();
         recordStorage = new RecordStorage();
         soundManager = new SoundManager();
-        controlFactory = new ClientControlFactory();
         popupManager = new PopupManager();
 
         popupManager.showAnimateFactory = function(v) return new UnFadeAnimate(v, 100);
@@ -66,5 +70,22 @@ class Init {
 
         connection = buildConnection();
         networkManager = new NetworkManager();
+
+        bus = new ControlBus();
+        bus.connect(new KeyboardDevice(Lib.current.stage));
+
+        for (device in Gamepad.devices) {
+            trace('gamepad', device);
+        }
+        Gamepad.onConnect.add(function(device) {
+            trace('connect gamepad', device);
+        });
+
+        for (device in Joystick.devices) {
+            bus.connect(new JoystickDevice(device));
+        }
+        Joystick.onConnect.add(function(device) {
+            bus.connect(new JoystickDevice(device));
+        });
     }
 }

src/client/haxe/ru/m/tankz/Style.hx

@@ -22,6 +22,7 @@ class Style {
     public static var darkColor = 0x777564;
     public static var textColor = 0xE7E0BB;
     public static var activeColor = 0xFFFF00;
+    public static var borderColor = ColorUtil.multiply(lightColor, 1.5);
 
     public static var baseFontSize = 18;
     public static var bigFontSize = 22;
@@ -36,7 +37,7 @@ class Style {
 
     public static function registerButton(name:String, resource:String):Void {
         resources.skin.put('button.$name', [
-            Skin.size(64, 64),
+            Skin.size(42, 42),
             new ButtonSVGSkin(Assets.getText('resources/image/icon/$resource'), lightColor),
         ]);
         resources.skin.put('button.$name.small', [
@@ -45,6 +46,14 @@ class Style {
         ]);
     }
 
+    public static function textBox(color:Int):SkinSet {
+        return [
+            Skin.color(0x000000, 0.1),
+            Skin.border(lightColor, 1, 2),
+            Skin.text(color, baseFontSize, fontFamily, fontEmbed),
+        ];
+    }
+
     public static function register(font:Font = null):Void {
         resources.color.put("light", lightColor);
         resources.color.put("dark", darkColor);
@@ -111,7 +120,7 @@ class Style {
             Skin.geometry(new Geometry().setPadding([25, 8])),
         ]);
         resources.skin.put("border", [
-            Skin.border(ColorUtil.multiply(lightColor, 1.5), 1, 2),
+            Skin.border(borderColor, 1, 2),
         ]);
         resources.skin.put("scroll", [
             Skin.scrollVertical(lightColor, ColorUtil.diff(lightColor, 128)),
@@ -128,19 +137,22 @@ class Style {
             Skin.color(darkColor),
         ]);
         resources.skin.put("panel", [
-            Skin.geometry(new Geometry().setSize("100%", -1).setPadding([20, 10])),
+            Skin.geometry(new Geometry().setSize("100%", -1).setPadding([10, 5])),
             Skin.layout(new Layout().setAlign(NONE, MIDDLE)),
             Skin.color(lightColor),
         ]);
         resources.skin.put("window", [
             Skin.color(darkColor),
-            Skin.border(ColorUtil.multiply(lightColor, 1.5), 1, 2),
+            Skin.border(borderColor, 1, 2),
             Skin.geometry(new Geometry().setPadding(2)),
         ]);
         resources.skin.put("window.close", [
             Skin.size(36, 36),
             new ButtonSVGSkin(Assets.getText("resources/image/icon/window-close-solid.svg"), lightColor),
         ]);
+        resources.skin.put("line", [
+            Skin.color(borderColor),
+        ]);
 
         registerButton("settings", "cog-solid.svg");
         registerButton("close", "times-circle-solid.svg");

src/client/haxe/ru/m/tankz/bundle/ConfigBundle.hx

@@ -15,8 +15,8 @@ class ConfigBundle implements IConfigBundle {
 
     public function get(type:GameType):Config {
         if (!_cache.exists(type)) {
-            var source:ConfigSource = Yaml.parse(Assets.getText('resources/${type}/config.yaml'), Parser.options().useObjects());
-            _cache.set(type, new Config(type, source.game, source.map, source.bricks, source.presets, source.points, source.tanks, source.bonuses));
+            var source:ConfigSource = Yaml.parse(Assets.getText('resources/config/${type}.yaml'), Parser.options().useObjects());
+            _cache.set(type, Config.fromSource(type, source));
         }
         return _cache.get(type);
     }

src/client/haxe/ru/m/tankz/bundle/LevelBundle.hx

@@ -7,17 +7,13 @@ import ru.m.tankz.util.LevelUtil;
 
 class LevelBundle implements ILevelBundle {
 
-    private var cache:Map<String, LevelConfig> = new Map();
-
     public function new() {}
 
-    public function get(type:GameType, config:Config, levelId:LevelId):LevelConfig {
-        var key = '${type}:${levelId}';
-        if (!cache.exists(key)) {
-            var data:String = Assets.getText('resources/${type}/levels/level${LevelUtil.formatLevel(levelId)}.txt');
-            cache[key] = LevelUtil.loads(config, data);
-            cache[key].id = levelId;
-        }
-        return cache[key];
+    public function get(id:PackId):LevelPack {
+        var bytes = Assets.getBytes('levels/${id}.zip');
+        return {
+            id: id,
+            data: LevelUtil.unpack(bytes),
+        };
     }
 }

src/client/haxe/ru/m/tankz/control/ActionConfig.hx

@@ -1,27 +0,0 @@
-package ru.m.tankz.control;
-
-import ru.m.tankz.control.Control.TankAction;
-
-typedef ActionItem = {
-    public var action:TankAction;
-    public var key:Int;
-}
-
-typedef KeyBinding = Map<Int, TankAction>;
-
-class ActionConfig {
-
-    public var data(default, null):Array<ActionItem>;
-
-    public function new(data:Array<ActionItem>) {
-        this.data = data;
-    }
-
-    public function asKeyBinding():KeyBinding {
-        var result = new Map<Int, TankAction>();
-        for (item in data) {
-            result[item.key] = item.action;
-        }
-        return result;
-    }
-}

src/client/haxe/ru/m/tankz/control/Binding.hx

@@ -0,0 +1,12 @@
+package ru.m.tankz.control;
+
+import ru.m.control.DeviceAction;
+import ru.m.control.DeviceType;
+import ru.m.tankz.control.Control;
+
+typedef BindAction = {
+    var device:DeviceType;
+    var action:DeviceAction;
+}
+
+typedef Binding = Map<TankAction, BindAction>;

src/client/haxe/ru/m/tankz/control/ClientControlFactory.hx

@@ -1,22 +0,0 @@
-package ru.m.tankz.control;
-
-import ru.m.tankz.bot.StupidBotControl;
-import ru.m.tankz.bot.HardBotControl;
-import ru.m.tankz.Type;
-
-class ClientControlFactory implements IControlFactory {
-
-    public function new() {}
-
-    public function build(id:PlayerId, controller:Controller):Control {
-        return switch controller {
-            case HUMAN(index): new HumanControl(id, index);
-            case BOT(type): switch type {
-                case StupidBotControl.BOT_TYPE: new StupidBotControl(id);
-                case HardBotControl.BOT_TYPE: new HardBotControl(id);
-                case _: null;
-            }
-            case NONE: null;
-        }
-    }
-}

src/client/haxe/ru/m/tankz/control/HumanControl.hx

@@ -1,60 +1,85 @@
 package ru.m.tankz.control;
 
 import flash.events.FocusEvent;
-import flash.events.KeyboardEvent;
-import flash.Lib;
-import flash.ui.Keyboard;
 import haxe.Timer;
-import ru.m.tankz.control.ActionConfig;
+import ru.m.control.DeviceAction;
+import ru.m.control.DeviceType;
+import ru.m.control.IControlBus;
+import ru.m.geom.Direction;
 import ru.m.tankz.control.Control;
 import ru.m.tankz.storage.SettingsStorage;
 import ru.m.tankz.Type;
 
 class HumanControl extends Control {
 
-    @:provide var storage:SettingsStorage;
+    @:provide static var storage:SettingsStorage;
+    @:provide static var bus:IControlBus;
 
-    private var keyBinding:KeyBinding;
-    private var moveQueue:Array<Int>;
+    private var binding:Map<DeviceType, Map<DeviceAction, TankAction>>;
+
+    private var moveQueue:Array<Direction>;
     private var shotTimer:Timer;
 
     public function new(playerId:PlayerId, controlIndex:Int) {
         super(playerId);
-        this.keyBinding = storage.getActionConfig(controlIndex).asKeyBinding();
-        moveQueue = new Array<Int>();
-        Lib.current.stage.addEventListener(KeyboardEvent.KEY_DOWN, onKeyDown);
-        Lib.current.stage.addEventListener(KeyboardEvent.KEY_UP, onKeyUp);
-        //Lib.current.stage.addEventListener(FocusEvent.FOCUS_OUT, onFocusOut);
+        var config = storage.getBinding(controlIndex);
+        binding = new Map();
+        for (action in config.keys()) {
+            var bind = config.get(action);
+            if (!binding.exists(bind.device)) {
+                binding.set(bind.device, new Map());
+            }
+            binding.get(bind.device).set(bind.action, action);
+        }
+        moveQueue = [];
     }
 
-    private function onKeyDown(event:KeyboardEvent):Void {
-        if (keyBinding.exists(event.keyCode)) switch (keyBinding.get(event.keyCode)) {
-            case TankAction.MOVE(direction):
-                if (moveQueue.indexOf(event.keyCode) == -1) {
-                    moveQueue.unshift(event.keyCode);
-                    updateMove();
-                }
-            case TankAction.SHOT:
-                if (shotTimer == null) {
-                    shotTimer = new Timer(300);
-                    shotTimer.run = shot;
-                    shot();
-                }
-            case _:
+    private function onDeviceAction(device:DeviceType, action:DeviceAction, on:Bool):Void {
+        if (binding.exists(device) && binding[device].exists(action)) {
+            toggleAction(binding[device][action], on);
         }
     }
 
-    private function onKeyUp(event:KeyboardEvent):Void {
-        if (keyBinding.exists(event.keyCode)) switch (keyBinding.get(event.keyCode)) {
+    override public function start():Void {
+        super.start();
+        bus.signal.connect(onDeviceAction);
+    }
+
+    override public function stop():Void {
+        super.stop();
+        bus.signal.disconnect(onDeviceAction);
+        moveQueue = [];
+        if (shotTimer != null) {
+            shotTimer.stop();
+            shotTimer = null;
+        }
+    }
+
+    public function toggleAction(action:TankAction, on:Bool):Void {
+        switch action {
             case TankAction.MOVE(direction):
-                moveQueue.remove(event.keyCode);
+                if (on) {
+                    if (moveQueue.indexOf(direction) == -1) {
+                        moveQueue.unshift(direction);
+                    }
+                } else {
+                    moveQueue.remove(direction);
+                }
                 updateMove();
             case TankAction.SHOT:
-                if (shotTimer != null) {
-                    shotTimer.stop();
-                    shotTimer = null;
+                if (on) {
+                    if (shotTimer == null) {
+                        shotTimer = new Timer(300);
+                        shotTimer.run = shot;
+                        shot();
+                    }
+                } else {
+                    if (shotTimer != null) {
+                        shotTimer.stop();
+                        shotTimer = null;
+                    }
                 }
-            case _:
+            case TankAction.STOP:
         }
     }
 
@@ -65,17 +90,13 @@ class HumanControl extends Control {
 
     private function updateMove():Void {
         if (moveQueue.length == 0) {
-            action(TankAction.STOP);
+            action(STOP);
         } else {
-            switch (keyBinding.get(moveQueue[0])) {
-                case TankAction.MOVE(direction):
-                    action(TankAction.MOVE(direction));
-                case _:
-            }
+            action(MOVE(moveQueue[0]));
         }
     }
 
     private function shot():Void {
-        action(TankAction.SHOT);
+        action(SHOT);
     }
 }

src/client/haxe/ru/m/tankz/local/LocalControlFactory.hx

@@ -0,0 +1,13 @@
+package ru.m.tankz.local;
+
+import ru.m.tankz.control.BaseControlFactory;
+import ru.m.tankz.control.Control;
+import ru.m.tankz.control.HumanControl;
+import ru.m.tankz.Type;
+
+class LocalControlFactory extends BaseControlFactory {
+
+    override private function buildHuman(id:PlayerId, index:Int):Control {
+        return new HumanControl(id, index);
+    }
+}

src/client/haxe/ru/m/tankz/local/LocalGame.hx

@@ -0,0 +1,32 @@
+package ru.m.tankz.local;
+
+import ru.m.tankz.config.Config;
+import ru.m.tankz.game.GameEvent;
+import ru.m.tankz.game.GameRunner;
+import ru.m.tankz.game.GameState;
+import ru.m.tankz.game.record.GameRecorder;
+import ru.m.tankz.local.LocalControlFactory;
+import ru.m.tankz.storage.RecordStorage;
+
+class LocalGame extends GameRunner {
+    @:provide var recordStorage:RecordStorage;
+    private var recorder:GameRecorder;
+
+    public function new(state:GameState, level:LevelConfig) {
+        super(state, level);
+        controlFactory = new LocalControlFactory();
+        recorder = new GameRecorder();
+        connect(recorder);
+    }
+
+    override public function onGameEvent(event:GameEvent):Void {
+        super.onGameEvent(event);
+        switch event {
+            case GameEvent.COMPLETE(_, _):
+                disconnect(recorder);
+                recorder.onGameEvent(event); //ToDo:
+                recordStorage.save(recorder.record);
+            case _:
+        }
+    }
+}

src/client/haxe/ru/m/tankz/network/NetworkControl.hx

@@ -1,13 +1,16 @@
-package ru.m.tankz.control;
+package ru.m.tankz.network;
 
+import ru.m.tankz.control.HumanControl;
 import ru.m.tankz.network.NetworkManager;
 import ru.m.tankz.control.Control;
 
-class ClientNetworkControl extends HumanControl {
+class NetworkControl extends HumanControl {
 
     @:provide private var network:NetworkManager;
 
     override public function action(action:TankAction):Void {
-        network.action(action);
+        if (tankId > -1) {
+            network.action(tankId, action);
+        }
     }
 }

src/client/haxe/ru/m/tankz/network/NetworkControlFactory.hx

@@ -0,0 +1,16 @@
+package ru.m.tankz.network;
+
+import ru.m.tankz.control.BaseControlFactory;
+import ru.m.tankz.control.Control;
+import ru.m.tankz.Type;
+
+class NetworkControlFactory extends BaseControlFactory {
+
+    override private function buildHuman(id:PlayerId, index:Int):Control {
+        return new NetworkControl(id, index);
+    }
+
+    override private function buildBot(id:PlayerId, type:String):Control {
+        return null;
+    }
+}

src/client/haxe/ru/m/tankz/network/NetworkGame.hx

@@ -0,0 +1,54 @@
+package ru.m.tankz.network;
+
+import haxe.Unserializer;
+import ru.m.tankz.game.Game;
+import ru.m.tankz.game.GameEvent;
+import ru.m.tankz.game.GameState;
+import ru.m.tankz.network.NetworkControlFactory;
+import ru.m.tankz.network.NetworkManager;
+import ru.m.tankz.proto.pack.GameEventResponse;
+import ru.m.tankz.proto.room.RoomSlotProto;
+
+class NetworkGame extends Game {
+
+    private var network:NetworkManager;
+
+    public function new(network:NetworkManager) {
+        super(new GameState(network.room.game.type, 0), null);
+        this.network = network;
+        this.controlFactory = new NetworkControlFactory();
+        network.gameEventSignal.connect(onGameEventProto);
+        network.stateSignal.connect(onConnectionState);
+    }
+
+    private function onGameEventProto(game:GameEventResponse):Void {
+        var time = game.event.time;
+        var eventStr = game.event.event;
+        var event:GameEvent = Unserializer.run(eventStr);
+        gameEventSignal.emit(event);
+    }
+
+    private function onConnectionState(state:ConnectionState):Void {
+        switch state {
+            case ONLINE(user):
+                if (network.room != null) {
+                    network.joinGame(network.room.game.id);
+                }
+            case _:
+        }
+    }
+
+    override public function start():Void {
+        var slot:RoomSlotProto = Lambda.find(network.room.slots, function(slot:RoomSlotProto) return slot.hasUser() && slot.user.uuid == network.user.uuid);
+        if (slot != null) {
+            state.controls.push({playerId: [slot.slot.team, slot.slot.index], control: "human-0"});
+        }
+        super.start();
+    }
+
+    override public function dispose():Void {
+        super.dispose();
+        network.gameEventSignal.disconnect(onGameEventProto);
+        network.stateSignal.disconnect(onConnectionState);
+    }
+}

src/client/haxe/ru/m/tankz/network/NetworkManager.hx

@@ -1,21 +1,28 @@
 package ru.m.tankz.network;
 
-import ru.m.tankz.proto.core.UserProto;
+import ru.m.tankz.proto.game.GameEventProto;
+import ru.m.tankz.proto.room.SlotProto;
+import ru.m.tankz.proto.room.SlotRequest;
+import haxe.Serializer;
 import haxework.signal.Signal;
 import ru.m.connect.IConnection;
 import ru.m.tankz.control.Control;
-import ru.m.tankz.proto.core.GameProto;
-import ru.m.tankz.proto.game.GameChangeProto;
-import ru.m.tankz.proto.pack.CreateGameRequest;
-import ru.m.tankz.proto.pack.JoinGameRequest;
-import ru.m.tankz.proto.pack.LeaveGameRequest;
-import ru.m.tankz.proto.pack.ListGameRequest;
+import ru.m.tankz.game.GameEvent;
+import ru.m.tankz.proto.core.UserProto;
+import ru.m.tankz.proto.pack.GameEventRequest;
+import ru.m.tankz.proto.pack.GameEventResponse;
 import ru.m.tankz.proto.pack.LoginRequest;
 import ru.m.tankz.proto.pack.LogoutRequest;
 import ru.m.tankz.proto.pack.Request;
 import ru.m.tankz.proto.pack.Response;
-import ru.m.tankz.proto.pack.StartGameRequest;
-import ru.m.tankz.storage.MultiplayerStorage;
+import ru.m.tankz.proto.room.CreateRequest;
+import ru.m.tankz.proto.room.JoinRequest;
+import ru.m.tankz.proto.room.LeaveRequest;
+import ru.m.tankz.proto.room.RoomListRequest;
+import ru.m.tankz.proto.room.RoomProto;
+import ru.m.tankz.proto.room.RoomRequest;
+import ru.m.tankz.proto.room.StartRequest;
+import ru.m.tankz.storage.NetworkStorage;
 
 typedef ClientConnection = IConnection<Request, Response>;
 
@@ -31,29 +38,30 @@ enum ConnectionState {
 class NetworkManager {
 
     public var state(default, null):ConnectionState;
-    public var game(default, null):GameProto;
+    public var room(default, null):RoomProto;
     public var user(default, null):UserProto;
 
     public var stateSignal:Signal<ConnectionState>;
-    public var listGameSignal:Signal<Array<GameProto>>;
-    public var gameSignal:Signal<GameProto>;
-    public var gameUpdateSignal:Signal<Array<GameChangeProto>>;
+    public var listRoomSignal:Signal<Array<RoomProto>>;
+    public var roomSignal:Signal<RoomProto>;
+    public var gameEventSignal:Signal<GameEventResponse>;
 
     @:provide private var connection:ClientConnection;
-    @:provide private var storage:MultiplayerStorage;
+    @:provide private var storage:NetworkStorage;
+
+    private var reconnectTimer:Timer;
+    private var reconnectDelay:Int;
 
     public function new() {
+        reconnectDelay = 500;
         stateSignal = new Signal();
-        listGameSignal = new Signal();
-        gameSignal = new Signal();
-        gameUpdateSignal = new Signal();
+        listRoomSignal = new Signal();
+        roomSignal = new Signal();
+        gameEventSignal = new Signal();
         updateState(OFFLINE);
         connection.handler.connect(onConnectionEvent);
         connection.receiveHandler.connect(onResponse);
-        var user = storage.user;
-        if (user != null) {
-            login(user.name, user.uuid);
-        }
+        connect();
     }
 
     private function updateState(value:ConnectionState):Void {
@@ -62,59 +70,83 @@ class NetworkManager {
     }
 
     public function login(name:String, uuid:String = null):Void {
-        updateState(CONNECT);
-        connection.connect().then(function(c:ClientConnection) {
-            updateState(LOGIN);
-            c.send(new Request().setLogin(
-                new LoginRequest()
-                    .setUuid(uuid)
-                    .setName(name)
-            ));
-        }).catchError(function(error) {
-            updateState(ERROR(error));
-        });
+        updateState(LOGIN);
+        connection.send(new Request().setLogin(
+            new LoginRequest()
+                .setUuid(uuid)
+                .setName(name)
+        ));
     }
 
     public function logout():Void {
         connection.send(new Request().setLogout(new LogoutRequest()));
     }
 
-    public function listGame():Void {
-        connection.send(new Request().setListGame(new ListGameRequest()));
+    public function listGame(subscribe:Bool):Void {
+        connection.send(new Request().setRoomList(new RoomListRequest().setSubscribe(subscribe)));
     }
 
     public function createGame(type:String, level:Int):Void {
-        connection.send(new Request().setCreateGame(new CreateGameRequest().setType(type).setLevel(level)));
+        connection.send(new Request().setRoom(new RoomRequest().setCreate(new CreateRequest().setType(type).setLevel(level))));
     }
 
-    public function joinGame(gameId:Int):Void {
-        connection.send(new Request().setJoinGame(new JoinGameRequest().setGameId(gameId)));
+    public function joinGame(gameId:Int, restore:Bool = false):Void {
+        connection.send(new Request().setRoom(new RoomRequest().setJoin(new JoinRequest().setGameId(gameId).setRestore(restore))));
+    }
+
+    public function selectSlot(slot:SlotProto):Void {
+        connection.send(new Request().setRoom(new RoomRequest().setSlot(new SlotRequest().setSlot(slot))));
     }
 
     public function leaveGame():Void {
-        connection.send(new Request().setLeaveGame(new LeaveGameRequest()));
+        connection.send(new Request().setRoom(new RoomRequest().setLeave(new LeaveRequest())));
     }
 
     public function startGame():Void {
-        connection.send(new Request().setStartGame(new StartGameRequest()));
+        connection.send(new Request().setRoom(new RoomRequest().setStart(new StartRequest())));
     }
 
-    public function action(action:TankAction):Void {
-        // ToDo: network
+    public function action(tankId:Int, action:TankAction):Void {
+        connection.send(new Request().setGameEvent(new GameEventRequest().setEvent(
+            new GameEventProto().setTime(0).setEvent(
+                Serializer.run(GameEvent.ACTION(tankId, action))
+            )))
+        );
+    }
+
+    private function connect():Void {
+        if (reconnectTimer != null) {
+            reconnectTimer.stop();
+            reconnectTimer = null;
+        }
+        reconnectTimer = null;
+        updateState(CONNECT);
+        connection.connect().catchError(function(error) {});
+    }
+
+    private function reconnect():Void {
+        reconnectDelay = Std.int(Math.min(reconnectDelay * 2, 10000));
+        if (reconnectTimer == null) {
+            reconnectTimer = Timer.delay(connect, reconnectDelay);
+        }
     }
 
     private function onConnectionEvent(event:ConnectionEvent):Void {
         updateState(switch event {
-            case CONNECTED:
-                L.d('Network', '$event');
-                CONNECTED;
-            case DISCONNECTED:
-                L.d('Network', '$event');
-                OFFLINE;
-            case ERROR(error):
-                L.e('Network', '$error', error);
-                ERROR(error);
+            case CONNECTED: CONNECTED;
+            case DISCONNECTED: OFFLINE;
+            case ERROR(error): ERROR(error);
         });
+        switch event {
+            case CONNECTED:
+                reconnectDelay = 500;
+                var user = storage.user;
+                if (user != null) {
+                    login(user.name, user.uuid);
+                }
+            case DISCONNECTED | ERROR(_):
+                reconnect();
+        }
     }
 
     private function onResponse(packet:Response):Void {
@@ -129,25 +161,13 @@ class NetworkManager {
         } else if (packet.hasLogout()) {
             storage.user = null;
             updateState(CONNECTED);
-        } else if (packet.hasListGame()) {
-            listGameSignal.emit(packet.listGame.games);
-        } else if (packet.hasCreateGame()) {
-            game = packet.createGame.game;
-            gameSignal.emit(game);
-        } else if (packet.hasJoinGame()) {
-            game = packet.joinGame.game;
-            gameSignal.emit(game);
-        } else if (packet.hasLeaveGame()) {
-            if (packet.leaveGame.user.uuid == user.uuid) {
-                game = null;
-                gameSignal.emit(null);
-            } else {
-                game = packet.leaveGame.game;
-                gameSignal.emit(game);
-            }
-        } else if (packet.hasStartGame()) {
-            game = packet.startGame.game;
-            gameSignal.emit(game);
+        } else if (packet.hasRoomList()) {
+            listRoomSignal.emit(packet.roomList.rooms);
+        } else if (packet.hasRoom()) {
+            room = packet.room.room;
+            roomSignal.emit(room);
+        } else if (packet.hasGameEvent()) {
+            gameEventSignal.emit(packet.gameEvent);
         }
     }
 }

src/client/haxe/ru/m/tankz/render/IRender.hx

@@ -6,6 +6,7 @@ import ru.m.tankz.game.IGame;
 
 interface IRender extends IView<Dynamic> extends GameListener {
     public var config(default, set):Config;
+    public var gridSize(default, set):GridSize;
     public function draw():Void;
     public function reset():Void;
 }

src/client/haxe/ru/m/tankz/render/Render.hx

@@ -21,10 +21,15 @@ import ru.m.tankz.render.item.EagleRenderItem;
 import ru.m.tankz.render.item.IRenderItem;
 import ru.m.tankz.render.item.TankRenderItem;
 import ru.m.tankz.Type;
+using ru.m.display.DisplayObjectContainerExtender;
 
 class Render extends SpriteView implements IRender {
 
     public var config(default, set):Config;
+    public var gridSize(default, set):GridSize;
+
+    private var mapWidth(get, null):Float;
+    private var mapHeight(get, null):Float;
 
     private var backgroundLayer:Sprite;
     private var groundLayer:Sprite;
@@ -50,19 +55,34 @@ class Render extends SpriteView implements IRender {
         reset();
     }
 
+    private function get_mapWidth():Float {
+        return config.map.cell.width * (gridSize != null ? gridSize.width : config.map.grid.width);
+    }
+
+    private function get_mapHeight():Float {
+        return config.map.cell.height * (gridSize != null ? gridSize.height : config.map.grid.height);
+    }
+
     private function set_config(value:Config):Config {
-        return config = value;
+        config = value;
+        setContentSize(mapWidth, mapHeight, "render");
+        drawBackground();
+        return config;
+    }
+
+    private function set_gridSize(value:GridSize):GridSize {
+        gridSize = value;
+        setContentSize(mapWidth, mapHeight, "render");
+        drawBackground();
+        return gridSize;
     }
 
     private function drawBackground():Void {
-        var width = config.map.cellWidth * config.map.gridWidth;
-        var height = config.map.cellHeight * config.map.gridHeight;
         var g:Graphics = backgroundLayer.graphics;
         g.clear();
         g.beginFill(0x000000);
-        g.drawRect(0, 0, width, height);
+        g.drawRect(0, 0, mapWidth, mapHeight);
         g.endFill();
-        setContentSize(width, height);
     }
 
     public function draw():Void {
@@ -76,7 +96,9 @@ class Render extends SpriteView implements IRender {
     }
 
     private function clearLayer(layer:DisplayObjectContainer) {
-        while (layer.numChildren > 0) layer.removeChildAt(0);
+        while (layer.numChildren > 0) {
+            layer.removeChildAt(0);
+        }
     }
 
     public function reset():Void {
@@ -93,7 +115,8 @@ class Render extends SpriteView implements IRender {
 
     public function onGameEvent(event:GameEvent):Void {
         switch event {
-            case START(_):
+            case START(_, level):
+                gridSize = level.size;
                 content.addEventListener(Event.ENTER_FRAME, onEnterFrame);
             case COMPLETE(_, _):
                 content.removeEventListener(Event.ENTER_FRAME, onEnterFrame);
@@ -117,10 +140,11 @@ class Render extends SpriteView implements IRender {
             case SPAWN(TANK(id, rect, playerId, info)):
                 var item = new TankRenderItem(rect);
                 var tankConfig = config.getTank(info.type);
-                item.color = config.getColor(playerId);
+                item.color = info.color;
                 item.skin = tankConfig.skin;
                 item.hits = info.hits;
                 item.bonus = info.bonus;
+                item.name = info.name == null ? "" : info.name;
                 items.set(id, item);
                 entryLayer.addChild(item.view);
                 item.update();
@@ -183,7 +207,7 @@ class Render extends SpriteView implements IRender {
                     var item = items[id];
                     entryLayer.removeChild(item.view);
                     playAnimate(item.rect.center, AnimateBundle.tankBoom());
-                    if (shot.score != 0) {
+                    if (shot.score != null) {
                         showScore(item.rect.center, shot.score);
                     }
                     items.remove(id);
@@ -202,7 +226,7 @@ class Render extends SpriteView implements IRender {
                 if (items.exists(id)) {
                     var item = items[id];
                     playAnimate(item.rect.center, AnimateBundle.tankBoom());
-                    if (shot.score != 0) {
+                    if (shot.score != null) {
                         showScore(item.rect.center, shot.score);
                     }
                     cast(item, EagleRenderItem).death = true;
@@ -211,7 +235,7 @@ class Render extends SpriteView implements IRender {
                 if (items.exists(id)) {
                     var item = items[id];
                     upperLayer.removeChild(item.view);
-                    if (shot.score != 0) {
+                    if (shot.score != null) {
                         showScore(item.rect.center, shot.score);
                     }
                     items.remove(id);
@@ -224,6 +248,9 @@ class Render extends SpriteView implements IRender {
                 item.destroy();
             case _:
         }
+        #if cpp
+        flash.Lib.current.stage.invalidate();
+        #end
     }
 
     private function playAnimate(point:Point, animate:OnceAnimate):Promise<Dynamic> {
@@ -233,7 +260,7 @@ class Render extends SpriteView implements IRender {
         return animate.play().then(function(animate:Animate):Void {
             // ToDo: clean animates on reset
             if (upperLayer.contains(animate)) {
-                upperLayer.removeChild(animate);
+                upperLayer.removeChildSafety(animate);
             }
             animate.dispose();
         });
@@ -248,6 +275,6 @@ class Render extends SpriteView implements IRender {
         view.x = point.x - view.width / 2;
         view.y = point.y - view.height / 2;
         upperLayer.addChild(view.content);
-        Timer.delay(function() upperLayer.removeChild(view.content), 1000);
+        Timer.delay(function() upperLayer.removeChildSafety(view.content), 1000);
     }
 }

src/client/haxe/ru/m/tankz/render/item/RenderItem.hx

@@ -7,6 +7,7 @@ import ru.m.geom.Rectangle;
 class RenderItem implements IRenderItem {
 
     public var view(get, null):DisplayObject;
+    public var content(get, null):DisplayObject;
 
     public var rect(default, null):Rectangle;
 
@@ -18,14 +19,24 @@ class RenderItem implements IRenderItem {
         throw "Not Implemented";
     }
 
+    private function get_content():DisplayObject {
+        return null;
+    }
+
     public function move(position:Position):Void {
         view.x = rect.x = position.x;
         view.y = rect.y = position.y;
         if (position.direction != null) {
             rect.direction = position.direction;
-            view.rotation = rect.direction.angle;
-            view.x = rect.x - rect.width * (rect.direction.x + 1) / 2 + rect.width * (rect.direction.y + 1) / 2 + 0.5 * rect.width;
-            view.y = rect.y - rect.height * (rect.direction.x + 1) / 2 - rect.height * (rect.direction.y + 1) / 2 + 1.5 * rect.height;
+            if (content != null) {
+                content.rotation = rect.direction.angle;
+                content.x = - rect.width * (rect.direction.x + 1) / 2 + rect.width * (rect.direction.y + 1) / 2 + 0.5 * rect.width;
+                content.y = - rect.height * (rect.direction.x + 1) / 2 - rect.height * (rect.direction.y + 1) / 2 + 1.5 * rect.height;
+            } else {
+                view.rotation = rect.direction.angle;
+                view.x = rect.x - rect.width * (rect.direction.x + 1) / 2 + rect.width * (rect.direction.y + 1) / 2 + 0.5 * rect.width;
+                view.y = rect.y - rect.height * (rect.direction.x + 1) / 2 - rect.height * (rect.direction.y + 1) / 2 + 1.5 * rect.height;
+            }
         }
     }
 

src/client/haxe/ru/m/tankz/render/item/TankRenderItem.hx

@@ -1,9 +1,13 @@
 package ru.m.tankz.render.item;
 
+import flash.display.BitmapData;
 import flash.display.DisplayObject;
 import flash.display.Sprite;
-import flash.display.BitmapData;
+import flash.text.TextField;
+import flash.text.TextFieldAutoSize;
+import flash.text.TextFormat;
 import haxework.color.Color;
+import haxework.text.BitmapTextField;
 import haxework.view.utils.BitmapUtil;
 import openfl.Assets;
 import ru.m.animate.Animate;
@@ -16,11 +20,13 @@ class TankRenderItem extends BitmapRenderItem {
     public var bonus(default, set):Bool;
     public var moves(default, set):Bool;
     public var protect(default, set):Bool;
+    public var name(default, set):String;
 
     private var container:Sprite;
     private var images:Array<BitmapData>;
     private var frame:Int;
     private var protectView:Animate;
+    private var nameView:TextField;
 
     public function new(rect:Rectangle) {
         super(rect);
@@ -29,13 +35,29 @@ class TankRenderItem extends BitmapRenderItem {
         protectView = AnimateBundle.tankProtect();
         protectView.visible = false;
         container.addChild(protectView);
+        nameView = buildNameView();
+        container.addChild(nameView);
         move(rect.position);
     }
 
+    private function buildNameView():TextField {
+        var result = new BitmapTextField();
+        result.defaultTextFormat = new TextFormat(Style.fontFamily, 10, 0xffffff);
+        result.embedFonts = Style.fontEmbed;
+        result.autoSize = TextFieldAutoSize.LEFT;
+        result.shadowColor = 0x000000;
+        result.stroke = true;
+        return result;
+    }
+
     override private function get_view():DisplayObject {
         return container;
     }
 
+    override private function get_content():DisplayObject {
+        return bitmap;
+    }
+
     private function redraw():Void {
         var image1 = Assets.getBitmapData('resources/image/tank/${skin}-0.png');
         var image2 = Assets.getBitmapData('resources/image/tank/${skin}-1.png');
@@ -105,6 +127,16 @@ class TankRenderItem extends BitmapRenderItem {
         return moves;
     }
 
+    private function set_name(value:String):String {
+        if (name != value) {
+            name = value;
+            nameView.text = name;
+            nameView.x = (rect.width - nameView.width) / 2;
+            nameView.y = -nameView.height / 2; //(rect.height - nameView.height) / 2;
+        }
+        return name;
+    }
+
     override public function update():Void {
         super.update();
         if (moves) {

src/client/haxe/ru/m/tankz/storage/GameStorage.hx

@@ -1,8 +1,8 @@
 package ru.m.tankz.storage;
 
 import haxework.storage.SharedObjectStorage;
-import ru.m.tankz.game.GameProgress;
-import ru.m.tankz.Type.GameType;
+import ru.m.tankz.game.PackProgress;
+import ru.m.tankz.Type;
 
 class GameStorage extends SharedObjectStorage  {
 
@@ -12,11 +12,11 @@ class GameStorage extends SharedObjectStorage  {
         super('game_${VERSION}');
     }
 
-    public function get(type:GameType):GameProgress {
-        return exists(type) ? read(type) : new GameProgress(type);
+    public function get(id:PackId):PackProgress {
+        return exists(id) ? read(id) : new PackProgress(id);
     }
 
-    public function set(progress:GameProgress):Void {
-        write(progress.type, progress);
+    public function set(progress:PackProgress):Void {
+        write(progress.id, progress);
     }
 }

src/client/haxe/ru/m/tankz/storage/NetworkStorage.hx

@@ -2,12 +2,12 @@ package ru.m.tankz.storage;
 
 import haxework.storage.SharedObjectStorage;
 
-class MultiplayerStorage extends SharedObjectStorage {
+class NetworkStorage extends SharedObjectStorage {
 
     public var user(get, set):User;
 
     public function new() {
-        super("multiplayer");
+        super("network");
     }
 
     private inline function get_user():User {

src/client/haxe/ru/m/tankz/storage/SettingsStorage.hx

@@ -3,50 +3,64 @@ package ru.m.tankz.storage;
 import flash.ui.Keyboard;
 import haxework.storage.SharedObjectStorage;
 import haxework.utils.ObjectUtil;
+import ru.m.control.DeviceAction;
+import ru.m.control.DeviceType;
 import ru.m.geom.Direction;
-import ru.m.tankz.control.ActionConfig;
-import ru.m.tankz.control.Control.TankAction;
+import ru.m.tankz.control.Binding;
+import ru.m.tankz.control.Control;
 
 class SettingsStorage extends SharedObjectStorage {
 
+    private static inline var VERSION = 3;
+
     public function new() {
-        super("settings");
+        super('settings_${VERSION}');
     }
 
-    public function getActionConfig(index:Int):ActionConfig {
-        return exists('action:$index') ? read('action:$index') : getDefaultActionConfig(index);
+    public function getBinding(index:Int):Binding {
+        return exists('action:$index') ? read('action:$index') : getDefaultBinding(index);
     }
 
-    public function setActionConffig(index:Int, value:ActionConfig) {
+    public function saveBinding(index:Int, value:Binding) {
         write('action:$index', value);
     }
 
-    public static function getDefaultActionConfig(index:Int):ActionConfig {
-        return ObjectUtil.clone(defaults.exists(index) ? defaults.get(index) : empty);
+    public static function getDefaultBinding(index:Int):Binding {
+        return ObjectUtil.clone(defaults.exists(index) ? defaults.get(index) : defaults.get(-1));
     }
 
-    private static var defaults:Map<Int, ActionConfig> = [
-        0 => new ActionConfig([
-            {action:TankAction.MOVE(Direction.TOP), key:Keyboard.W},
-            {action:TankAction.MOVE(Direction.LEFT), key:Keyboard.A},
-            {action:TankAction.MOVE(Direction.BOTTOM), key:Keyboard.S},
-            {action:TankAction.MOVE(Direction.RIGHT), key:Keyboard.D},
-            {action:TankAction.SHOT, key:Keyboard.SPACE},
-        ]),
-        1 => new ActionConfig([
-            {action:TankAction.MOVE(Direction.TOP), key:Keyboard.UP},
-            {action:TankAction.MOVE(Direction.LEFT), key:Keyboard.LEFT},
-            {action:TankAction.MOVE(Direction.BOTTOM), key:Keyboard.DOWN},
-            {action:TankAction.MOVE(Direction.RIGHT), key:Keyboard.RIGHT},
-            {action:TankAction.SHOT, key:Keyboard.NUMPAD_0},
-        ]),
-    ];
+    public static function buildGamepadBinding(id:Int):Binding {
+        var device = GAMEPAD(id);
+        return [
+            MOVE(Direction.TOP) => {device: device, action: DIRECTION(Direction.TOP)},
+            MOVE(Direction.LEFT) => {device: device, action: DIRECTION(Direction.LEFT)},
+            MOVE(Direction.BOTTOM) => {device: device, action: DIRECTION(Direction.BOTTOM)},
+            MOVE(Direction.RIGHT) => {device: device, action: DIRECTION(Direction.RIGHT)},
+            SHOT => {device: device, action: KEY(0)},
+        ];
+    }
 
-    private static var empty:ActionConfig = new ActionConfig([
-        {action:TankAction.MOVE(Direction.TOP), key:-1},
-        {action:TankAction.MOVE(Direction.LEFT), key:-1},
-        {action:TankAction.MOVE(Direction.BOTTOM), key:-1},
-        {action:TankAction.MOVE(Direction.RIGHT), key:-1},
-        {action:TankAction.SHOT, key:-1},
-    ]);
+    private static var defaults:Map<Int, Binding> = [
+        -1 => [
+            MOVE(Direction.TOP) => null,
+            MOVE(Direction.LEFT) => null,
+            MOVE(Direction.BOTTOM) => null,
+            MOVE(Direction.RIGHT) => null,
+            SHOT => null,
+        ],
+        0 => [
+            MOVE(Direction.TOP) => {device: KEYBOARD, action: KEY(Keyboard.W)},
+            MOVE(Direction.LEFT) => {device: KEYBOARD, action: KEY(Keyboard.A)},
+            MOVE(Direction.BOTTOM) => {device: KEYBOARD, action: KEY(Keyboard.S)},
+            MOVE(Direction.RIGHT) => {device: KEYBOARD, action: KEY(Keyboard.D)},
+            SHOT => {device: KEYBOARD, action: KEY(Keyboard.SPACE)},
+        ],
+        1 => [
+            MOVE(Direction.TOP) => {device: KEYBOARD, action: KEY(Keyboard.UP)},
+            MOVE(Direction.LEFT) => {device: KEYBOARD, action: KEY(Keyboard.LEFT)},
+            MOVE(Direction.BOTTOM) => {device: KEYBOARD, action: KEY(Keyboard.DOWN)},
+            MOVE(Direction.RIGHT) => {device: KEYBOARD, action: KEY(Keyboard.RIGHT)},
+            SHOT => {device: KEYBOARD, action: KEY(Keyboard.NUMPAD_0)},
+        ],
+    ];
 }

src/client/haxe/ru/m/tankz/view/ClientView.hx

@@ -1,22 +1,34 @@
 package ru.m.tankz.view;
 
+import ru.m.tankz.game.IGame;
 import flash.events.KeyboardEvent;
 import flash.ui.Keyboard;
 import haxework.resources.IResources;
+import haxework.view.ButtonView;
 import haxework.view.frame.FrameSwitcher;
-import haxework.view.IView;
+import haxework.view.LabelView;
+import haxework.view.VGroupView;
+import ru.m.tankz.network.NetworkManager;
 import ru.m.tankz.sound.SoundManager;
+import ru.m.tankz.view.popup.LoginPopup;
 
-@:template class ClientView extends FrameSwitcher {
+@:template class ClientView extends VGroupView {
+    @:view("switcher") var switcherView:FrameSwitcher;
+    @:view var username:LabelView;
+    @:view("login") var loginButton:ButtonView;
+    @:view("logout") var logoutButton:ButtonView;
 
+    @:provide var network:NetworkManager;
     @:provide var resources:IResources;
     @:provide var switcher:FrameSwitcher;
     @:provide var soundManager:SoundManager;
+    @:provide var game:IGame;
 
     public function init():Void {
         resources.text.put('version', '${Const.VERSION}');
-        switcher = this;
-        onSwitch.connect(onFrameSwitch);
+        switcher = switcherView;
+        network.stateSignal.connect(onConnectionState);
+        onConnectionState(network.state);
     }
 
     public function launch():Void {
@@ -24,17 +36,50 @@ import ru.m.tankz.sound.SoundManager;
         content.stage.addEventListener(KeyboardEvent.KEY_UP, function(event:KeyboardEvent):Void {
             switch event.keyCode {
                 case Keyboard.ESCAPE:
-                    change(StartFrame.ID);
+                    switcher.change(StartFrame.ID);
                 case Keyboard.M:
                     soundManager.mute = !soundManager.mute;
+                case Keyboard.P:
+                    if (game != null) {
+                        game.pause = !game.pause;
+                    }
             }
         });
-        change(StartFrame.ID);
+        switcher.change(StartFrame.ID);
     }
 
-    private function onFrameSwitch(frame:IView<Dynamic>):Void {
-        if (frame.id == StartFrame.ID) {
-            soundManager.stopAll();
+    private function onConnectionState(state:ConnectionState):Void {
+        L.d("ClientView", 'onConnectionState: ${state}');
+        switch state {
+            case ONLINE(user):
+                username.text = user.name;
+                logoutButton.visible = true;
+                loginButton.visible = false;
+            case CONNECTED:
+                username.text = "";
+                logoutButton.visible = false;
+                loginButton.visible = true;
+            case ERROR(error):
+                //L.e("ClientView", 'onConnectionState: ERROR', error);
+                L.w("ClientView", 'onConnectionState: ERROR');
+            case _:
+                username.text = "";
+                logoutButton.visible = false;
+                loginButton.visible = false;
         }
     }
+
+    private function login():Void {
+        LoginPopup.instance.show().then(function(user:User):Void {
+            L.d("Login", 'user: $user');
+        });
+    }
+
+    private function logout():Void {
+        network.logout();
+    }
+
+    private function close():Void {
+        switcher.change(StartFrame.ID);
+    }
 }

src/client/haxe/ru/m/tankz/view/ClientView.yaml

@@ -1,21 +1,51 @@
 ---
-$type: haxework.view.frame.FrameSwitcher
-geometry.size.stretch: true
-skinId: dark
 views:
-  - id: start
-    $type: ru.m.tankz.view.StartFrame
-  - id: level
-    $type: ru.m.tankz.view.LevelFrame
-  - id: game
-    $type: ru.m.tankz.view.GameFrame
-  - id: result
-    $type: ru.m.tankz.view.ResultFrame
-  - id: settings
-    $type: ru.m.tankz.view.SettingsFrame
-  - id: record
-    $type: ru.m.tankz.view.RecordFrame
-  - id: game_list
-    $type: ru.m.tankz.view.network.GameListFrame
-  - id: game_room
-    $type: ru.m.tankz.view.network.GameRoomFrame
+  - $type: haxework.view.frame.FrameSwitcher
+    id: switcher
+    geometry.size.stretch: true
+    skinId: dark
+    views:
+      - id: start
+        $type: ru.m.tankz.view.StartFrame
+      - id: level
+        $type: ru.m.tankz.view.LevelFrame
+      - id: game
+        $type: ru.m.tankz.view.GameFrame
+      - id: result
+        $type: ru.m.tankz.view.ResultFrame
+      - id: settings
+        $type: ru.m.tankz.view.SettingsFrame
+      - id: record
+        $type: ru.m.tankz.view.RecordFrame
+      - id: room_list
+        $type: ru.m.tankz.view.network.RoomListFrame
+      - id: room
+        $type: ru.m.tankz.view.network.RoomFrame
+  - $type: haxework.view.HGroupView
+    skinId: panel
+    layout.margin: 10
+    views:
+      - id: settings
+        $type: haxework.view.ButtonView
+        skinId: button.settings
+        +onPress: $code:switcher.change('settings')
+      - $type: haxework.view.SpriteView
+        geometry.size.width: 50%
+      - id: username
+        $type: haxework.view.LabelView
+        skinId: text
+      - id: login
+        $type: haxework.view.ButtonView
+        skinId: button.login
+        +onPress: $code:login()
+      - id: logout
+        $type: haxework.view.ButtonView
+        skinId: button.logout
+        +onPress: $code:logout()
+        visible: false
+      - $type: haxework.view.SpriteView
+        geometry.size.width: 50%
+      - id: close
+        $type: haxework.view.ButtonView
+        skinId: button.close
+        +onPress: $code:close()

src/client/haxe/ru/m/tankz/view/GameFrame.hx

@@ -1,21 +1,20 @@
 package ru.m.tankz.view;
 
-import haxe.ds.Option;
 import haxework.view.frame.FrameSwitcher;
 import haxework.view.VGroupView;
-import ru.m.tankz.game.Game;
+import ru.m.control.DeviceType;
+import ru.m.control.IControlBus;
 import ru.m.tankz.game.GameEvent;
-import ru.m.tankz.game.GameRunner;
 import ru.m.tankz.game.GameState;
 import ru.m.tankz.game.IGame;
-import ru.m.tankz.game.record.GamePlayer;
 import ru.m.tankz.game.record.GameRecord;
-import ru.m.tankz.game.record.GameRecorder;
 import ru.m.tankz.network.NetworkManager;
 import ru.m.tankz.sound.SoundManager;
 import ru.m.tankz.storage.GameStorage;
-import ru.m.tankz.storage.RecordStorage;
+import ru.m.tankz.storage.SettingsStorage;
+import ru.m.tankz.Type;
 import ru.m.tankz.view.game.GameView;
+import ru.m.tankz.view.GamepadView;
 
 @:template class GameFrame extends VGroupView implements GameListener {
     public static inline var ID = "game";
@@ -23,33 +22,37 @@ import ru.m.tankz.view.game.GameView;
     private static inline var TAG = "GameFrame";
 
     @:view("game") private var gameView(default, null):GameView;
+    @:view private var gamepad(default, null):GamepadView;
 
     @:provide var network:NetworkManager;
     @:provide var soundManager:SoundManager;
     @:provide var state:GameState;
     @:provide var record:GameRecord;
-    @:provide("result") var result:GameState;
     @:provide var switcher:FrameSwitcher;
-    @:provide var gameStorage:GameStorage;
-    @:provide var recordStorage:RecordStorage;
+    @:provide static var gameStorage:GameStorage;
+    @:provide static var settings:SettingsStorage;
 
-    private var game:IGame;
-    private var runner:GameRunner;
-    private var recorder:GameRecorder;
-    private var player:GamePlayer;
+    @:provide var game:IGame;
+    @:provide static var bus:IControlBus;
 
-    public function onShow():Void {
-        if (record != null) {
-            play(record);
-            record = null;
-        } else {
-            start(state);
-        }
+    public function init():Void {
+        bus.connect(gamepad);
     }
 
-    private function buildGame(state:GameState):Void {
-        gameView.type = state.type;
-        game = new Game(state);
+    public function onShow():Void {
+        gamepad.visible = false;
+        // ToDo:
+        for (i in 0...1) {
+            for (bind in settings.getBinding(i)) {
+                switch bind.device {
+                    case GAMEPAD(GamepadView.ID):
+                        gamepad.visible = true;
+                        break;
+                    case _:
+                }
+            }
+        }
+        gameView.type = game.type;
         soundManager.config = game.config;
         gameView.render.config = game.config;
         game.connect(gameView.render);
@@ -57,28 +60,11 @@ import ru.m.tankz.view.game.GameView;
         if (gameView.panel != null) {
             game.connect(gameView.panel);
         }
-    }
-
-    private function start(state:GameState):Void {
-        buildGame(state);
         game.connect(this);
-        recorder = new GameRecorder();
-        game.connect(recorder);
-        runner = new GameRunner(game);
-        runner.start(state);
-    }
-
-    private function play(record:GameRecord):Void {
-        buildGame(record.state);
-        player = new GamePlayer(game, record);
-        player.start();
+        game.start();
     }
 
     private function stop():Void {
-        if (runner != null) {
-            runner.dispose();
-            runner = null;
-        }
         if (game != null) {
             game.dispose();
             game = null;
@@ -88,28 +74,33 @@ import ru.m.tankz.view.game.GameView;
 
     public function onGameEvent(event:GameEvent):Void {
         switch event {
-            case GameEvent.COMPLETE(state, _):
-                // ToDo:
-                recordStorage.save(recorder.record);
-                result = state;
-                this.state = switch runner.next() {
-                    case Some(s):
-                        // ToDo:
-                        var progress = gameStorage.get(game.type);
-                        progress.completeLevel(result.levelId, result.presetId);
-                        gameStorage.set(progress);
-                        s;
-                    case None:
-                        new GameState(state.type, state.presetId, 0);
-                }
+            case COMPLETE(state, winner):
+                this.state = state;
+                updateProgress(game, winner);
                 stop();
                 switcher.change(ResultFrame.ID);
             case _:
         }
     }
 
+    // ToDo:
+    private static function updateProgress(game:IGame, winner:TeamId):Void {
+        var complete = true;
+        for (rule in game.config.game.complete) {
+            if (rule.team != null && rule.team != winner) {
+                complete = false;
+            }
+        }
+        if (complete) {
+            var progress = gameStorage.get(new PackId(game.state.type));
+            progress.completeLevel(game.level.id, game.state.presetId);
+            gameStorage.set(progress);
+        }
+    }
+
     public function onHide():Void {
         stop();
+        soundManager.stopAll();
     }
 
     public function close():Void {

src/client/haxe/ru/m/tankz/view/GameFrame.yaml

@@ -2,13 +2,12 @@
 views:
   - $type: haxework.view.VGroupView
     skinId: container
+    layout.overflow: true
     views:
       - id: game
         $type: ru.m.tankz.view.game.GameView
-#  - $type: haxework.view.HGroupView
-#    skinId: panel
-#    views:
-#      - id: close
-#        $type: haxework.view.ButtonView
-#        skinId: button.close
-#        +onPress: $code:close()
+  - id: gamepad
+    $type: ru.m.tankz.view.GamepadView
+    geometry.position: absolute
+    geometry.size.stretch: true
+    visible: false

src/client/haxe/ru/m/tankz/view/GamepadView.hx

@@ -0,0 +1,159 @@
+package ru.m.tankz.view;
+
+import flash.display.Graphics;
+import flash.display.Stage;
+import flash.events.MouseEvent;
+import flash.events.TouchEvent;
+import haxework.signal.Signal;
+import haxework.view.skin.ISkin;
+import haxework.view.SpriteView;
+import ru.m.control.DeviceAction;
+import ru.m.control.DeviceType;
+import ru.m.control.IControlDevice;
+import ru.m.geom.Direction;
+import ru.m.geom.Point;
+import ru.m.geom.Rectangle;
+
+typedef ActionArea = {
+    var action:DeviceAction;
+    var rect:Rectangle;
+}
+
+class GamepadSkin implements ISkin<GamepadView> {
+
+    public var color(default, default):Int;
+
+    public function new(color:Int = 0) {
+        this.color = color;
+    }
+
+    public function draw(view:GamepadView):Void {
+        var graphics:Graphics = view.content.graphics;
+        graphics.clear();
+        graphics.beginFill(0, 0.0);
+        graphics.drawRect(0, 0, view.width, view.height);
+        graphics.endFill();
+        graphics.lineStyle(2, color);
+        graphics.beginFill(color, 0.2);
+        for (area in view.areas) {
+            graphics.drawRect(area.rect.x, area.rect.y, area.rect.width, area.rect.height);
+        }
+        graphics.lineStyle();
+    }
+}
+
+class GamepadView extends SpriteView implements IControlDevice {
+    public static var ID(default, never):Int = -128;
+
+    public var type(default, null):DeviceType;
+    public var signal(default, null):Signal2<DeviceAction, Bool>;
+
+    public var areas(default, null):Array<ActionArea>;
+    public var currentAreas(default, null):Map<Int, ActionArea>;
+
+    private var stage:Stage;
+
+    public function new() {
+        super();
+        type = GAMEPAD(ID);
+        signal = new Signal2();
+        areas = [];
+        currentAreas = new Map();
+        skin = [new GamepadSkin(0x00ff00)];
+        content.addEventListener(MouseEvent.MOUSE_DOWN, onMouseDown);
+        content.addEventListener(TouchEvent.TOUCH_BEGIN, onTouchBegin);
+    }
+
+    private function onMouseDown(event:MouseEvent):Void {
+        onMouseMove(event);
+        stage = content.stage;
+        stage.addEventListener(MouseEvent.MOUSE_MOVE, onMouseMove);
+        stage.addEventListener(MouseEvent.MOUSE_UP, onMouseUp);
+    }
+
+    private function onMouseMove(event:MouseEvent):Void {
+        var point = new Point(event.localX, event.localY);
+        updateTouch(-1, point);
+    }
+
+    private function onMouseUp(event:MouseEvent):Void {
+        endTouch(-1);
+        stage.removeEventListener(MouseEvent.MOUSE_MOVE, onMouseMove);
+        stage.removeEventListener(MouseEvent.MOUSE_UP, onMouseUp);
+    }
+
+    private function onTouchBegin(event:TouchEvent):Void {
+        onTouchMove(event);
+        stage = content.stage;
+        stage.addEventListener(TouchEvent.TOUCH_MOVE, onTouchMove);
+        stage.addEventListener(TouchEvent.TOUCH_END, onTouchEnd);
+    }
+
+    private function onTouchMove(event:TouchEvent):Void {
+        var point = new Point(event.localX, event.localY);
+        updateTouch(event.touchPointID, point);
+    }
+
+    private function onTouchEnd(event:TouchEvent):Void {
+        endTouch(event.touchPointID);
+        if (Lambda.count(currentAreas) == 0) {
+            stage.removeEventListener(TouchEvent.TOUCH_MOVE, onTouchMove);
+            stage.removeEventListener(TouchEvent.TOUCH_END, onTouchEnd);
+        }
+    }
+
+    private function updateTouch(pointID:Int, point:Point):Void {
+        if (currentAreas.exists(pointID)) {
+            var area = currentAreas[pointID];
+            if (!area.rect.contain(point)) {
+                currentAreas.remove(pointID);
+                signal.emit(area.action, false);
+            }
+        }
+        for (area in areas) {
+            if (area.rect.contain(point)) {
+                currentAreas[pointID] = area;
+                signal.emit(area.action, true);
+                break;
+            }
+        }
+    }
+
+    private function endTouch(pointID:Int):Void {
+        if (currentAreas.exists(pointID)) {
+            signal.emit(currentAreas[pointID].action, false);
+            currentAreas.remove(pointID);
+        }
+    }
+
+    override public function update():Void {
+        super.update();
+        areas = [];
+        var size = Math.min(width, height) / 7;
+        var padding = size / 2;
+        areas.push({
+            action: DIRECTION(Direction.TOP),
+            rect: new Rectangle(padding + size, height - size * 3 - padding, size, size)
+        });
+        areas.push({
+            action: DIRECTION(Direction.LEFT),
+            rect: new Rectangle(padding, height - size * 2 - padding, size, size)
+        });
+        areas.push({
+            action: DIRECTION(Direction.BOTTOM),
+            rect: new Rectangle(padding + size, height - size - padding, size, size)
+        });
+        areas.push({
+            action: DIRECTION(Direction.RIGHT),
+            rect: new Rectangle(padding + size * 2, height - size * 2 - padding, size, size)
+        });
+        areas.push({
+            action: KEY(0),
+            rect: new Rectangle(width - size * 1.5 - padding, height - size * 2 - padding, size, size)
+        });
+    }
+
+    public function dispose():Void {
+        stage = null;
+    }
+}

src/client/haxe/ru/m/tankz/view/LevelFrame.hx

@@ -8,6 +8,8 @@ import haxework.view.VGroupView;
 import ru.m.tankz.bundle.ILevelBundle;
 import ru.m.tankz.config.Config;
 import ru.m.tankz.game.GameState;
+import ru.m.tankz.game.IGame;
+import ru.m.tankz.local.LocalGame;
 import ru.m.tankz.storage.GameStorage;
 import ru.m.tankz.Type;
 import ru.m.tankz.view.popup.LevelPopup;
@@ -16,49 +18,53 @@ import ru.m.tankz.view.popup.LevelPopup;
     public static inline var ID = "level";
 
     @:view var header:LabelView;
-    @:view var levels:DataView<LevelId, ButtonView>;
+    @:view var levels:DataView<LevelConfig, ButtonView>;
 
     @:provide var state:GameState;
+    @:provide var game:IGame;
     @:provide var switcher:FrameSwitcher;
     @:provide var levelBundle:ILevelBundle;
     @:provide var storage:GameStorage;
 
+    private var pack:LevelPack;
     private var levelPopup:LevelPopup;
 
     public function onShow():Void {
         header.text = state.type;
-        levels.data = [for (i in 0...state.config.game.levels) i];
+        pack = levelBundle.get(new PackId(state.type));
+        levels.data = pack.data;
     }
 
-    private function start(level:LevelConfig, preset:GamePreset):Void {
-        state.levelId = level.id;
+    private function start(level:LevelConfig, preset:GamePreset, control:ControlPreset):Void {
         state.presetId = preset.id;
+        state.controls = control.values;
+        game = new LocalGame(state, level);
         switcher.change(GameFrame.ID);
     }
 
-    private function levelViewFactory(index:Int, levelId:LevelId):ButtonView {
-        var progress = storage.get(state.type);
+    private function levelViewFactory(index:Int, level:LevelConfig):ButtonView {
+        var progress = storage.get(pack.id);
         var result = new ButtonView();
         result.skinId = "button.level";
-        var presetsLine = [for (p in state.config.presets) progress.isPresetCompleted(levelId, p.id) ? '*' : '_'].join('');
-        result.text = '${levelId}\n${presetsLine}';
-        result.disabled = !progress.isLevelAvailable(levelId);
+        var presetsLine = [for (p in state.config.presets) progress.isPresetCompleted(level.id, p.id) ? '*' : '_'].join('');
+        result.text = '${level.id}\n${presetsLine}';
+        result.disabled = !progress.isLevelAvailable(level.id);
         return result;
     }
 
-    private function onLevelSelect(index:Int, levelId:LevelId, view:ButtonView):Void {
-        if (!storage.get(state.type).isLevelAvailable(levelId)) {
+    private function onLevelSelect(index:Int, level:LevelConfig, view:ButtonView):Void {
+        if (!storage.get(pack.id).isLevelAvailable(level.id)) {
             return;
         }
         if (levelPopup == null) {
             levelPopup = new LevelPopup();
         }
-        var level = levelBundle.get(state.type, state.config, levelId);
         levelPopup.setData(
             level,
             state.config.presets,
-            storage.get(state.type)
+            state.config.controls,
+            storage.get(pack.id)
         );
-        levelPopup.show().then(function(preset) preset != null ? start(level, preset) : {});
+        levelPopup.show().then(function(result) result != null ? start(level, result.preset, result.control) : {});
     }
 }

src/client/haxe/ru/m/tankz/view/LevelFrame.yaml

@@ -16,9 +16,3 @@ views:
         factory: $this:levelViewFactory
         +onItemSelect: $this:onLevelSelect
         geometry.padding: 10
-  - $type: haxework.view.HGroupView
-    skinId: panel
-    views:
-      - $type: haxework.view.ButtonView
-        skinId: button.close
-        +onPress: $code:switcher.change('start')

src/client/haxe/ru/m/tankz/view/RecordFrame.hx

@@ -25,8 +25,4 @@ import ru.m.tankz.storage.RecordStorage;
     private function onRecordSelect(item:IListItemView<GameRecordInfo>):Void {
 
     }
-
-    private function close() {
-        switcher.change(StartFrame.ID);
-    }
 }

src/client/haxe/ru/m/tankz/view/RecordFrame.yaml

@@ -16,9 +16,3 @@ views:
         scroll:
             $type: haxework.view.list.VScrollBarView
             skinId: scroll
-  - $type: haxework.view.HGroupView
-    skinId: panel
-    views:
-      - $type: haxework.view.ButtonView
-        skinId: button.close
-        +onPress: $code:close()

src/client/haxe/ru/m/tankz/view/ResultFrame.hx

@@ -1,44 +1,43 @@
 package ru.m.tankz.view;
 
-import haxework.view.ButtonView;
 import haxework.view.DataView;
 import haxework.view.frame.FrameSwitcher;
 import haxework.view.LabelView;
 import haxework.view.VGroupView;
+import ru.m.tankz.game.GameRunner;
 import ru.m.tankz.game.GameState;
+import ru.m.tankz.game.IGame;
 import ru.m.tankz.view.common.LifeView;
 
 @:template class ResultFrame extends VGroupView {
     public static var ID(default, never):String = "result";
 
     @:view("result") var resultView:DataView<PlayerState, LifeView>;
-    @:view("next") var nextButton:ButtonView;
     @:view("level") var levelLabel:LabelView;
 
     @:provide var frames:FrameSwitcher;
     @:provide var state:GameState;
-    @:provide("result") var resultState:GameState;
+    @:provide var game:IGame;
 
     private function playerViewFactory(index:Int, player:PlayerState) {
         var view = new LifeView();
-        var playerConfig = resultState.config.getPlayer(player.id);
+        var playerConfig = state.config.getPlayer(player.id);
         var tankType = playerConfig.tanks[0].type;
-        var tankConfig = resultState.config.getTank(tankType);
+        var tankConfig = state.config.getTank(tankType);
         view.tank = tankConfig == null ? 'ba' : tankConfig.skin;
-        view.color = resultState.getPlayerColor(player.id);
+        view.color = state.getPlayerColor(player.id);
         view.life = player.frags;
         view.score = player.score;
         return view;
     }
 
     public function onShow() {
-        resultView.data =  Lambda.array(resultState.players);
-        levelLabel.text = 'Level ${resultState.levelId}';
-        nextButton.visible = state != null;
+        resultView.data =  Lambda.array(state.players);
+        //levelLabel.text = 'Level ${state.levelId}'; // ToDo: level?
     }
 
     private function next() {
-        frames.change(GameFrame.ID);
+        //ToDo: next level?
     }
 
     private function close() {

src/client/haxe/ru/m/tankz/view/ResultFrame.yaml

@@ -14,16 +14,3 @@ views:
           $type: haxework.view.layout.VerticalLayout
           hAlign: right
           margin: 10
-  - $type: haxework.view.HGroupView
-    skinId: panel
-    views:
-      - id: close
-        $type: haxework.view.ButtonView
-        skinId: button.close
-        +onPress: $code:close()
-      - $type: haxework.view.SpriteView
-        geometry.size.width: 100%
-      - id: next
-        $type: haxework.view.ButtonView
-        skinId: button.next
-        +onPress: $code:next()

src/client/haxe/ru/m/tankz/view/SettingsFrame.hx

@@ -1,11 +1,7 @@
 package ru.m.tankz.view;
 
-import haxework.view.frame.FrameSwitcher;
 import haxework.view.VGroupView;
 
 @:template class SettingsFrame extends VGroupView {
-
     public static var ID(default, never):String = "settings";
-
-    @:provide var switcher:FrameSwitcher;
 }

src/client/haxe/ru/m/tankz/view/SettingsFrame.yaml

@@ -2,20 +2,28 @@
 views:
   - $type: haxework.view.VGroupView
     skinId: container
+    geometry.padding: 20
     views:
       - $type: haxework.view.LabelView
         skinId: text.header
         text: Settings
-      - $type: haxework.view.HGroupView
-        layout.margin: 20
-        views:
-          - $type: ru.m.tankz.view.settings.SettingsEditor
-            controlIndex: 0
-          - $type: ru.m.tankz.view.settings.SettingsEditor
-            controlIndex: 1
-  - $type: haxework.view.HGroupView
-    skinId: panel
-    views:
-      - $type: haxework.view.ButtonView
-        skinId: button.close
-        +onPress: $code:switcher.change('start')
+      - $type: haxework.view.ScrollView
+        geometry.size.stretch: true
+        scroll:
+          $type: haxework.view.list.VScrollBarView
+          skinId: scroll.vertical
+        view:
+          $type: haxework.view.GroupView
+          geometry.size.stretch: true
+          layout:
+            $type: haxework.view.layout.TailLayout
+            vAlign: top
+            margin: 20
+            overflow: true
+          views:
+            - id: settings0
+              $type: ru.m.tankz.view.settings.SettingsEditor
+              controlIndex: 0
+            - id: settings1
+              $type: ru.m.tankz.view.settings.SettingsEditor
+              controlIndex: 1

src/client/haxe/ru/m/tankz/view/StartFrame.hx

@@ -1,12 +1,12 @@
 package ru.m.tankz.view;
 
-import haxework.view.ButtonView;
-import haxework.view.LabelView;
 import haxework.view.frame.FrameSwitcher;
 import haxework.view.VGroupView;
 import ru.m.tankz.game.GameState;
 import ru.m.tankz.network.NetworkManager;
 import ru.m.tankz.Type.GameType;
+import ru.m.tankz.view.network.RoomListFrame;
+import ru.m.tankz.view.network.RoomFrame;
 import ru.m.tankz.view.popup.FontPopup;
 import ru.m.tankz.view.popup.LoginPopup;
 
@@ -14,54 +14,34 @@ import ru.m.tankz.view.popup.LoginPopup;
 
     public static var ID(default, never):String = "start";
 
-    @:view var username:LabelView;
-    @:view("login") var loginButton:ButtonView;
-    @:view("logout") var logoutButton:ButtonView;
-    @:view("network") var networkButton:ButtonView;
-
     @:provide var state:GameState;
     @:provide var switcher:FrameSwitcher;
     @:provide var network:NetworkManager;
 
     private var fontPopup:FontPopup;
 
-    public function onShow():Void {
-        onConnectionState(network.state);
-        network.stateSignal.connect(onConnectionState);
-    }
-
-    public function onHide():Void {
-        network.stateSignal.disconnect(onConnectionState);
-    }
-
-    private function onConnectionState(state:ConnectionState):Void {
-        trace("state", state);
-        setUser(switch state {
-            case ONLINE(user): user;
-            case _: null;
-        });
-    }
-
-    private function setUser(value:User):Void {
-        username.text = value == null ? "" : value.name;
-        loginButton.visible = value == null;
-        logoutButton.visible = value != null;
-        networkButton.disabled = value == null;
-    }
-
     private function startGame(type:GameType):Void {
         state = new GameState(type);
         switcher.change(LevelFrame.ID);
     }
 
-    private function login():Void {
-        LoginPopup.instance.show().then(function(user:User):Void {
-            L.d("Login", 'user: $user');
-        });
-    }
-
-    private function logout():Void {
-        network.logout();
+    private function startNetwork():Void {
+        switch network.state {
+            case ONLINE(user):
+                if (network.room != null) {
+                    switcher.change(RoomFrame.ID);
+                    network.joinGame(network.room.game.id, true);
+                } else {
+                    switcher.change(RoomListFrame.ID);
+                }
+            case CONNECTED:
+                LoginPopup.instance.show().then(function(user):Void {
+                    if (user != null) {
+                        switcher.change(RoomListFrame.ID);
+                    }
+                });
+            case _:
+        }
     }
 
     private function choiceFont():Void {

src/client/haxe/ru/m/tankz/view/StartFrame.yaml

@@ -28,31 +28,9 @@ views:
           - id: network
             $type: haxework.view.ButtonView
             skinId: button
-            +onPress: $code:switcher.change('game_list')
+            +onPress: $code:startNetwork()
             text: Network
-            disabled: true
-    - $type: haxework.view.HGroupView
-      skinId: panel
-      views:
-          - id: settings
-            $type: haxework.view.ButtonView
-            skinId: button.settings
-            +onPress: $code:switcher.change('settings')
-          - $type: haxework.view.SpriteView
-            geometry.size.width: 100%
-          - id: username
-            $type: haxework.view.LabelView
-            skinId: text
-            geometry.margin.right: 10
-          - id: login
-            $type: haxework.view.ButtonView
-            skinId: button.login
-            +onPress: $code:login()
-          - id: logout
-            $type: haxework.view.ButtonView
-            skinId: button.logout
-            +onPress: $code:logout()
-            visible: false
+            #disabled: true
     - $type: haxework.view.LabelView
       geometry.hAlign: right
       geometry.vAlign: top

src/client/haxe/ru/m/tankz/view/common/RecordView.hx

@@ -1,5 +1,7 @@
 package ru.m.tankz.view.common;
 
+import ru.m.tankz.game.record.GamePlayer;
+import ru.m.tankz.game.IGame;
 import haxework.view.frame.FrameSwitcher;
 import haxework.view.HGroupView;
 import haxework.view.LabelView;
@@ -18,7 +20,7 @@ import ru.m.tankz.storage.RecordStorage;
 
     @:provide var recordStorage:RecordStorage;
     @:provide var switcher:FrameSwitcher;
-    @:provide var record:GameRecord;
+    @:provide var game:IGame;
 
     private function set_data(value:GameRecordInfo):GameRecordInfo {
         if (data != value) {
@@ -32,7 +34,8 @@ import ru.m.tankz.storage.RecordStorage;
     }
 
     private function play():Void {
-        record = recordStorage.read(data.id);
+        var record = recordStorage.read(data.id);
+        game = new GamePlayer(record);
         switcher.change(GameFrame.ID);
     }
 

src/client/haxe/ru/m/tankz/view/game/ClassicGamePanel.hx

@@ -21,7 +21,6 @@ import ru.m.tankz.view.common.LifeView;
     private var player2Id:PlayerId = new PlayerId(ClassicGame.HUMAN, 1);
 
     public function refresh(state:GameState):Void {
-        level.text = 'Level ${state.levelId}';
         bot.life = state.getTeamLife(ClassicGame.BOT);
         player1.life = state.getPlayerLife(player1Id);
         player1.score = state.getPlayerScore(player1Id);
@@ -36,7 +35,8 @@ import ru.m.tankz.view.common.LifeView;
 
     public function onGameEvent(event:GameEvent):Void {
         switch event {
-            case START(state):
+            case START(state, level):
+                this.level.text = 'Level ${level.id}';
                 refresh(state);
             case CHANGE(TEAM_LIFE(teamId, life)):
                 if (teamId == ClassicGame.BOT) {

src/client/haxe/ru/m/tankz/view/game/ClassicGamePanel.yaml

@@ -2,7 +2,7 @@
 geometry.padding: 5
 geometry.size.height: 100%
 layout.margin: 5
-layout.hAlign: right
+layout.hAlign: left
 views:
   - id: level
     $type: haxework.view.LabelView

src/client/haxe/ru/m/tankz/view/game/DeathGamePanel.hx

@@ -16,8 +16,8 @@ import ru.m.tankz.view.common.LifeView;
 
     public function onGameEvent(event:GameEvent):Void {
         switch event {
-            case START(state):
-                level.text = 'Level ${state.levelId}';
+            case START(state, level):
+                this.level.text = 'Level ${level.id}';
                 players.data = Lambda.array(state.players);
             case _:
                 for (view in players.views) {

src/client/haxe/ru/m/tankz/view/game/DotaGamePanel.hx

@@ -17,7 +17,6 @@ import ru.m.tankz.view.common.LifeView;
     @:view var level:LabelView;
 
     public function refresh(state:GameState):Void {
-        level.text = 'Level ${state.levelId}';
         radiant.life = state.getTeamLife(DotaGame.RADIANT);
         radiant.score = state.getTeamScore(DotaGame.RADIANT);
         dire.life = state.getTeamLife(DotaGame.DIRE);
@@ -34,7 +33,8 @@ import ru.m.tankz.view.common.LifeView;
 
     public function onGameEvent(event:GameEvent):Void {
         switch event {
-            case START(state):
+            case START(state, level):
+                this.level.text = 'Level ${level.id}';
                 refresh(state);
             case CHANGE(TEAM_LIFE(teamId, life)):
                 getLifeView(teamId).life = life;

src/client/haxe/ru/m/tankz/view/network/GameItemView.hx

@@ -1,24 +0,0 @@
-package ru.m.tankz.view.network;
-
-import haxework.view.LabelView;
-import haxework.view.HGroupView;
-import haxework.view.list.ListView;
-import ru.m.tankz.proto.core.GameProto;
-
-@:template class GameItemView extends HGroupView implements IListItemView<GameProto> {
-
-    public var item_index(default, default):Int;
-    public var data(default, set):GameProto;
-
-    @:view var label:LabelView;
-
-    private function set_data(value:GameProto):GameProto {
-        data = value;
-        label.text = '[${value.creator.name}] ${value.type} ${value.level} (${value.players.length})';
-        return data;
-    }
-
-    public static function factory():GameItemView {
-        return new GameItemView();
-    }
-}

src/client/haxe/ru/m/tankz/view/network/GameItemView.yaml

@@ -1,8 +0,0 @@
----
-geometry.size.width: 100%
-geometry.size.height: 48
-views:
-    - id: label
-      $type: haxework.view.LabelView
-      geometry.size.stretch: true
-      skinId: text.box

src/client/haxe/ru/m/tankz/view/network/GameListFrame.hx

@@ -1,54 +0,0 @@
-package ru.m.tankz.view.network;
-
-import haxework.view.frame.FrameSwitcher;
-import haxework.view.list.VListView;
-import haxework.view.VGroupView;
-import ru.m.tankz.network.NetworkManager;
-import ru.m.tankz.proto.core.GameProto;
-
-@:template class GameListFrame extends VGroupView {
-    public static inline var ID = "game_list";
-
-    @:view var games:VListView<GameProto>;
-
-    @:provide var switcher:FrameSwitcher;
-    @:provide var network:NetworkManager;
-
-    public function onShow():Void {
-        network.listGameSignal.connect(onGameList);
-        network.gameSignal.connect(onGame);
-        network.stateSignal.connect(onState);
-        network.listGame();
-    }
-
-    public function onHide():Void {
-        network.listGameSignal.disconnect(onGameList);
-        network.gameSignal.disconnect(onGame);
-        network.stateSignal.disconnect(onState);
-    }
-
-    private function create():Void {
-        network.createGame("classic", 0);
-    }
-
-    private function onState(state:ConnectionState):Void {
-        switch state {
-            case ONLINE(_):
-            case _: switcher.change(StartFrame.ID);
-        }
-    }
-
-    private function onGameList(data:Array<GameProto>):Void {
-        games.data = data;
-    }
-
-    private function onGame(game:GameProto):Void {
-        if (game != null) {
-            switcher.change(GameRoomFrame.ID);
-        }
-    }
-
-    private function selectGame(game:GameProto):Void {
-        network.joinGame(game.id);
-    }
-}

src/client/haxe/ru/m/tankz/view/network/GameRoomFrame.hx

@@ -1,53 +0,0 @@
-package ru.m.tankz.view.network;
-
-import haxework.view.frame.FrameSwitcher;
-import haxework.view.list.VListView;
-import haxework.view.TextView;
-import haxework.view.VGroupView;
-import ru.m.tankz.network.NetworkManager;
-import ru.m.tankz.proto.core.GameProto;
-import ru.m.tankz.proto.core.UserProto;
-
-@:template class GameRoomFrame extends VGroupView {
-
-    public static inline var ID = "game_room";
-
-    @:view var info:TextView;
-    @:view var players:VListView<UserProto>;
-
-    @:provide var switcher:FrameSwitcher;
-    @:provide var network:NetworkManager;
-
-    private function refresh(game:GameProto):Void {
-        if (game != null) {
-            info.text = '[${game.creator.name}] ${game.type} ${game.level} (${game.players.length})';
-            players.data = game.players;
-        } else {
-            Timer.delay(function() switcher.change(GameListFrame.ID), 1);
-        }
-    }
-
-    public function onShow():Void {
-        refresh(network.game);
-        network.gameSignal.connect(onGame);
-        network.stateSignal.connect(onState);
-    }
-
-    public function onHide():Void {
-        network.gameSignal.disconnect(onGame);
-        network.stateSignal.disconnect(onState);
-        network.leaveGame();
-    }
-
-    private function onGame(game:GameProto):Void {
-        refresh(game);
-    }
-
-    private function onState(state:ConnectionState):Void {
-        switch state {
-            case ONLINE(_):
-            case _: switcher.change(StartFrame.ID);
-        }
-    }
-
-}

src/client/haxe/ru/m/tankz/view/network/GameRoomFrame.yaml

@@ -1,25 +0,0 @@
----
-views:
-    - $type: haxework.view.VGroupView
-      skinId: container
-      geometry.padding: 20
-      views:
-          - id: header
-            $type: haxework.view.LabelView
-            geometry.margin.bottom: 20
-            skinId: text.header
-            text: Game Room
-          - id: info
-            $type: haxework.view.LabelView
-            geometry.size.width: 100%
-            skinId: text.box
-          - id: players
-            $type: haxework.view.list.VListView
-            geometry.size.stretch: true
-            factory: $code:ru.m.tankz.view.network.PlayerItemView.factory
-    - $type: haxework.view.HGroupView
-      skinId: panel
-      views:
-          - $type: haxework.view.ButtonView
-            skinId: button.close
-            +onPress: $code:network.leaveGame()

src/client/haxe/ru/m/tankz/view/network/PlayerItemView.hx

@@ -1,24 +0,0 @@
-package ru.m.tankz.view.network;
-
-import haxework.view.HGroupView;
-import haxework.view.LabelView;
-import haxework.view.list.ListView;
-import ru.m.tankz.proto.core.UserProto;
-
-@:template class PlayerItemView extends HGroupView implements IListItemView<UserProto> {
-
-    public var item_index(default, default):Int;
-    public var data(default, set):UserProto;
-
-    @:view var label:LabelView;
-
-    private function set_data(value:UserProto):UserProto {
-        data = value;
-        label.text = '${value.name}';
-        return data;
-    }
-
-    public static function factory():PlayerItemView {
-        return new PlayerItemView();
-    }
-}

src/client/haxe/ru/m/tankz/view/network/PlayerItemView.yaml

@@ -1,8 +0,0 @@
----
-geometry.size.width: 100%
-geometry.size.height: 48
-views:
-    - id: label
-      $type: haxework.view.LabelView
-      geometry.size.stretch: true
-      skinId: text.box

src/client/haxe/ru/m/tankz/view/network/RoomFrame.hx

@@ -0,0 +1,50 @@
+package ru.m.tankz.view.network;
+
+import haxework.view.ButtonView;
+import haxework.view.frame.FrameSwitcher;
+import haxework.view.list.VListView;
+import haxework.view.TextView;
+import haxework.view.VGroupView;
+import ru.m.tankz.game.IGame;
+import ru.m.tankz.network.NetworkGame;
+import ru.m.tankz.network.NetworkManager;
+import ru.m.tankz.proto.room.RoomProto;
+import ru.m.tankz.proto.room.RoomSlotProto;
+
+@:template class RoomFrame extends VGroupView {
+
+    public static inline var ID = "room";
+
+    @:view var start:ButtonView;
+    @:view var info:TextView;
+    @:view var slots:VListView<RoomSlotProto>;
+
+    @:provide var switcher:FrameSwitcher;
+    @:provide var network:NetworkManager;
+    @:provide var game:IGame;
+
+    private function refresh(room:RoomProto):Void {
+        if (room != null) {
+            start.visible = room.creator.uuid == network.user.uuid;
+            info.text = '${room.game.type} #${room.game.level}';
+            slots.data = room.slots;
+            if (room.game.started) {
+                if (this.game == null) {
+                    this.game = new NetworkGame(network);
+                }
+                switcher.change(GameFrame.ID);
+            }
+        } else {
+            Timer.delay(function() switcher.change(RoomListFrame.ID), 1);
+        }
+    }
+
+    public function onShow():Void {
+        refresh(network.room);
+        network.roomSignal.connect(refresh);
+    }
+
+    public function onHide():Void {
+        network.roomSignal.disconnect(refresh);
+    }
+}

src/client/haxe/ru/m/tankz/view/network/RoomFrame.yaml

@@ -0,0 +1,38 @@
+---
+views:
+  - $type: haxework.view.VGroupView
+    skinId: container
+    geometry.padding: 20
+    layout.margin: 10
+    views:
+      - id: header
+        $type: haxework.view.LabelView
+        geometry.margin.bottom: 20
+        skinId: text.header
+        text: Game Room
+      - $type: haxework.view.HGroupView
+        layout.margin: 10
+        views:
+          - id: info
+            $type: haxework.view.LabelView
+            geometry.padding: [30, 10]
+            skinId: text.box
+          - id: start
+            $type: haxework.view.ButtonView
+            skinId: button.simple
+            text: Start
+            +onPress: $code:network.startGame()
+            visible: false
+          - id: leave
+            $type: haxework.view.ButtonView
+            skinId: button.simple
+            text: Leave
+            +onPress: $code:network.leaveGame()
+      - $type: haxework.view.SpriteView
+        geometry.size.width: 100%
+        geometry.size.height: 3
+        skinId: line
+      - id: slots
+        $type: haxework.view.list.VListView
+        geometry.size.stretch: true
+        factory: $code:ru.m.tankz.view.network.SlotItemView.factory

src/client/haxe/ru/m/tankz/view/network/RoomItemView.hx

@@ -0,0 +1,40 @@
+package ru.m.tankz.view.network;
+
+import ru.m.tankz.network.NetworkManager;
+import ru.m.tankz.proto.room.RoomSlotProto;
+import haxework.view.ButtonView;
+import haxework.view.HGroupView;
+import haxework.view.LabelView;
+import haxework.view.list.ListView;
+import ru.m.tankz.proto.room.RoomProto;
+
+@:template class RoomItemView extends HGroupView implements IListItemView<RoomProto> {
+
+    public var item_index(default, default):Int;
+    public var data(default, set):RoomProto;
+
+    @:view("creator") var creatorView:LabelView;
+    @:view("type") var typeView:LabelView;
+    @:view("users") var usersView:LabelView;
+    @:view("join") var joinButton:ButtonView;
+
+    @:provide static var network:NetworkManager;
+
+    private function set_data(value:RoomProto):RoomProto {
+        data = value;
+        creatorView.skinId = value.creator.uuid == network.user.uuid ? "text.box.active" : "text.box";
+        creatorView.text = value.creator.name;
+        typeView.text = '${value.game.type} #${value.game.level}';
+        var used = value.slots.filter(function(slot:RoomSlotProto) return slot.hasUser()).length;
+        usersView.text = value.game.started ? 'started' : '${used}/${value.slots.length}';
+        return data;
+    }
+
+    private function join():Void {
+        network.joinGame(data.game.id, true);
+    }
+
+    public static function factory():RoomItemView {
+        return new RoomItemView();
+    }
+}

src/client/haxe/ru/m/tankz/view/network/RoomItemView.yaml

@@ -0,0 +1,27 @@
+---
+# geometry.size.width: 100%
+geometry.size.height: 48
+layout.margin: 10
+layout.hAlign: center
+views:
+  - id: creator
+    $type: haxework.view.LabelView
+    geometry.size.height: 100%
+    geometry.size.width: 200
+    skinId: text.box
+  - id: type
+    $type: haxework.view.LabelView
+    geometry.size.height: 100%
+    geometry.size.width: 200
+    skinId: text.box
+  - id: users
+    $type: haxework.view.LabelView
+    geometry.size.height: 100%
+    geometry.size.width: 150
+    skinId: text.box
+  - id: join
+    $type: haxework.view.ButtonView
+    geometry.size.height: 100%
+    skinId: button.simple
+    text: Join
+    +onPress: $code:join()

src/client/haxe/ru/m/tankz/view/network/RoomListFrame.hx

@@ -0,0 +1,47 @@
+package ru.m.tankz.view.network;
+
+import haxework.view.frame.FrameSwitcher;
+import haxework.view.list.VListView;
+import haxework.view.VGroupView;
+import ru.m.tankz.network.NetworkManager;
+import ru.m.tankz.proto.room.RoomProto;
+import ru.m.tankz.view.popup.CreateGamePopup;
+
+@:template class RoomListFrame extends VGroupView {
+    public static inline var ID = "room_list";
+
+    @:view var games:VListView<RoomProto>;
+
+    @:provide var switcher:FrameSwitcher;
+    @:provide var network:NetworkManager;
+
+    public function onShow():Void {
+        network.listRoomSignal.connect(onRoomList);
+        network.roomSignal.connect(onRoom);
+        network.listGame(true);
+    }
+
+    public function onHide():Void {
+        network.listRoomSignal.disconnect(onRoomList);
+        network.roomSignal.disconnect(onRoom);
+        network.listGame(false);
+    }
+
+    private function create():Void {
+        CreateGamePopup.instance.show().then(function(result) {
+            if (result != null) {
+                network.createGame(result.type, result.level.id);
+            }
+        });
+    }
+
+    private function onRoomList(data:Array<RoomProto>):Void {
+        games.data = data;
+    }
+
+    private function onRoom(room:RoomProto):Void {
+        if (room != null) {
+            switcher.change(RoomFrame.ID);
+        }
+    }
+}

src/client/haxe/ru/m/tankz/view/network/RoomListFrame.yaml

@@ -16,12 +16,5 @@ views:
           - id: games
             $type: haxework.view.list.VListView
             geometry.size.stretch: true
-            factory: $code:ru.m.tankz.view.network.GameItemView.factory
+            factory: $code:ru.m.tankz.view.network.RoomItemView.factory
             geometry.margin: 10
-            +onItemSelect: $code:function(item) selectGame(item.data)
-    - $type: haxework.view.HGroupView
-      skinId: panel
-      views:
-          - $type: haxework.view.ButtonView
-            skinId: button.close
-            +onPress: $code:switcher.change('start')

src/client/haxe/ru/m/tankz/view/network/SlotItemView.hx

@@ -0,0 +1,45 @@
+package ru.m.tankz.view.network;
+
+import haxework.view.ButtonView;
+import haxework.view.HGroupView;
+import haxework.view.LabelView;
+import haxework.view.list.ListView;
+import ru.m.tankz.bundle.IConfigBundle;
+import ru.m.tankz.network.NetworkManager;
+import ru.m.tankz.proto.room.RoomSlotProto;
+
+@:template class SlotItemView extends HGroupView implements IListItemView<RoomSlotProto> {
+
+    public var item_index(default, default):Int;
+    public var data(default, set):RoomSlotProto;
+
+    @:view("type") var typeView:LabelView;
+    @:view("user") var userView:LabelView;
+    @:view("select") var selectButton:ButtonView;
+
+    @:provide static var network:NetworkManager;
+    @:provide static var configBundle:IConfigBundle;
+
+    private function set_data(value:RoomSlotProto):RoomSlotProto {
+        data = value;
+        typeView.text = '${value.slot.team} #${value.slot.index}';
+        userView.text = value.hasUser() ? value.user.name : "(NONE)";
+        userView.visible = value.hasUser();
+        selectButton.visible = !value.hasUser();
+        userView.skinId = (value.hasUser() && value.user.uuid == network.user.uuid) ? "text.box.active" : "text.box";
+        var config = configBundle.get(network.room.game.type);
+        var color = config.getColor([value.slot.team, value.slot.index]);
+        if (color != null) {
+            typeView.skin = Style.textBox(color);
+        }
+        return data;
+    }
+
+    private function select():Void {
+        network.selectSlot(data.slot);
+    }
+
+    public static function factory():SlotItemView {
+        return new SlotItemView();
+    }
+}

src/client/haxe/ru/m/tankz/view/network/SlotItemView.yaml

@@ -0,0 +1,25 @@
+---
+geometry.size.height: 48
+geometry.padding: 2
+layout.margin: 10
+views:
+  - id: type
+    $type: haxework.view.LabelView
+    skinId: text.box
+    geometry.size.height: 100%
+    geometry.size.width: 150
+  - $type: haxework.view.HGroupView
+    layout.hAlign: center
+    layout.vAlign: middle
+    geometry.size.height: 100%
+    geometry.size.width: 300
+    views:
+    - id: user
+      $type: haxework.view.LabelView
+      geometry.size.stretch: true
+      skinId: text.box
+    - id: select
+      $type: haxework.view.ButtonView
+      skinId: button.simple
+      text: Select
+      +onPress: $this:select()

src/client/haxe/ru/m/tankz/view/popup/CreateGamePopup.hx

@@ -0,0 +1,75 @@
+package ru.m.tankz.view.popup;
+
+import haxework.view.DataView;
+import haxework.view.popup.PopupView;
+import haxework.view.ToggleButtonView;
+import ru.m.tankz.bundle.IConfigBundle;
+import ru.m.tankz.bundle.ILevelBundle;
+import ru.m.tankz.config.Config;
+import ru.m.tankz.Type;
+
+private typedef Result = {
+    var type:GameType;
+    var level:LevelConfig;
+}
+
+@:template class CreateGamePopup extends PopupView<Result> {
+
+    @:view("type") var typeView:DataView<GameType, ToggleButtonView>;
+    @:view("level") var levelView:DataView<LevelConfig, ToggleButtonView>;
+
+    @:provide static var configBundle:IConfigBundle;
+    @:provide static var levelBundle:ILevelBundle;
+
+    private var type:GameType;
+    private var level:LevelConfig;
+
+    override private function onShow():Void {
+        super.onShow();
+        onGameTypeSelect(0, "classic", typeView.dataViews[0]);
+    }
+
+    private function submit():Void {
+        close({type:type, level:level});
+    }
+
+    private function gameTypeViewFactory(index:Int, type:GameType):ToggleButtonView {
+        var result = new ToggleButtonView();
+        result.skinId = "button.simple";
+        result.text = type;
+        result.on = type == this.type;
+        return result;
+    }
+
+    private function onGameTypeSelect(index:Int, value:GameType, view:ToggleButtonView):Void {
+        this.type = value;
+        for (v in typeView.dataViews) {
+            v.on = v == view;
+        }
+        levelView.data = levelBundle.get(new PackId(value)).data;
+        onLevelSelect(0, levelView.data[0], levelView.dataViews[0]);
+    }
+
+    private function levelViewFactory(index:Int, value:LevelConfig):ToggleButtonView {
+        var result = new ToggleButtonView();
+        result.skinId = "button.level";
+        result.text = Std.string(value.id);
+        return result;
+    }
+
+    private function onLevelSelect(index:Int, level:LevelConfig, view:ToggleButtonView):Void {
+        this.level = level;
+        for (v in levelView.dataViews) {
+            v.on = v == view;
+        }
+    }
+
+    public static var instance(get, null):CreateGamePopup;
+
+    private static function get_instance():CreateGamePopup {
+        if (instance == null) {
+            instance = new CreateGamePopup();
+        }
+        return instance;
+    }
+}

src/client/haxe/ru/m/tankz/view/popup/CreateGamePopup.yaml

@@ -0,0 +1,76 @@
+---
+layout.hAlign: center
+layout.vAlign: middle
+view:
+  $type: haxework.view.VGroupView
+  layout.hAlign: center
+  geometry.size.stretch: true
+  geometry.margin: 10
+  skinId: window
+  views:
+    - $type: haxework.view.HGroupView
+      geometry.size.width: 100%
+      geometry.padding: 10
+      layout.vAlign: middle
+      views:
+        - id: name
+          $type: haxework.view.LabelView
+          geometry.size.width: 100%
+          geometry.margin.left: 10
+          layout.hAlign: left
+          skinId: text
+          text: New game
+        - $type: haxework.view.ButtonView
+          skinId: window.close
+          +onPress: $code:reject('close')
+    - $type: haxework.view.VGroupView
+      geometry.size.stretch: true
+      geometry.padding: [5, 20]
+      layout.margin: 5
+      layout.hAlign: center
+      views:
+          - $type: haxework.view.LabelView
+            geometry.size.width: 100%
+            skinId: text
+            text: Type
+          - id: type
+            $type: haxework.view.DataView
+            geometry.size.width: 100%
+            layout:
+              $type: haxework.view.layout.TailLayout
+              margin: 10
+            factory: $this:gameTypeViewFactory
+            +onItemSelect: $this:onGameTypeSelect
+            data:
+              - "classic"
+              - "dota"
+              - "death"
+          - $type: haxework.view.LabelView
+            geometry.size.width: 100%
+            skinId: text
+            text: Level
+          - $type: haxework.view.ScrollView
+            geometry.size.stretch: true
+            scroll:
+                $type: haxework.view.list.VScrollBarView
+                skinId: scroll.vertical
+            view:
+                id: level
+                $type: haxework.view.DataView
+                geometry.size.width: 100%
+                layout:
+                  $type: haxework.view.layout.TailLayout
+                  rowSize: 10
+                  margin: 5
+                factory: $this:levelViewFactory
+                +onItemSelect: $this:onLevelSelect
+                geometry.padding: 10
+    - $type: haxework.view.HGroupView
+      layout.hAlign: center
+      layout.margin: 5
+      skinId: panel
+      views:
+        - $type: haxework.view.ButtonView
+          skinId: button.simple
+          text: Create
+          +onPress: $code:submit()

src/client/haxe/ru/m/tankz/view/popup/LevelPopup.hx

@@ -4,22 +4,32 @@ import haxework.view.ButtonView;
 import haxework.view.DataView;
 import haxework.view.LabelView;
 import haxework.view.popup.PopupView;
+import haxework.view.ToggleButtonView;
 import ru.m.tankz.config.Config;
-import ru.m.tankz.game.GameProgress;
+import ru.m.tankz.game.PackProgress;
 
-@:template class LevelPopup extends PopupView<GamePreset> {
+private typedef Result = {
+    var control:ControlPreset;
+    var preset:GamePreset;
+}
+
+@:template class LevelPopup extends PopupView<Result> {
 
     private var level:LevelConfig;
-    private var progress:GameProgress;
+    private var progress:PackProgress;
 
     @:view var name:LabelView;
     @:view("presets") var presetsView:DataView<GamePreset, ButtonView>;
+    @:view("controls") var controlsView:DataView<ControlPreset, ToggleButtonView>;
+    private var control:ControlPreset;
 
-    public function setData(level:LevelConfig, presets:Array<GamePreset>, progress:GameProgress):Void {
+    public function setData(level:LevelConfig, presets:Array<GamePreset>, controls:Array<ControlPreset>, progress:PackProgress):Void {
         this.level = level;
         this.progress = progress;
         name.text = '${level.id}. ${level.name != null ? level.name : "#"}';
         presetsView.data = presets;
+        control = controls[0];
+        controlsView.data = controls;
     }
 
     private function presetViewFactory(index:Int, value:GamePreset):ButtonView {
@@ -32,7 +42,22 @@ import ru.m.tankz.game.GameProgress;
 
     private function onPresetSelect(value:GamePreset):Void {
         if (progress.isPresetAvailable(level.id, value.id)) {
-            close(value);
+            close({control: control, preset: value});
+        }
+    }
+
+    private function controlViewFactory(index:Int, value:ControlPreset):ToggleButtonView {
+        var result = new ToggleButtonView();
+        result.skinId = 'button.simple.active';
+        result.on = control == value;
+        result.text = value.name;
+        return result;
+    }
+
+    private function onControlSelect(index:Int, value:ControlPreset, view:ToggleButtonView):Void {
+        control = value;
+        for (v in controlsView.dataViews) {
+            v.on = v == view;
         }
     }
 }

src/client/haxe/ru/m/tankz/view/popup/LevelPopup.yaml

@@ -24,6 +24,15 @@ view:
                 +onPress: $code:reject('close')
         - $type: haxework.view.SpriteView
           geometry.size.height: 100%
+        - id: controls
+          $type: haxework.view.DataView
+          factory: $this:controlViewFactory
+          +onItemSelect: $this:onControlSelect
+          layout:
+              $type: haxework.view.layout.HorizontalLayout
+              hAlign: center
+              margin: 5
+          skinId: panel
         - id: presets
           $type: haxework.view.DataView
           factory: $this:presetViewFactory

src/client/haxe/ru/m/tankz/view/popup/LoginPopup.yaml

@@ -42,12 +42,14 @@ view:
                 geometry.size.width: 100%
                 skinId: text
                 text: Password
+                visible: false
               - id: password
                 $type: haxework.view.InputView
                 textField.displayAsPassword: true
                 geometry.size.width: 100%
                 geometry.size.height: 28
                 skinId: text.box
+                visible: false
               - id: error
                 $type: haxework.view.TextView
                 geometry.size.width: 100%

src/client/haxe/ru/m/tankz/view/settings/ActionView.hx

@@ -2,14 +2,17 @@ package ru.m.tankz.view.settings;
 
 import haxework.view.HGroupView;
 import haxework.view.LabelView;
-import haxework.view.list.ListView.IListItemView;
+import haxework.view.list.ListView;
 import openfl.Assets;
-import openfl.events.KeyboardEvent;
-import promhx.Deferred;
-import promhx.Promise;
-import ru.m.tankz.control.ActionConfig;
+import ru.m.control.DeviceAction;
+import ru.m.tankz.control.Binding;
 import ru.m.tankz.control.Control;
 
+typedef ActionItem = {
+    var action:TankAction;
+    var bind:BindAction;
+}
+
 class KeyboardMap {
 
     private var data:Map<Int, String>;
@@ -26,9 +29,9 @@ class KeyboardMap {
 
     }
 
-    private static var instance: KeyboardMap;
+    private static var instance:KeyboardMap;
 
-    public static function getName(key: Int): String {
+    public static function getName(key:Int):String {
         if (instance == null) instance = new KeyboardMap();
         return key == -1 ? "(NONE)" : instance.data.exists(key) ? instance.data.get(key) : Std.string(key);
     }
@@ -39,12 +42,12 @@ class KeyboardMap {
     public var item_index(default, default):Int;
     public var data(default, set):ActionItem;
 
+    public var edit(default, set):Bool;
+
     @:view var action(default, null):LabelView;
     @:view var key(default, null):LabelView;
 
-    private var editDeferred: Deferred<Int>;
-
-    private static function actionLabel(action: TankAction): String {
+    private static function actionLabel(action:TankAction):String {
         return switch (action) {
             case TankAction.SHOT: "SHOT";
             case TankAction.MOVE(d): 'MOVE_$d';
@@ -52,32 +55,25 @@ class KeyboardMap {
         }
     }
 
-    private static function keyLabel(key: Int): String {
-        return KeyboardMap.getName(key);
+    private static function bindLabel(bind:BindAction):String {
+        return bind == null ? "(NONE)" : Std.string(bind.device) + " " + switch bind.action {
+            case KEY(code): KeyboardMap.getName(code);
+            case DIRECTION(direction): Std.string(direction);
+        };
     }
 
     private function set_data(value:ActionItem):ActionItem {
         data = value;
         action.text = actionLabel(data.action);
-        key.text = keyLabel(data.key);
+        key.text = bindLabel(data.bind);
         return data;
     }
 
-    public function edit():Promise<Int> {
-        action.skinId = key.skinId = "text.box.active";
-        toRedraw();
-        editDeferred = new Deferred();
-        content.stage.addEventListener(KeyboardEvent.KEY_DOWN, onKeyDown);
-        return editDeferred.promise();
-    }
-
-    private function onKeyDown(event: KeyboardEvent):Void {
-        content.stage.removeEventListener(KeyboardEvent.KEY_DOWN, onKeyDown);
-        action.skinId = key.skinId = "text.box";
-        toRedraw();
-        data.key = event.keyCode;
-        key.text = keyLabel(data.key);
-        editDeferred.resolve(data.key);
-        editDeferred = null;
+    private function set_edit(value:Bool):Bool {
+        if (edit != value) {
+            edit = value;
+            action.skinId = key.skinId = edit ? "text.box.active" : "text.box";
+        }
+        return edit;
     }
 }

src/client/haxe/ru/m/tankz/view/settings/ActionView.yaml

@@ -4,9 +4,9 @@ layout.margin: 5
 views:
   - id: action
     $type: haxework.view.LabelView
-    geometry.size.fixed: [200, 38]
+    geometry.size.fixed: [180, 38]
     skinId: text.box
   - id: key
     $type: haxework.view.LabelView
-    geometry.size.fixed: [200, 38]
+    geometry.size.fixed: [250, 38]
     skinId: text.box

src/client/haxe/ru/m/tankz/view/settings/SettingsEditor.hx

@@ -1,11 +1,66 @@
 package ru.m.tankz.view.settings;
 
 import haxework.view.DataView;
+import haxework.view.GroupView;
 import haxework.view.LabelView;
 import haxework.view.VGroupView;
+import promhx.Deferred;
 import promhx.Promise;
-import ru.m.tankz.control.ActionConfig;
+import ru.m.control.DeviceAction;
+import ru.m.control.DeviceType;
+import ru.m.control.IControlBus;
+import ru.m.tankz.control.Binding;
 import ru.m.tankz.storage.SettingsStorage;
+import ru.m.tankz.view.settings.ActionView;
+
+class BindEditor {
+
+    private var editViews:Array<ActionView>;
+
+    @:provide static var bus:IControlBus;
+
+    private var def:Deferred<Bool>;
+
+    public function new() {
+        editViews = [];
+        bus.signal.connect(onBusAction);
+    }
+
+    private function onBusAction(device:DeviceType, action:DeviceAction, on:Bool):Void {
+        if (on && editViews.length > 0) {
+            var view = editViews.shift();
+            view.edit = false;
+            view.data.bind = {device: device, action: action};
+            view.data = view.data;
+            if (editViews.length > 0) {
+                editViews[0].edit = true;
+            } else {
+                def.resolve(true);
+            }
+        }
+    }
+
+    public function push(views:Array<ActionView>):Promise<Bool> {
+        for (view in editViews) {
+            view.edit = false;
+        }
+        editViews = views.slice(0);
+        if (editViews.length > 0) {
+            editViews[0].edit = true;
+        }
+        def = new Deferred();
+        return def.promise();
+    }
+
+    public static var i(get, null):BindEditor;
+
+    private static function get_i():BindEditor {
+        if (i == null) {
+            i = new BindEditor();
+        }
+        return i;
+    }
+}
 
 @:template class SettingsEditor extends VGroupView {
 
@@ -13,13 +68,20 @@ import ru.m.tankz.storage.SettingsStorage;
 
     @:view var label:LabelView;
     @:view var list:DataView<ActionItem, ActionView>;
+    @:view var panel:GroupView;
 
-    @:provide var storage:SettingsStorage;
+    @:provide static var storage:SettingsStorage;
+    @:provide static var bus:IControlBus;
+
+    private function refresh():Void {
+        label.text = 'Player ${controlIndex+1}';
+        var binding = storage.getBinding(controlIndex);
+        list.data = bindingToArray(binding);
+    }
 
     private function set_controlIndex(value: Int): Int {
         this.controlIndex = value;
-        label.text = 'Player ${controlIndex+1}';
-        list.data = storage.getActionConfig(controlIndex).data;
+        refresh();
         return this.controlIndex;
     }
 
@@ -31,34 +93,48 @@ import ru.m.tankz.storage.SettingsStorage;
     }
 
     private function onItemSelect(index:Int, value:ActionItem, view:ActionView):Void {
-        view.edit();
+        BindEditor.i.push([view]).then(function(_) save());
     }
 
-    private function change():Void {
-        var p: Promise<Int> = Promise.promise(0);
-        for (view in list.views) {
-            var v: ActionView = cast view;
-            p = p.pipe(function(_):Promise<Int> return v.edit());
-        }
-        p.then(function(_) save());
-    }
-
-    private function clear():Void {
-        for (item in list.data) {
-            item.key = -1;
-        }
-        list.data = list.data;
+    private function screen():Void {
+        list.data = bindingToArray(SettingsStorage.buildGamepadBinding(GamepadView.ID));
         list.toUpdate();
         save();
     }
 
-    private function reset():Void {
-        list.data = SettingsStorage.getDefaultActionConfig(controlIndex).data;
+    private function change():Void {
+        BindEditor.i.push(list.dataViews).then(function(_) save());
+    }
+
+    private function clear():Void {
+        list.data = bindingToArray(SettingsStorage.getDefaultBinding(-1));
+        list.toUpdate();
+        save();
+    }
+
+    private function default_():Void {
+        list.data = bindingToArray(SettingsStorage.getDefaultBinding(controlIndex));
         list.toUpdate();
         save();
     }
 
     private function save():Void {
-        storage.setActionConffig(controlIndex, new ActionConfig(list.data));
+        storage.saveBinding(controlIndex, arrayToBinding(list.data));
+    }
+
+    private static function bindingToArray(binding:Binding):Array<ActionItem> {
+        var result:Array<ActionItem> = [];
+        for (action in binding.keys()) {
+            result.push({action: action, bind: binding.get(action)});
+        }
+        return result;
+    }
+
+    private static function arrayToBinding(array:Array<ActionItem>):Binding {
+        var result = new Binding();
+        for (item in array) {
+            result.set(item.action, item.bind);
+        }
+        return result;
     }
 }

src/client/haxe/ru/m/tankz/view/settings/SettingsEditor.yaml

@@ -1,27 +1,34 @@
 layout.margin: 10
 layout.hAlign: center
+geometry.size.width: 400
 views:
   - id: label
     $type: haxework.view.LabelView
     skinId: text
-  - $type: haxework.view.HGroupView
-    layout.margin: 10
+  - id: panel
+    $type: haxework.view.GroupView
+    layout:
+        $type: haxework.view.layout.TailLayout
+        rowSize: 2
+        margin: 10
+    geometry.size.width: 100%
     views:
-      - id: change
-        $type: haxework.view.ButtonView
+      - $type: haxework.view.ButtonView
+        +onPress: $code:screen()
+        skinId: button.simple
+        text: Screen
+      - $type: haxework.view.ButtonView
         +onPress: $code:change()
         skinId: button.simple
         text: Change
-      - id: clear
-        $type: haxework.view.ButtonView
+      - $type: haxework.view.ButtonView
         +onPress: $code:clear()
         skinId: button.simple
         text: Clear
-      - id: reset
-        $type: haxework.view.ButtonView
-        +onPress: $code:reset()
+      - $type: haxework.view.ButtonView
+        +onPress: $code:default_()
         skinId: button.simple
-        text: Reset
+        text: Default
   - id: list
     $type: haxework.view.DataView
     layout:

src/common/haxe/ru/m/Timer.hx

@@ -20,7 +20,7 @@ class Timer {
                 try {
                     run();
                 } catch (error:Dynamic) {
-                    trace(error);
+                    trace(haxework.log.BaseLogger.LoggerUtil.printError(error));
                 }
             }
         });

src/common/haxe/ru/m/connect/PacketQueue.hx

@@ -1,21 +1,22 @@
 package ru.m.connect;
 
+import Reflect;
 import haxe.io.Bytes;
 import haxe.io.BytesBuffer;
 import haxe.io.BytesInput;
 import protohx.Message;
 
-
 class PacketQueue<P:Message> {
 
     public var packetClass(default, null):Class<P>;
 
-    private var bytesBuff:Bytes;
+    private var buffer:BytesBuffer;
     private var msgs:List<P>;
 
     public function new(packetClass:Class<P>) {
         this.packetClass = packetClass;
         msgs = new List<P>();
+        buffer = new BytesBuffer();
     }
 
     public inline function hasMsg():Bool {
@@ -30,47 +31,41 @@ class PacketQueue<P:Message> {
         msgs.add(msg);
     }
 
-    public function addBytes(bytes:Bytes):Void {
-        if (bytes == null) {
-            return;
-        }
-        if (bytesBuff == null) {
-            bytesBuff = bytes;
-        } else {
-            var buffer = new BytesBuffer();
-            buffer.add(bytesBuff);
-            buffer.add(bytes);
-            bytesBuff = buffer.getBytes();
-        }
-        if (bytesBuff == null || bytesBuff.length < 1) {
-            return;
-        }
-        var available = bytesBuff.length;
-        var bi = new BytesInput(bytesBuff);
-        bi.bigEndian = false;
-        while (available > 0) {
-            var packetSize = bi.readUInt16();
-            available -= 2;
-            if (packetSize <= available) {
-                var msgBytes = bi.read(packetSize);
+    private function readPackage():Null<P> {
+        var bytes = buffer.getBytes();
+        var input = new BytesInput(bytes);
+        input.bigEndian = false;
+        if (input.length > 1) {
+            var packetSize = input.readUInt16();
+            if (input.length >= packetSize + 2) {
                 var packet:P = Type.createInstance(packetClass, []);
-                packet.mergeFrom(msgBytes);
-                addMsg(packet);
-                available -= packetSize;
-            } else {
-                break;
+                try {
+                    packet.mergeFrom(input.read(packetSize));
+                    buffer = new BytesBuffer();
+                    buffer.add(input.read(input.length - (packetSize + 2)));
+                    return packet;
+                } catch (error:Dynamic) {
+                    L.w("PacketQueue", "readPackage ", error);
+                    buffer = new BytesBuffer();
+                    return null;
+                }
             }
         }
-        if (available == 0) {
-            bytesBuff = null;
-        } else if (available > 0) {
-            if (bytesBuff.length != available) {
-                var pos = bytesBuff.length - available;
-                bytesBuff = bytesBuff.sub(pos, available);
-            }
-        } else {
-            throw "Wrong available: " + available;
+        buffer = new BytesBuffer();
+        buffer.add(bytes);
+        return null;
+    }
+
+    public function addBytes(bytes:Bytes):Void {
+        buffer.add(bytes);
+        var packet = readPackage();
+        while (packet != null) {
+            msgs.add(packet);
+            packet = readPackage();
         }
     }
 
-}
+    public function clean():Void {
+        buffer = new BytesBuffer();
+    }
+}

src/common/haxe/ru/m/connect/desktop/DesktopConnection.hx

@@ -38,8 +38,10 @@ class DesktopConnection<O:Message, I:Message> extends BaseConnection<O, I> {
                 connected = true;
                 reader = Thread.create(_read);
                 connectDeferred.resolve(this);
+                handler.emit(ConnectionEvent.CONNECTED);
             }
         } catch (error:Dynamic) {
+            handler.emit(ConnectionEvent.ERROR(error));
             Timer.delay(function() connectDeferred.throwError(error), 1);
         }
         return connectDeferred.promise();

src/common/haxe/ru/m/connect/flash/FlashConnection.hx

@@ -74,14 +74,10 @@ class FlashConnection<O:Message, I:Message> extends BaseConnection<O, I> {
     }
 
     private function onSocketData(_):Void {
-        try {
-            var data = new flash.utils.ByteArray();
-            socket.readBytes(data);
-            var bytes = Bytes.ofData(data);
-            pushData(bytes);
-        } catch (error:Dynamic) {
-            handler.emit(ConnectionEvent.ERROR(error));
-        }
+        var data = new flash.utils.ByteArray();
+        socket.readBytes(data);
+        var bytes = Bytes.ofData(data);
+        pushData(bytes);
     }
 
     private function _send(packet:O):Void {

src/common/haxe/ru/m/connect/js/JsConnection.hx

@@ -21,7 +21,7 @@ class JsConnection<O:Message, I:Message> extends BaseConnection<O, I> {
         this.port = port;
         connected = false;
     }
-    
+
     public static function isSecured():Bool {
         return Browser.location.protocol == "https:";
     }
@@ -49,7 +49,7 @@ class JsConnection<O:Message, I:Message> extends BaseConnection<O, I> {
     }
 
     private function onError(event:Dynamic):Void {
-        socket.close();
+        socket.close(1000);
         connected = false;
         handler.emit(ConnectionEvent.ERROR(event));
     }
@@ -67,18 +67,25 @@ class JsConnection<O:Message, I:Message> extends BaseConnection<O, I> {
     }
 
     private function onSocketData(event:Dynamic):Void {
+        var packet:I = null;
         try {
             var bytes = Bytes.ofData(event.data);
-            var packet:I = PacketUtil.fromBytes(bytes, queue.packetClass);
-            receive(packet);
+            packet = PacketUtil.fromBytes(bytes, queue.packetClass);
         } catch (error:Dynamic) {
-            handler.emit(ConnectionEvent.ERROR(event));
+            handler.emit(ConnectionEvent.ERROR(error));
+        }
+        if (packet != null) {
+            receive(packet);
         }
     }
 
     override public function send(packet:O):Void {
-        super.send(packet);
-        var bytes = PacketUtil.toBytes(packet);
-        socket.send(bytes.getData());
+        if (connected) {
+            super.send(packet);
+            var bytes = PacketUtil.toBytes(packet);
+            socket.send(bytes.getData());
+        } else {
+            L.w("Connection", "closed");
+        }
     }
 }

src/common/haxe/ru/m/connect/neko/NekoConnection.hx

@@ -7,16 +7,22 @@ class NekoConnection<O:Message, I:Message> extends BaseConnection<O, I> {
 
     public var socket(default, null):Socket;
 
+    private var sendQueue:Array<O>;
+    private var timer:Timer;
+
     public function new(socket:Socket, i:Class<I>) {
         super(i);
         this.socket = socket;
         socket.setFastSend(true);
         socket.output.bigEndian = false;
         socket.input.bigEndian = false;
-        sendHandler.connect(_send);
+        sendHandler.connect(pushPacket);
+        sendQueue = [];
+        timer = new Timer(1);
+        timer.run = sendRun;
     }
 
-    private function _send(packet:O):Void {
+    private function sendPacket(packet:O):Void {
         try {
             var bytes = PacketUtil.toBytes(packet);
             socket.output.writeUInt16(bytes.length);
@@ -26,4 +32,25 @@ class NekoConnection<O:Message, I:Message> extends BaseConnection<O, I> {
             L.e('Proto', 'Error send packet: ${packet}', error);
         }
     }
+
+    private function sendRun():Void {
+        if (sendQueue.length > 0) {
+            for (packet in sendQueue) {
+                sendPacket(packet);
+            }
+            sendQueue = [];
+        }
+    }
+
+    private function pushPacket(packet:O):Void {
+        sendQueue.push(packet);
+    }
+
+    override public function disconnect():Void {
+        if (timer != null) {
+            timer.stop();
+            timer = null;
+        }
+        super.disconnect();
+    }
 }

src/common/haxe/ru/m/connect/neko/NekoWSConnection.hx

@@ -16,7 +16,7 @@ class NekoWSConnection<O:Message, I:Message> extends NekoConnection<O, I> {
         opened = false;
     }
 
-    override private function _send(packet:O):Void {
+    override private function sendPacket(packet:O):Void {
         var data = PacketUtil.toBytes(packet);
         writeData(data, socket);
     }

src/common/haxe/ru/m/tankz/Type.hx

@@ -8,6 +8,8 @@ typedef TeamId = String;
 
 typedef BrickType = String;
 
+typedef BrickIndex = Int;
+
 typedef TankType = String;
 
 typedef BonusType = String;
@@ -37,5 +39,33 @@ abstract PlayerId(Array<Dynamic>) {
     }
 }
 
+abstract PackId(Array<Dynamic>) {
+    public static inline var DEFAULT = "standard";
+
+    public var type(get, never):GameType;
+    public var name(get, never):String;
+
+    public function new(type:GameType, name:String = DEFAULT) {
+        this = [type, name];
+    }
+
+    private inline function get_type():GameType return this[0];
+
+    private inline function get_name():String return this[1];
+
+    @:from static public inline function fromArray(value:Array<Dynamic>):PackId {
+        return new PackId(value[0], value[1]);
+    }
+
+    @:to public inline function toString():String {
+        return '${type}_${name}';
+    }
+
+    @:op(X == Y) static public inline function equals(x:PackId, y:PackId):Bool {
+        return x.type == y.type && x.name == y.name;
+    }
+}
+
 typedef LevelId = Int;
+
 typedef PresetId = Int;

src/common/haxe/ru/m/tankz/bot/BotControl.hx

@@ -1,6 +1,6 @@
 package ru.m.tankz.bot;
 
-import haxe.Timer;
+import ru.m.Timer;
 import ru.m.geom.Direction;
 import ru.m.tankz.control.Control;
 import ru.m.tankz.core.Tank;
@@ -12,7 +12,7 @@ class BotControl extends Control {
     private var tank(get, null):Tank;
 
     private inline function get_tank():Tank {
-        return handler == null ? null : handler.engine.getEntity(tankId);
+        return handler == null || tankId == -1 ? null : engine.getEntity(tankId);
     }
 
     override public function stop():Void {

src/common/haxe/ru/m/tankz/bot/BotHelper.hx

@@ -4,13 +4,13 @@ import ru.m.geom.Direction;
 import ru.m.tankz.core.Eagle;
 import ru.m.tankz.core.Entity;
 import ru.m.tankz.core.EntityType;
-import ru.m.tankz.game.IGame;
+import ru.m.tankz.engine.IEngine;
 import ru.m.tankz.Type;
 
 class BotHelper {
 
-    public static function findEagle(team:TeamId, handler:IGame):Null<Eagle> {
-        for (entity in handler.engine.entities) {
+    public static function findEagle(team:TeamId, engine:IEngine):Null<Eagle> {
+        for (entity in engine.entities) {
             switch (EntityTypeResolver.of(entity)) {
                 case EntityType.EAGLE(eagle):
                     if (eagle.team != team) {

src/common/haxe/ru/m/tankz/bot/HardBotControl.hx

@@ -1,6 +1,6 @@
 package ru.m.tankz.bot;
 
-import haxe.Timer;
+import ru.m.Timer;
 import ru.m.tankz.core.Eagle;
 import ru.m.tankz.core.EntityType;
 import ru.m.tankz.core.Tank;
@@ -56,7 +56,7 @@ class HardBotControl extends BotControl {
         }
         var enemy:Tank = null;
         var distance:Float = Math.POSITIVE_INFINITY;
-        for (entity in handler.engine.entities.iterator()) {
+        for (entity in engine.entities.iterator()) {
             switch EntityTypeResolver.of(entity) {
                 case TANK(t):
                     if (t.playerId.team != tank.playerId.team) {
@@ -82,7 +82,7 @@ class HardBotControl extends BotControl {
     }
 
     private function calcTurn():Void {
-        var eagle:Eagle = BotHelper.findEagle(playerId.team, handler);
+        var eagle:Eagle = BotHelper.findEagle(playerId.team, engine);
         if (eagle != null && Math.random() > 0.5) {
             turn(BotHelper.getDirectionTo(tank, eagle));
         } else {

src/common/haxe/ru/m/tankz/bot/StupidBotControl.hx

@@ -1,6 +1,6 @@
 package ru.m.tankz.bot;
 
-import haxe.Timer;
+import ru.m.Timer;
 import ru.m.tankz.control.Control;
 import ru.m.tankz.core.Eagle;
 import ru.m.tankz.core.EntityType;
@@ -45,7 +45,7 @@ class StupidBotControl extends BotControl {
 
     private function calcTurn():Void {
         if (handler == null || tank == null) return;
-        var eagle:Eagle = BotHelper.findEagle(playerId.team, handler);
+        var eagle:Eagle = BotHelper.findEagle(playerId.team, engine);
         if (eagle != null && Math.random() > 0.5) {
             turn(BotHelper.getDirectionTo(tank, eagle));
         } else {

src/common/haxe/ru/m/tankz/bundle/IConfigBundle.hx

@@ -3,17 +3,6 @@ package ru.m.tankz.bundle;
 import ru.m.tankz.config.Config;
 import ru.m.tankz.Type;
 
-
-typedef ConfigSource = {
-    var game:GameConfig;
-    var map: MapConfig;
-    var bricks: Array<BrickConfig>;
-    var presets: Array<GamePreset>;
-    var points: Array<SpawnPoint>;
-    var tanks: Array<TankConfig>;
-    var bonuses: Array<BonusConfig>;
-}
-
 interface IConfigBundle {
     public function get(type:GameType):Config;
 }

src/common/haxe/ru/m/tankz/bundle/ILevelBundle.hx

@@ -4,5 +4,5 @@ import ru.m.tankz.config.Config;
 import ru.m.tankz.Type;
 
 interface ILevelBundle {
-    public function get(type:GameType, config:Config, levelId:LevelId):LevelConfig;
+    public function get(id:PackId):LevelPack;
 }

src/common/haxe/ru/m/tankz/config/Config.hx

@@ -23,18 +23,26 @@ typedef SpawnPoint = {
     var direction:String;
 }
 
+typedef CellSize = {
+    var width:Float;
+    var height:Float;
+}
+
+typedef GridSize = {
+    var width:Int;
+    var height:Int;
+}
+
 typedef MapConfig = {
-    var cellWidth:Float;
-    var cellHeight:Float;
-    var gridWidth:Int;
-    var gridHeight:Int;
+    var cell:CellSize;
+    var grid:GridSize;
 }
 
 typedef BrickConfig = {
     var type:BrickType;
     var index:Int;
     var layer:Int;
-    var armor:Int;
+    var armor:Float;
 }
 
 typedef BulletConfig = {
@@ -51,17 +59,17 @@ typedef TankConfig = {
     var speed:Float;
     var bullet:BulletConfig;
     var bullets:Int;
-    var hits:Int;
     var skin:String;
+    @:optinal var hits:Int;
     @:optinal var upgrade:TankType;
     @:optinal var downgrade:TankType;
-    @:optinal var score:Int;
+    @:optinal var score:Null<Int>;
 }
 
 typedef BonusConfig = {
     var type:BonusType;
-    @:optional var duration:Int;
-    @:optinal var score:Int;
+    @:optional var duration:Null<Int>;
+    @:optinal var score:Null<Int>;
 }
 
 typedef TankSpawn = {
@@ -75,12 +83,12 @@ typedef PlayerConfig = {
     @:optional var bonus:Float;
     @:optional var protect:Float;
     @:optional var life:Int;
-    @:optional var color:Color;
+    @:optional var color:Null<Int>;
     @:optional var control:String;
 }
 
 typedef EagleConfig = {
-    @:optional var score:Int;
+    @:optional var score:Null<Int>;
 }
 
 typedef TeamConfig = {
@@ -89,7 +97,7 @@ typedef TeamConfig = {
     @:optional var eagle:EagleConfig;
     @:optional var life:Int;
     @:optional var spawnInterval:Int;
-    @:optional var color:Color;
+    @:optional var color:Null<Int>;
 }
 
 typedef GamePreset = {
@@ -100,9 +108,39 @@ typedef GamePreset = {
 
 typedef LevelConfig = {
     @:optional var id:LevelId;
-    var data:Array<BrickConfig>;
+    var data:Array<BrickIndex>;
     @:optional var name:String;
     @:optional var points:Array<SpawnPoint>;
+    @:optional var size:{width:Int, height:Int};
+}
+
+typedef LevelPack = {
+    var id:PackId;
+    var data:Array<LevelConfig>;
+}
+
+typedef PlayerControl = {
+    var playerId:PlayerId;
+    var control:String;
+    @:optional var color:Null<Int>;
+    @:optional var name:String;
+}
+
+typedef ControlPreset = {
+    var id:Int;
+    var name:String;
+    var values:Array<PlayerControl>;
+};
+
+typedef ConfigSource = {
+    var game:GameConfig;
+    var map: MapConfig;
+    var bricks: Array<BrickConfig>;
+    var presets: Array<GamePreset>;
+    var controls: Array<ControlPreset>;
+    var points: Array<SpawnPoint>;
+    var tanks: Array<TankConfig>;
+    var bonuses: Array<BonusConfig>;
 }
 
 class Config {
@@ -112,6 +150,7 @@ class Config {
     public var bricks(default, null):Array<BrickConfig>;
     public var tanks(default, null):Array<TankConfig>;
     public var presets(default, null):Array<GamePreset>;
+    public var controls(default, null):Array<ControlPreset>;
     public var points(default, null):Array<SpawnPoint>;
     public var bonuses(default, null):Array<BonusConfig>;
 
@@ -123,12 +162,17 @@ class Config {
     private var teamsMap:Map<TeamId, TeamConfig>;
     private var playersMap:Map<String, PlayerConfig>;
 
+    public static function fromSource(type:GameType, source:ConfigSource):Config {
+        return new Config(type, source.game, source.map, source.bricks, source.presets, source.controls, source.points, source.tanks, source.bonuses);
+    }
+
     public function new(
         type:String,
         game:GameConfig,
         map:MapConfig,
         bricks:Array<BrickConfig>,
         presets:Array<GamePreset>,
+        controls:Array<ControlPreset>,
         points:Array<SpawnPoint>,
         tanks:Array<TankConfig>,
         bonuses:Array<BonusConfig>
@@ -138,6 +182,7 @@ class Config {
         this.map = map;
         this.bricks = bricks;
         this.presets = presets;
+        this.controls = controls;
         this.points = points;
         this.tanks = tanks;
         this.bonuses = bonuses;
@@ -203,16 +248,16 @@ class Config {
         return playersMap.get(playerId);
     }
 
-    public function getColor(playerId:PlayerId):Color {
+    public function getColor(playerId:PlayerId):Null<Color> {
         var player = getPlayer(playerId);
-        if (player != null && !player.color.zero) {
+        if (player != null && player.color != null) {
             return player.color;
         }
         var team = getTeam(playerId.team);
         if (team != null) {
             return team.color;
         }
-        return -1;
+        return null;
     }
 
     public function getPoint(teamId:TeamId, type:String, index:Int = -1):SpawnPoint {

src/common/haxe/ru/m/tankz/control/BaseControlFactory.hx

@@ -0,0 +1,30 @@
+package ru.m.tankz.control;
+
+import ru.m.tankz.bot.HardBotControl;
+import ru.m.tankz.bot.StupidBotControl;
+import ru.m.tankz.Type;
+
+class BaseControlFactory implements IControlFactory {
+
+    public function new() {}
+
+    public function build(id:PlayerId, controller:Controller):Control {
+        return switch controller {
+            case Controller.HUMAN(index): buildHuman(id, index);
+            case Controller.BOT(type): buildBot(id, type);
+            case Controller.NONE: null;
+        }
+    }
+
+    private function buildHuman(id:PlayerId, index:Int):Control {
+        return null;
+    }
+
+    private function buildBot(id:PlayerId, type:String):Control {
+        return switch type {
+            case StupidBotControl.BOT_TYPE: new StupidBotControl(id);
+            case HardBotControl.BOT_TYPE: new HardBotControl(id);
+            case _: null;
+        }
+    }
+}

src/common/haxe/ru/m/tankz/control/Control.hx

@@ -1,8 +1,9 @@
 package ru.m.tankz.control;
 
-import ru.m.tankz.game.GameEvent;
 import ru.m.geom.Direction;
 import ru.m.tankz.core.EntityType;
+import ru.m.tankz.engine.IEngine;
+import ru.m.tankz.game.GameEvent;
 import ru.m.tankz.game.IGame;
 import ru.m.tankz.Type;
 
@@ -13,21 +14,23 @@ enum TankAction {
 }
 
 class Control {
-    public var type:String;
     public var playerId(default, null):PlayerId;
     public var tankId(default, default):Int;
     private var handler:IGame;
+    private var engine:IEngine;
 
     public function new(playerId:PlayerId) {
         this.playerId = playerId;
+        this.tankId = -1;
     }
 
-    public function bind(handler:IGame):Void {
+    public function bind(handler:IGame, engine:IEngine):Void {
         this.handler = handler;
+        this.engine = engine;
     }
 
     public function action(action:TankAction):Void {
-        if (tankId != 0 && handler != null) {
+        if (tankId > -1 && handler != null) {
             handler.gameEventSignal.emit(GameEvent.ACTION(tankId, action));
         }
     }
@@ -41,5 +44,7 @@ class Control {
     public function dispose():Void {
         stop();
         handler = null;
+        engine = null;
+        tankId = -1;
     }
 }

src/common/haxe/ru/m/tankz/core/Eagle.hx

@@ -11,7 +11,7 @@ class Eagle extends Entity {
     public var config(default, null):EagleConfig;
     public var color(default, default):Color;
     public var death(default, default):Bool;
-    public var protect(default, null):Modificator;
+    public var protect(default, default):Bool;
 
     public var score(get, null):Int;
 
@@ -20,15 +20,10 @@ class Eagle extends Entity {
         this.team = team;
         this.config = config;
         this.death = false;
-        this.protect = new Modificator(id);
+        this.protect = false;
     }
 
     private inline function get_score():Int {
         return config != null ? config.score : 0;
     }
-
-    override public function dispose() {
-        super.dispose();
-        protect.dispose();
-    }
 }

src/common/haxe/ru/m/tankz/core/Entity.hx

@@ -18,6 +18,4 @@ class Entity {
     public function toString():String {
         return '$type($id)';
     }
-
-    public function dispose() {}
 }