commiting changes to separate branch for later use

hGameTest/build.hxml

@@ -1,5 +1,11 @@
--main App
--js src/app.js
--cp node_modules/openfl/lib
+
+#-main App
+#-js src/app.js
+#-cp node_modules/openfl/lib
+#-cp src
+#-D buildhxml
+#-D source-map
+
+--main 
+-hl exp/out.hl
 -cp src
--D source-map

hGameTest/project.xml

@@ -3,28 +3,27 @@
 	<!-- NMML reference: https://gist.github.com/1763850 -->
 	
 	<!-- metadata, make sure 'package' is at least 3 segments (ie. com.mycompany.myproject) -->
-	<meta title="FLWork" package="FLWork" version="1.0.0" company="" />
+	<meta title="hgame" package="FLWork" version="1.0.0" company="" />
 	
 	<!-- output -->
-	<app main="Main" file="FLWork" path="bin" />
+	<app main="Main" file="hgame" path="bin" />
 	
-	<!-- <window background="#FFFFFF" fps="60" /> -->
-	<window background="null" color-depth="32" fps="60" />
-	<window width="320" height="480" unless="mobile" />
+	<window background="#FFFFFF" fps="60" />
+	<!--<window width="320" height="480" unless="mobile" />-->
+	<window width="1280" height="960" unless="mobile || html5" />
 	<window orientation="landscape" vsync="false" antialiasing="0" if="cpp" />
 	
 	<!-- classpath, haxe libs -->
 	<source path="src" />
-	<assets path="res/textures" rename="textures" />
-	<assets path="res/data" rename="data"/>
+	<assets path="./res/textures" rename="textures" />
+	<assets path="./res/fonts" rename="fonts" />
+	<assets path="./res/data" rename="data"/>
 	<haxelib name="openfl" />
 	<haxelib name="actuate" />
-	
 	<!-- assets -->
-	<icon path="assets/openfl.svg" />
+	<!--<icon path="assets/openfl.svg" /> -->
 	<!-- <assets path="assets/img" rename="img" /> -->
 	
 	<!-- optimize output
 	<haxeflag name="-dce full" /> -->
-	
 </project>

hGameTest/res/assets.manifest.json

@@ -0,0 +1,9 @@
+{
+    "datascheme": "assetmanifest",
+    "version": "1.0",
+    "type": "manifestmanifest",
+    "files": [
+        ""
+    ]
+
+}

hGameTest/src/App.hx

@@ -1,17 +1,25 @@
 import openfl.display.Sprite;
 import openfl.display.Stage;
 import openfl.events.Event;
+import assets.Scanner;
+import openfl.utils.AssetManifest;
 
 
 class App extends Sprite {
 	
 	
 	public function new () {
-		
 		super ();
-		var game:Game = new Game(stage);
-		game.onInit();
-		stage.addEventListener(Event.ENTER_FRAME, game.onEnterFrame);
+		Scanner.scanTextureDir();
+		trace("k");
+		#if buildhxml
+			var manifest = new AssetManifest ();
+			
+			
+		#end
+		//var game:Game = new Game(stage);
+		//game.onInit();
+		//stage.addEventListener(Event.ENTER_FRAME, game.onEnterFrame);
 		
 		
 	}

hGameTest/src/Main.hx

@@ -1,33 +1,39 @@
+import assets.Scanner;
+import game.video.Mode;
 import openfl.events.KeyboardEvent;
 import openfl.display.Sprite;
 import openfl.display.Stage;
 import openfl.events.Event;
+import game.Input;
 import game.Game;
+import game.video.Mode;
 
 class Main extends Sprite {
 	public function new () {
 		super ();
+		this.addEventListener(Event.ADDED_TO_STAGE, onInit);
+		//stage.application.window.resize(1920, 1080);
+		//stage.application.window.title = "Kanker";
+	} 
+	private function onInit(e:Event)
+	{
+		//Scanner.scanTextureDir();
+		trace("heyy");
 		stage.frameRate = 1000;
 		var game:Game = new Game(stage);
-		game.onInit();
+		trace("kokk");
 		stage.addEventListener(Event.ENTER_FRAME, game.onEnterFrame);
-		stage.addEventListener(KeyboardEvent.KEY_DOWN,keyIsDown);
-		stage.addEventListener(KeyboardEvent.KEY_UP,keyIsUp);
+		stage.addEventListener(KeyboardEvent.KEY_DOWN,Input.onKeyIsDown);
+		stage.addEventListener(KeyboardEvent.KEY_UP,Input.onKeyIsUp);
 		stage.addEventListener(Event.RESIZE,onResize);
-		stage.application.window.resize(1920, 1080);
-		stage.application.window.title = "Kanker";
+		game.onInit();
 		
-	} 
+		//Mode.setVideoMode(1280, 960);
+	}
 	private function onResize (event:Event):Void {
+		trace("yeet");
 		//Here we can do shit with window scaling
 		//stage.stageWidth;
 		//stage.stageHeight;
 	}
-	
-	private function keyIsDown(e:KeyboardEvent){
-		Game.keys[e.keyCode]  = true;
-	}
-	private function keyIsUp(e:KeyboardEvent){
-		Game.keys[e.keyCode]  = false;
-	}
 }

hGameTest/src/assets/Fonts.hx

@@ -0,0 +1,8 @@
+package assets;
+
+import openfl.text.Font;
+import openfl.Assets;
+
+class Fonts{
+    //public static var terminus:Font = Assets.getFont("fonts/Terminus.ttf");
+}

hGameTest/src/assets/HTex.hx

@@ -31,7 +31,7 @@ class HTex{
                     var tileNames:Array<String> = td.tilesetGeneric.tiles;
                     var atlas:TextureAtlas = new TextureAtlas(Assets.getBitmapData(baseTexturePath),width,height);
                     var tileSetGeneric = new TilesetGeneric(td.texName, atlas, tileNames);
-                    trace(tileSetGeneric);
+                    //trace(tileSetGeneric);
                 }
             }
         }

hGameTest/src/assets/Scanner.hx

@@ -1,7 +1,7 @@
 package assets;
+#if sys
 import sys.io.File;
 import sys.FileSystem;
-
 class Scanner{
     public static function scanTextureDir(){
         scanDirsRecursively("textures");
@@ -30,4 +30,16 @@ class Scanner{
             trace(textures);
         }
     }
-}
+}
+#else
+import openfl.Assets;
+import openfl.utils.AssetType;
+class Scanner{
+    public static function scanTextureDir(){
+        trace(Assets.list(AssetType.TEXT));
+        for(str in Assets.list(AssetType.TEXT)){
+            trace(str);
+        }
+    }
+}
+#end

hGameTest/src/engine/enums/CVarFlag.hx

@@ -0,0 +1,8 @@
+package engine.enums;
+
+enum CVarFlag{
+    FCVAR_ARCHIVE;
+    FCVAR_CHEAT;
+    FVCAR_REPLICATED;
+    FCVAR_NOTIFY;
+}

hGameTest/src/engine/enums/CVarType.hx

@@ -0,0 +1,8 @@
+package engine.enums;
+
+enum CVarType {
+    CInt;
+    CFloat;
+    CString;
+    CBool;
+}

hGameTest/src/engine/typedefs/CCmd.hx

@@ -0,0 +1,9 @@
+package engine.typedefs;
+
+import engine.typedefs.CVar;
+
+
+typedef CCmd = {
+    var name:String;
+    @:optional var callback:Array<String> -> Void;
+};

hGameTest/src/engine/typedefs/CVar.hx

@@ -0,0 +1,17 @@
+package engine.typedefs;
+
+import engine.enums.CVarType;
+import engine.enums.CVarFlag;
+
+typedef CVar = {
+    var name:String;
+    var type:CVarType;
+    var value:Dynamic;
+    var flags:CVarFlag;
+    var helpString:String;
+    var bMin:Bool;
+    var fMin:Float;
+    var fMax:Float;
+    var bMax:Bool;
+    @:optional var callback:Void -> Void;
+};

hGameTest/src/game/Bind.hx

@@ -0,0 +1,10 @@
+package game;
+
+class Bind{
+    public var key:Int;
+    public var action:String;    
+    public function new(key:Int, action:String){
+        this.key = key;
+        this.action = action;
+    }
+}

hGameTest/src/game/Game.hx

@@ -1,40 +1,53 @@
 package game;
 
+import engine.typedefs.CVar;
 import game.entities.Player;
-import assets.tilesets.TilesetGeneric;
-import assets.tilesets.Tileset;
-import openfl.display.Bitmap;
 import openfl.display.Stage;
-import openfl.display.Bitmap;
-import openfl.display.BitmapData;
 import openfl.display.Sprite;
-import openfl.ui.Keyboard;
 import openfl.events.Event;
-import openfl.Assets;
 import assets.Scanner;
 import assets.HTex;
-import openfl.Lib;
-import openfl.display.StageDisplayState;
+import game.ui.ConVar;
+import game.ui.console.Console;
 
 class Game
 {
     public var stage:Stage;
+    public var gameLayer:Sprite;
+    public var uiLayer:Sprite;
     public function new(_stage:Stage){
         stage = _stage;
+        /*
         Scanner.scanTextureDir();
         for(tex in Scanner.textures){
             HTex.createTextureObjectFromJSON(tex);
         }
+        */
+        gameLayer = new Sprite();
+        uiLayer = new Sprite();
+        trace("wattafak");
     }
     public var player:Player;
+    public var console:Console = new Console();
+    public function loadData():Void
+    {
+        new game.ui.text.TextFormats();
+        
+    }
     public function onInit():Void
     {
-		
+        
+        gameLayer = new Sprite();
+        uiLayer = new Sprite();
+        stage.addChild(gameLayer);
+        stage.addChild(uiLayer);
 		//player.graphics.lineStyle(2,0xFF0000);
         //player.graphics.drawRect(0,0,16,16);
         // var bitmapData:BitmapData = Assets.getBitmapData("textures/sprites/character.png");
-        player = new Player();
-        stage.addChild(player.sprite);
+        //player = new Player();
+        //gameLayer.addChild(player.sprite);
+        uiLayer.addChild(console);
+        var cvar_cl_kankerlow:CVar = ConVar.registerCVar("cl_kankerlow", CInt, 10, FCVAR_ARCHIVE, "is de speler een kankerlow?",null,false,false,0,0,false);
         //var sheet:SpriteSheet = new SpriteSheet(sheetData);
         //var playerBitmap:Bitmap = new Bitmap(Tileset.tilesetMap["testsheet"].tileMap["testTile5"]);
         //var someotherbitmap:Bitmap = new Bitmap(Tileset.tilesetMap["testsheet"].tileMap["testTile3"]);
@@ -43,21 +56,8 @@ class Game
         //TextureData.parseConfig();
         //Sys.
 	}
-    public static var keys:Array<Bool> = [];
-    public static var keysLast:Array<Bool> = [];
 	public function onEnterFrame(e:Event):Void
 	{
-        trace(keys);
-        if( keys[Keyboard.ALTERNATE] && keys[Keyboard.ENTER] && !keysLast[Keyboard.ALTERNATE] && !keysLast[Keyboard.ENTER] ){
-            if(Lib.current.stage.displayState != StageDisplayState.FULL_SCREEN_INTERACTIVE){
-                Lib.current.stage.displayState = StageDisplayState.FULL_SCREEN_INTERACTIVE;
-            }
-            else{
-                Lib.current.stage.displayState = StageDisplayState.NORMAL;
-            }
-        }
-        keysLast = keys;
-        //player.x++;
-        //player.y++;
+        Input.onEnterFrame();
 	}
 }

hGameTest/src/game/Input.hx

@@ -0,0 +1,105 @@
+package game;
+
+import engine.enums.CVarFlag;
+import engine.typedefs.CCmd;
+import game.ui.console.Console;
+import game.video.Mode;
+import openfl.events.KeyboardEvent;
+import openfl.ui.Keyboard in Kb;
+import openfl.Lib;
+import engine.enums.CVarType;
+import engine.typedefs.CVar;
+import game.ui.ConVar;
+
+
+class Input{
+    public static var keys:Map<Int,Bool> = [];
+    public static var keysLast:Map<Int,Bool> = [];
+    public static var bindMap:Map<String, String> = [];
+    //public static var bind:CVar = Convar.registerCVar("bind",CVarType.cCmd, null, ()->{
+    //
+    //});
+    public static var cv_debugKeys = ConVar.registerCVar("cl_debuginput", CInt, 0, null, "print debug messages related to input to console", null, false, true, 0, 0, false);
+    public static var keyNameMap:Map<Int, String> = [
+        Kb.HOME =>      "HOME",     Kb.END =>      "END",  Kb.INSERT =>   "INSERT", Kb.DELETE =>   "DELETE",     Kb.PAGE_UP =>     "PGUP", Kb.PAGE_DOWN =>    "PGDN", 
+        Kb.ESCAPE =>    "ESC",      Kb.F1 =>       "F1",   Kb.F2 =>       "F2",     Kb.F3 =>       "F3",         Kb.F4 =>          "F4",   Kb.F5 =>           "F5", 
+        Kb.F6 =>        "F6",       Kb.F7 =>       "F7",   Kb.F8 =>       "F8",     Kb.F9 =>       "F9",         Kb.F10 =>         "F10",  Kb.F11 =>          "F11",  
+        Kb.F12 =>       "F12",
+        Kb.BACKQUOTE => "~",        Kb.NUMBER_1 => "1",    Kb.NUMBER_2 => "2",      Kb.NUMBER_3 =>  "3",         Kb.NUMBER_4 =>    "4",    Kb.NUMBER_5 =>     "5" ,   
+        Kb.NUMBER_6 =>  "6",        Kb.NUMBER_7 => "7",    Kb.NUMBER_8 => "8",      Kb.NUMBER_9 =>  "9",         Kb.NUMBER_0 =>    "0",
+        Kb.TAB =>       "TAB",      Kb.Q =>        "Q",    Kb.W =>        "W",      Kb.E =>         "E",         Kb.R =>           "R",    Kb.T =>            "T",  Kb.Y =>         "Y",  
+        Kb.U =>         "U",        Kb.I =>        "I",    Kb.O =>        "O",      Kb.P =>         "P",         Kb.LEFTBRACKET => "[",    Kb.RIGHTBRACKET => "]",  Kb.BACKSLASH => "\\",
+        Kb.CAPS_LOCK => "CAPSLOCK", Kb.A =>        "A",    Kb.S =>        "S",      Kb.D =>         "D",         Kb.F =>           "F",    Kb.G =>            "G" , Kb.H =>         "H",  
+        Kb.J =>         "J",        Kb.K =>        "K" ,   Kb.L =>        "L",      Kb.SEMICOLON => "SEMICOLON", Kb.QUOTE =>       "'",    Kb.ENTER =>        "ENTER",
+        Kb.SHIFT =>     "SHIFT",    Kb.Z =>        "Z",    Kb.X =>        "X",      Kb.C =>         "C",         Kb.V =>           "V",    Kb.B =>            "B",  Kb.N =>         "N",  
+        Kb.M =>         "M",        Kb.COMMA =>    "COMMA",Kb.PERIOD =>   "PERIOD", Kb.SLASH =>     "/" ,
+        Kb.CONTROL =>   "CTRL",     Kb.ALTERNATE =>"ALT"  
+    ];
+    public static var keyCodeMap:Map<String, Int> = [
+        for(key in keyNameMap.keys()){
+            keyNameMap[key] => key;
+        }
+    ];
+    public static var cCmdGetKeyCode = ConVar.registerCCmd("getkey", (cArgs:Array<String>) -> {
+        var keycode:Int = keyCodeMap[cArgs[0]];
+        if(cArgs != null)
+            Console.devMsg(Std.string(keycode));
+    });
+    public static function onKeyIsDown(e:KeyboardEvent){
+        if(!keys[e.keyCode]){
+            if(cv_debugKeys.value > 0)
+                Console.devMsg("triggered key: "+keyNameMap[e.keyCode]);
+        }
+        keys[e.keyCode] = true;
+        var key:String = keyNameMap[e.keyCode];
+        if(cv_debugKeys.value > 0)  Console.devMsg(""+key);
+
+    }
+    public static function onKeyIsUp(e:KeyboardEvent){
+        keys[e.keyCode] = false;
+    }
+    public static function resolveKeyName(key:Int):String
+    {
+        return keyNameMap[key];
+    }
+    // public static function bind(input:Dynamic, action:String):Void
+    // {
+    //     var key:Int;
+    //     if(Std.is(input,Int)){
+    //         key = input;
+    //     }
+    //     else if(Std.is(input, String)){
+    //         var value:String = input;
+    //         key = keyCodeMap[value.toUpperCase()];
+    //     }
+        
+    // }
+    private static var bind:CCmd = ConVar.registerCCmd("bind", (cArgs:Array<String>)->{
+        
+        ConVar.runCmd("echo",cArgs);
+    });
+    public static function onEnterFrame()
+    {
+        if( keys[Kb.BACKQUOTE]){
+            //Console.toggle();
+            if(cv_debugKeys.value > 0) Console.devMsg("toggle console");
+                
+        }
+        if( keys[Kb.ALTERNATE] && keys[Kb.ENTER] && !keysLast[Kb.ALTERNATE] && !keysLast[Kb.ENTER] ){
+            Mode.switchFsMode();    
+        }
+        // Console Input field is in focus
+        if(Lib.current.stage.focus == Console.consoleInstance.cIn){
+            if ( keys[Kb.ENTER] && !keysLast[Kb.ENTER] && !keysLast[Kb.ALTERNATE]){
+                Console.consoleInstance.submitInput();
+            }
+            if (keys[Kb.UP] && !keysLast[Kb.UP]){
+                Console.histPrev();
+            }
+            if (keys[Kb.DOWN] && !keysLast[Kb.DOWN]){
+                Console.histNext();
+            }
+        }
+        keysLast = keys.copy();
+    }
+}

hGameTest/src/game/entities/BaseRenderable.hx

@@ -9,4 +9,7 @@ class BaseRenderable extends BaseEntity{
         super();
         sprite = new Sprite();
     }
+    override public function think(){
+        super.think();
+    }
 }

hGameTest/src/game/entities/Player.hx

@@ -10,6 +10,6 @@ class Player extends BaseRenderable{
         sprite.addChild(new Bitmap(Tileset.tilesetMap["testsheet"].tileMap["testTile5"]));
     }
     override public function think(){
-        
+        super.think();
     }
 }

hGameTest/src/game/scene/Map.hx

@@ -0,0 +1,2 @@
+package game.scene;
+

hGameTest/src/game/scene/Menu.hx

@@ -0,0 +1,2 @@
+package game.scene;
+

hGameTest/src/game/scene/Scene.hx

@@ -0,0 +1,2 @@
+package game.scene;
+

hGameTest/src/game/ui/CVar.hx

@@ -0,0 +1,9 @@
+package game.ui;
+
+
+typedef CVar = {
+    var name:String;
+    var type:CVarType;
+    var value:Dynamic;
+    @:optional var callback:Void -> Void;
+};

hGameTest/src/game/ui/CVarType.hx

@@ -0,0 +1,9 @@
+package game.ui;
+
+enum CVarType {
+    CInt;
+    CFloat;
+    CString;
+    CBool;
+    CCmd;
+}

hGameTest/src/game/ui/ConVar.hx

@@ -0,0 +1,162 @@
+package game.ui;
+
+import haxe.Constraints.Function;
+import engine.typedefs.CVar;
+import engine.typedefs.CCmd;
+import engine.enums.CVarType;
+import engine.enums.CVarFlag;
+import game.ui.console.Console;
+
+
+class ConVar{
+    static var CVarMap:Map<String, CVar> = [];
+    static var CCmdMap:Map<String, CCmd> = [];
+    /**
+     *  Registers a new CVar
+     *  @param _name The name of the CVar. This is the way it is called in the console or referred to in code.
+     *  @param _type CVar type as defined in the CVarType enum.
+     *  @param _value The default value for this CVar. This needs to be in line with its CVarType.
+     *  @param _flags CVar flags as defined in the CVarFlags enum.
+     *  @param _helpString Help string that gets printed out in console when no value is specified.
+     *  @param _callback The function that gets called when the CVar is set. Calls empty Void when left undefined.
+     *  @param _callOnCreate Whether the callback function gets called or not after registering.
+     *  @param _bMin Specifies if the CVar has a minimum numeric value.
+     *  @param _fMin Specifies the minimum numeric value.
+     *  @param _fMax Specifies the maximum numeric value. 
+     *  @param _bMax Specifies if the CVar has a maximum numeric value.
+     */
+    public static inline function registerCVar(_name:String, _type:CVarType, _value:Dynamic, ?_flags:CVarFlag, ?_helpString:String = "", ?_callback:Void->Void, ?_callOnCreate:Bool=false, _bMin:Bool=false, _fMin:Float=0, _fMax:Float=0, _bMax:Bool = false):CVar
+    {
+        if(CVarMap[_name]!=null || CCmdMap[_name]!=null){
+            Console.devMsg("Tried setting already defined convar: " + _name + ", returning null instead");
+            return null;
+        }
+        if(_bMin && _value < _fMin) _value = _fMin;
+        if(_bMax && _value > _fMax) _value = _fMax;
+        var cvar:CVar = CVarMap[_name] = {
+			name : _name,
+			type : _type,
+			value : _value,
+            flags: _flags,
+            helpString: _helpString,
+            bMin : _bMin,
+            fMin : _fMin,
+            fMax : _fMax,
+            bMax : _bMax,
+			callback : _callback == null ? ()->{} : _callback
+		}
+        if(_callback != null && _callOnCreate){
+            _callback();
+        }
+        return cvar;
+    }
+    public static inline function registerCCmd(_name:String, ?_callback:Array<String>->Void):CCmd
+    {
+        if(CVarMap[_name]!=null || CCmdMap[_name]!=null){
+            Console.devMsg("Tried setting already defined command: " + _name + ", returning null instead");
+            return null;
+        }
+        var cmd:CCmd = CCmdMap[_name] = {
+            name : _name,
+            callback : _callback
+        }
+        return cmd;
+    }
+    public static inline function setCVar(_name:String, _value:Dynamic):Void
+    {
+        var cv = getCVar(_name);
+        if(cv != null){
+            switch(cv.type){
+                case CInt,CFloat:
+                    if(cv.bMax && _value > cv.fMax) _value = cv.fMax;
+                    if(cv.bMin && _value < cv.fMin) _value = cv.fMin;
+                case CBool:
+                    if(Std.isOfType(_value, String)){
+                        var v:String = _value;
+                        _value = v.toLowerCase();
+                        if(_value == "true" || _value == "1"){
+                            _value = true;
+                        }
+                        else{
+                            _value = false;
+                        }
+                    }
+                    else if(Std.isOfType(_value, Int) || Std.isOfType(_value, Float)){
+                        if(_value %2 == 0){
+                            _value = false;
+                        }
+                        else{
+                            _value = true;
+                        }
+                    }
+                    else if(Std.isOfType(_value, Bool)){
+                        //do nothing
+                    }
+                    else{
+                        _value = cv.value;
+                    }
+                case CString:
+                    _value = Std.string(_value);
+                    
+            }
+            cv.value = _value;
+            cv.callback();
+
+        }
+        else{
+            Console.devMsg("trying to set null convar '"+_name+"'");
+        }
+
+    }
+    public static inline function isCVar(_name:String){
+        return (CVarMap[_name] != null);
+        
+    }
+    public static inline function isCmd(_name:String){
+        return (CCmdMap[_name] != null);
+    }
+    public static inline function runCmd(_name:String, _args:Array<String>){
+        if(CCmdMap[_name] != null){
+            CCmdMap[_name].callback(_args);
+        }
+    }
+    public static inline function getCVarNames():Array<String>
+    {
+        var keys:Array<String> = [
+            for(iterator in [CCmdMap.keys(),CVarMap.keys()]){
+                for(key in iterator){
+                    key;
+                }
+            }
+        ];
+        keys.sort(function(a:String, b:String):Int {
+            a = a.toUpperCase();
+            b = b.toUpperCase();
+            if (a < b) {
+                return -1;
+            }
+            else if (a > b) {
+                return 1;
+            } else {
+                return 0;
+            }
+        });
+        return keys;
+    }
+    public static var cmdList:CCmd = ConVar.registerCCmd("list", (cArgs:Array<String>)->{
+        var keys:Array<String> = getCVarNames();
+        for(key in keys){
+            if(CVarMap[key] != null){
+                Console.devMsg(key+" "+CVarMap[key].value);
+            }
+            else{
+                Console.devMsg(key);
+            }
+        }    
+    });
+    public static inline function getCVar(_name:String):CVar
+    {
+        return CVarMap[_name];
+    }
+
+}

hGameTest/src/game/ui/UIPane.hx

@@ -0,0 +1,258 @@
+package game.ui;
+
+import openfl.display.Sprite;
+import openfl.display.BitmapData;
+import openfl.display.DisplayObject;
+import openfl.text.TextField;
+
+typedef P2d = {
+    x:Float,
+    y:Float
+}
+enum PaneLayout{
+	HORIZONTAL;
+	VERTICAL;
+}
+enum PaneAnchor{
+    LEFT;
+	TOPLEFT;
+    TOP;
+	TOPRIGHT;
+    RIGHT;
+	BOTTOMLEFT;
+    BOTTOM;
+	BOTTOMRIGHT;
+}
+enum ExpandBehavior{
+    FACTOR;
+    ABSOLUTE;
+    STRETCH;
+    FILL;
+    FIT;
+    NONE;
+}
+enum PaneAlign{
+    START;
+    END;
+} 
+
+typedef PaneDimensions = {
+    var width:Float;
+	var height:Float;
+    @:optional var expandBehavior:ExpandBehavior;
+	@:optional var minWidth:Float;
+	@:optional var minHeight:Float;
+	@:optional var maxWidth:Float;
+	@:optional var maxHeight:Float;
+}
+
+typedef PaneProps = {
+	dimensions:PaneDimensions,
+	layout:PaneLayout
+}
+
+class UIPane{
+    public var name:String;
+    public var sprite:Sprite;
+    public var x(get, set):Float;
+    public var y(get, set):Float;
+    function get_x(){   return sprite.x; }
+    function set_x(x){  return sprite.x = x; }
+    function get_y(){   return sprite.y; }
+    function set_y(y){  return sprite.y = y; }
+    public var dimensions:PaneDimensions;
+    public var width(get,set):Float;
+    function get_width(){
+        return dimensions.width;
+    }
+    function set_width(width){
+        dimensions.width = width;
+        onResize();
+        return width;
+    }
+    public var height(get,set):Float;
+    function get_height(){
+        return dimensions.height; 
+    }
+    function set_height(height){
+        dimensions.height = height;
+        onResize();
+        return height; 
+    }
+	public var layout:PaneLayout;
+    public var autoArrange:Bool = true;
+    public var autoArrangeChildren = true;
+	public var expand:Bool;
+    public var children:Array<UIPane> = [];
+    public var parent:UIPane = null;
+    public var align:PaneAlign = START;
+    public var maskSprite:Sprite;
+    public function new(_name:String, _dimensions:PaneDimensions)
+	{
+        // Set name
+        name = _name;
+        // Set dimensions
+        if(_dimensions != null){
+            dimensions = _dimensions;
+        }
+        else{
+            dimensions = { 
+                width:      0, 
+                height:     0, 
+                minWidth:   0, 
+                minHeight:  0, 
+                maxWidth:   0, 
+                maxHeight:  0
+            };
+        }
+        
+        // Initialize Sprite
+        initSprite();
+        // Draw debug pane for visualizing
+		//drawDebugPane();
+	}
+    public function getAnchorOffset(anchor:PaneAnchor):P2d
+    {
+        switch(anchor){
+            case LEFT:
+                return {x:0,y:(height/2)};
+            case TOPLEFT:
+                return {x:0, y:0};
+            case TOP:
+                return {x:width/2,y:0};
+            case TOPRIGHT:
+                return {x:width, y:0};
+            case RIGHT:
+                return {x:width, y:height/2}
+            case BOTTOMRIGHT:
+                return {x:width, y:height};
+            case BOTTOM:
+                return {x:width/2, y:height};
+            case BOTTOMLEFT:
+                return {x:0, y:height};
+        }
+    }
+    public function initSprite():Void
+    {
+
+        // Construct Sprite object
+        sprite = new Sprite();
+
+		// Draw mask
+		//maskSprite = new Sprite();
+		//drawMask();
+		//sprite.addChild(maskSprite);
+		//sprite.mask = maskSprite;
+    }
+
+    public function drawMask():Void
+    {
+        maskSprite.graphics.clear();
+        maskSprite.graphics.beginFill(0xffffff);
+		maskSprite.graphics.drawRect(0,0,width,height);
+    }
+
+
+	public function drawDebugPane()
+	{
+		// Clear graphics
+        sprite.graphics.clear();
+        // Create objects we need to draw.
+		var label:TextField = new TextField();
+		var bmp = new BitmapData(Std.int(width),Std.int(height),true,0x00000000);
+		// Set textfield text to the panel name
+		label.text = name;
+		// Draw textfield to bitmap
+		bmp.draw(label);
+		// Draw graphics
+		sprite.graphics.beginFill(Std.int(Math.random()*0xffffff),0.5);
+		sprite.graphics.drawRect(0,0,dimensions.width,dimensions.height);
+		sprite.graphics.beginBitmapFill(bmp,null);
+		sprite.graphics.drawRect(0,0,dimensions.width,dimensions.height);
+        
+        if(true){
+            sprite.graphics.beginFill(Std.int(Math.random()*0xffffff),0.5);
+            sprite.graphics.drawCircle(getAnchorOffset(TOPLEFT).x,getAnchorOffset(TOPLEFT).y,5);
+            sprite.graphics.drawCircle(getAnchorOffset(TOP).x,getAnchorOffset(TOP).y,5);
+            sprite.graphics.drawCircle(getAnchorOffset(TOPRIGHT).x,getAnchorOffset(TOPRIGHT).y,5);
+            sprite.graphics.drawCircle(getAnchorOffset(RIGHT).x,getAnchorOffset(RIGHT).y,5);
+            sprite.graphics.drawCircle(getAnchorOffset(BOTTOMRIGHT).x,getAnchorOffset(BOTTOMRIGHT).y,5);
+            sprite.graphics.drawCircle(getAnchorOffset(BOTTOM).x,getAnchorOffset(BOTTOM).y,5);
+            sprite.graphics.drawCircle(getAnchorOffset(BOTTOMLEFT).x,getAnchorOffset(BOTTOMLEFT).y,5);
+            sprite.graphics.drawCircle(getAnchorOffset(LEFT).x,getAnchorOffset(LEFT).y,5);    
+        }
+        
+	}
+    public var endOffset:Float = 0;
+    public var startOffset:Float = 0;
+	public function addChild(child:UIPane)
+	{
+        children.push(child);
+        sprite.addChild(child.sprite);
+        child.parent = this;
+        if(child.autoArrange && autoArrangeChildren){
+            arrangeChild(child);
+        }
+        return child;
+	}
+    public function redraw():Void
+    {
+        //drawDebugPane();
+        //drawMask();
+    }
+	public function onResize(){
+        redraw();
+        if(autoArrangeChildren){
+            arrangeChildren();
+        }
+	}
+    private function arrangeChild(child:UIPane){
+        if(child.autoArrange){
+            switch(layout){
+                case HORIZONTAL:
+                    if(endOffset == 0) endOffset = width;
+                    switch(child.dimensions.expandBehavior){
+                        case STRETCH:
+                            child.width = endOffset-startOffset;
+                            child.height = height;
+                        default:
+                            child.height = height;
+                            //
+                    }
+                    switch(child.align){
+                        case START:
+                            child.x = startOffset;
+                            startOffset += child.width;
+                        case END:
+                            child.x = endOffset-= child.width;
+                    }
+                case VERTICAL:
+                    if(endOffset == 0) endOffset = height;
+                    switch(child.dimensions.expandBehavior){
+                        case STRETCH:
+                            child.height = endOffset-startOffset;
+                            child.width = width;
+                        default:
+                            child.width = width;
+                            //
+                    }
+                    switch(child.align){
+                        case START:
+                            child.y = startOffset;
+                            startOffset += child.height;
+                        case END:
+                            child.y = endOffset-=child.height;
+                    }
+            }
+            
+        }
+    }
+	public function arrangeChildren(){
+		startOffset = 0;
+        endOffset = 0;
+        for(child in children){
+            arrangeChild(child);
+        }
+	}
+
+}

hGameTest/src/game/ui/console/Console.hx

@@ -0,0 +1,381 @@
+package game.ui.console;
+
+import assets.Fonts;
+import openfl.Lib;
+import openfl.events.Event;
+import openfl.text.TextFieldAutoSize;
+import openfl.text.TextField;
+import openfl.display.Sprite;
+import openfl.Assets;
+import openfl.text.TextFormat;
+import openfl.text.TextFieldType;
+// Engine Imports
+import engine.enums.CVarFlag;
+import engine.typedefs.CVar;
+import engine.typedefs.CCmd;
+// Game imports
+import game.ui.ConVar;
+import game.ui.text.TextFormats;
+import game.ui.console.elements.ConsoleInput;
+import game.ui.UIPane;
+
+
+
+class Console extends Sprite{
+    public var textFormat:TextFormat;
+    public var cOut:TextField;
+    public var cIn:TextField;
+    public var cInput:ConsoleInput;
+    public var cAutoComp:TextField;
+    public static var consoleInstance:Console;
+    public var cvar_mat_consolebg:CVar;
+    public function new(){
+        super();
+        
+        consoleInstance = this;
+        
+        var consolePane:UIPane = new UIPane("console pane",{width: 800, height: 600});
+        var topBar:UIPane = new UIPane("top bar", {width: 800, height: 32});
+        var bottomBar:UIPane = new UIPane("input bar", {width: 800, height: 32});
+        var outputPane:UIPane = new UIPane("output pane", {width: 800, height: 1});
+        outputPane.dimensions.expandBehavior = STRETCH;
+        bottomBar.align = END;
+        outputPane.align = END;
+        consolePane.layout = VERTICAL;
+        topBar.align = START;
+        consolePane.addChild(topBar);
+        consolePane.addChild(bottomBar);
+        consolePane.addChild(outputPane);
+        addChild(consolePane.sprite);
+        //graphics.beginFill(0x555555);
+        graphics.drawRect(0,0,800,600);
+        
+        cInput = new ConsoleInput();
+        cIn = cInput.tf;
+        
+        //cIn.setTextFormat(textFormat);
+        cInput.y = 600-cInput.height-12;
+        cInput.x = 12;
+        
+        cvar_mat_consolebg = ConVar.registerCVar("mat_consolebg",CString,"0x222222",null,"console background color", ()->{
+            cOut.backgroundColor = Std.parseInt(cvar_mat_consolebg.value);
+            cIn.backgroundColor = Std.parseInt(cvar_mat_consolebg.value);
+        },false,false,0,0,false);
+        
+        cOut = new TextField();
+        cOut.text = "hConsole Initialized\n";
+        cOut.defaultTextFormat = TextFormats.getFormats().cOutputFmt;
+        cOut.wordWrap = true;
+        //cOut.autoSize = TextFieldAutoSize.LEFT;
+        cOut.multiline = true;
+        cOut.background = true;
+        cOut.backgroundColor = Std.parseInt(cvar_mat_consolebg.value);
+        cOut.width = outputPane.dimensions.width;
+        cOut.height = outputPane.dimensions.height;
+        cOut.y = 0;
+        cOut.x = 0;
+        
+
+
+
+        cAutoComp = new TextField();
+        cAutoComp.text = "";
+        cAutoComp.defaultTextFormat = TextFormats.getFormats().cInputFmt;
+        cAutoComp.wordWrap = false;
+        cAutoComp.multiline = true;
+        cAutoComp.background = true;
+        cAutoComp.backgroundColor = 0x11111100;
+        cAutoComp.border = true;
+        cAutoComp.borderColor = 0x55555500;
+        cAutoComp.selectable = false;
+        cAutoComp.width = 400;
+        cAutoComp.height = 32*5;
+        cAutoComp.visible = false;
+        cAutoComp.x = 0;
+        cAutoComp.y = 600;
+        
+        
+        
+        cOut.addEventListener(Event.CHANGE, onOutputTextChange);
+        cIn.addEventListener(Event.CHANGE, onInputTextChange);
+        //cOut.addEventListener()
+        outputPane.sprite.addChild(cOut);
+        this.addChild(cInput);
+        this.addChild(cAutoComp);
+        //ConVar.registerCVar("echo", CVarType.CCmd, null, devMsg())
+        ConVar.registerCCmd("echo", (args:Array<String>) -> { Console.devMsg(args.join(" ").split('"').join(""));});
+        ConVar.registerCCmd("quit", (args:Array<String>) -> { Lib.application.window.close();});
+    }
+    public function parseCmd(cmd:String){
+        history.push(cmd);
+        cmd = cmd.split(";").join(" ; ");
+        var subStrings = [];
+        var startQuoteIndex:Int = cmd.indexOf('"');
+        var endQuoteIndex:Int;
+        if(startQuoteIndex != -1){
+            while((startQuoteIndex = cmd.indexOf('"')) > -1){
+                //push start of the cmd up until the quotes start
+                subStrings.push(cmd.substring(0,startQuoteIndex));                
+                //find next quote
+                endQuoteIndex = cmd.indexOf('"',startQuoteIndex+1)+1;
+                if(endQuoteIndex == 0){
+                    cmd+='"';
+                    endQuoteIndex = cmd.length;
+                    
+                }
+                //push quote content
+                subStrings.push(cmd.substring(startQuoteIndex,endQuoteIndex));
+                cmd = cmd.substr(endQuoteIndex);
+            }
+        }
+        subStrings.push(cmd);
+        //Split args
+        var newSubStrings = [];
+        for(subString in subStrings){
+            if(subString.indexOf('"') == -1){
+                // split spaced args
+                for(str in subString.split(" ")){
+                    //we want to discard empty strings
+                    if(str != "")
+                        newSubStrings.push(str);
+                }
+                
+            }
+            else{
+                newSubStrings.push(subString);
+            }
+        }
+        var commands = [];
+        //split off additional commands
+        while(newSubStrings.length > 0){
+            for(i in 0...newSubStrings.length){
+                if(newSubStrings[i] == ";"){
+                    commands.push(newSubStrings.splice(0,i));
+                    newSubStrings.shift();
+                    break;
+                }
+                if(newSubStrings.length-1 == i){
+                    commands.push(newSubStrings);
+                    newSubStrings = [];
+                }
+            }
+        }
+        trace(commands);
+        execCommands(commands);
+    }
+    public function execCommands(commands:Array<Array<String>>){
+        for(command in commands){
+            var cName:String = command[0];
+            var cValue:String = command[1];
+            var cArgs:Array<String> = command.slice(1);
+            if(ConVar.isCVar(cName)){
+                var cv:CVar = ConVar.getCVar(command[0]);
+                if(command.length == 1){
+                    devMsg(cv.name+" - "+cv.helpString);
+                    devMsg(cv.name+" = "+cv.value);
+                }
+                else{
+                    switch(cv.type){
+                        case CInt:
+                            ConVar.setCVar(cName,Std.parseInt(cValue));
+                            trace(cValue);
+                            break;
+                        case CFloat:
+                            ConVar.setCVar(cName,Std.parseFloat(cValue));
+                            break;
+                        case CBool:
+                            cValue = cValue.toLowerCase();
+                            if(cValue == "1" || cValue == "true"){
+                                ConVar.setCVar(cName,true);
+                            }
+                            else if(cValue == "0" || cValue == "false"){
+                                ConVar.setCVar(cName,false);
+                            }
+                            break;
+                        case CString:
+                            ConVar.setCVar(cName,cValue);
+                            break;
+                    }
+                    
+                }
+                
+            }
+            else if(ConVar.isCmd(cName)){
+                ConVar.runCmd(cName,cArgs);
+            }
+            else{
+                devMsg("unkown command: "+command[0]);
+            }
+        }
+    }
+    public function submitInput(){
+        cOut.appendText(">"+cIn.text+"\n");
+        parseCmd(cIn.text);
+        cIn.text = "";
+        cAutoComp.visible = false;
+        cOut.scrollV = cOut.maxScrollV;
+        histSelect = -1;
+    }
+    public function onOutputTextChange(e:Event){
+        cOut.scrollV = cOut.maxScrollV;
+    }
+    public function onInputTextChange(e:Event){
+        if(cIn.text != ""){
+            cAutoComp.text = "";
+            for(string in (autocompleteList = getCompList())){
+                cAutoComp.text += string+"\n";
+                trace(string);
+            }
+            cAutoComp.visible = true;
+        }
+        else{
+            cAutoComp.visible = false;
+            autocompleteList = history;
+        }
+    }
+    public static function toggle():Void
+    {
+        consoleInstance.visible = !consoleInstance.visible;
+    }
+    public static function devMsg(msg:String):Void
+    {
+        consoleInstance.cOut.appendText(msg+"\n");
+        consoleInstance.cOut.scrollV = consoleInstance.cOut.maxScrollV;
+    }
+    public static var history:Array<String> = [];
+    public static var histSelect:Int = -1;
+    public static var tmpInput:String = "";
+    public static var autocompleteList:Array<String> = [];
+    public static var compSelect:Int = -1;
+    public static function getCompList():Array<String>
+    {
+        // Split words
+        var inp:Array<String> = consoleInstance.cIn.text.split(" ");
+        var inpStripped:Array<String> = [
+            for(word in inp){
+                if(word != "" && word != " "){
+                    word;
+                }
+            }
+        ];
+        // Stop if input is empty
+        if(inp.length == 0) return [];
+
+        var cVars:Array<String> = ConVar.getCVarNames();
+        var cVarFiltered:Array<String> = [];
+        // Loop through convars
+        for(cVar in cVars){
+            //if there's one word just check if the convar starts with the input string
+            if(inp.length == 1)
+            {
+                // Check if the cvar starts with the input
+                if(cVar.indexOf(inp[0]) == 0){
+                    cVarFiltered.push(cVar);
+                }
+            }
+            // User pressed space at least once but entered no other words. Check if first word occurs at any position
+            else if(inpStripped.length == 1 && inp.length > 1){
+                if(cVar.indexOf(inp[0]) > -1){
+                    cVarFiltered.push(cVar);
+                }
+            }
+            // Multiple words, check for cvars that contain all of them
+            else if(inpStripped.length > 1)
+            {
+                var bWordNotPresent:Bool = false;
+                for(word in inpStripped){
+                    if(cVar.indexOf(word) == -1){
+                        bWordNotPresent = true;
+                    }
+                }
+                if(!bWordNotPresent)
+                    cVarFiltered.push(cVar);
+            }
+        }
+        return cVarFiltered;
+    }
+    public static function histPrev():Void
+    {
+        // Only complete if input field is empty or scrolling through hist
+        if(consoleInstance.cIn.text == "" || histSelect != -1){
+            // Store current input in tmpInput
+            if(histSelect == -1) tmpInput = consoleInstance.cIn.text;
+            // Only go through history if history is not empty
+            if(history.length != 0){
+                // Check if currently selecting a history entry
+                if(histSelect >= 0){
+                    histSelect--;
+                }
+                // Not currently selecting a history entry
+                else{
+                    // Put selector to the newest
+                    histSelect = history.length -1;
+                }
+                if(histSelect != -1){
+                    // Put correct history entry in the input field
+                    consoleInstance.cIn.text = history[histSelect];
+                }
+                else{
+                    // Restore tmp input
+                    consoleInstance.cIn.text = tmpInput;
+                }
+            }
+            // History is empty
+            else{
+                // Do nothing
+                return;
+            }
+        }
+        // Now we need to descend through the autocomplete list
+        else{
+            if(autocompleteList.length == 0){
+                return;
+            }
+            else{
+                // Check if currently selecting an autocomplete entry
+                if(compSelect > -1){
+                    
+                }
+                // Not currently selecting an autocomplete entry
+                else{
+    
+                }
+            }
+                
+            
+        }
+    }
+    public static function histNext():Void
+    {
+        // Only complete if input field is empty or scrolling through hist
+        if(consoleInstance.cIn.text == "" || histSelect != -1){
+            // Store current input in tmpInput
+            if(histSelect == -1) tmpInput = consoleInstance.cIn.text;
+            // Only go through history if history is not empty
+            if(history.length != 0){
+                // Check if currently selecting a history entry
+                if(histSelect < history.length -1){
+                    histSelect++;
+                }
+                // Otherwise wrap around
+                else{
+                    // Put selector to no selection
+                    histSelect = -1;
+                }
+                if(histSelect != -1){
+                    // Put correct history entry in the input field
+                    consoleInstance.cIn.text = history[histSelect];
+                }
+                else{
+                    // Restore tmp input
+                    consoleInstance.cIn.text = tmpInput;
+                }
+            }
+            // History is empty
+            else{
+                // Do nothing
+                return;
+            }
+        }
+    }
+}

hGameTest/src/game/ui/console/elements/ConsoleInput.hx

@@ -0,0 +1,51 @@
+package game.ui.console.elements;
+
+import openfl.events.Event;
+import openfl.display.Sprite;
+import openfl.text.TextField;
+import openfl.text.TextFieldType;
+import openfl.text.TextFormat;
+import openfl.Assets;
+import game.ui.text.TextFormats;
+
+class ConsoleInput extends Sprite
+{
+    public var tf:TextField;
+    public function new(){
+        super();
+        tf = new TextField();
+        tf.defaultTextFormat = TextFormats.getFormats().cInputFmt;
+        tf.text = "";
+        //tf.setTextFormat(new TextFormat(Assets.getFont("fonts/Terminus.ttf").fontName, 24, 0x00ff00));
+        trace(tf.getTextFormat().color);
+        trace(tf.getTextFormat().font);
+        tf.type = TextFieldType.INPUT;
+        tf.multiline = false;
+        //tf.autoSize = TextFieldAutoSize.LEFT;
+        tf.width = 800-24;
+        tf.height = tf.textHeight+2;
+        tf.background = true;
+        tf.backgroundColor = 0x222222;
+        tf.selectable = true;
+        this.addChild(tf);
+        this.addEventListener(Event.RESIZE,onResize);
+        tf.addEventListener(Event.CHANGE, onTextChange);
+    }
+    public function onResize(e:Event){
+        tf.width = this.width;
+    }
+    public function onTextChange(e:Event){
+        
+    }
+    public function clearText(){
+        tf.text = "";
+    }
+    public function getText():String
+    {
+        return tf.text;
+    }
+    public function setText(t:String){
+        tf.text = t;
+    }
+    
+}

hGameTest/src/game/ui/text/TextFormats.hx

@@ -0,0 +1,24 @@
+package game.ui.text;
+
+
+import openfl.text.TextFormat;
+import openfl.Assets;
+import assets.Fonts;
+
+class TextFormats{
+    public static var formats:TextFormats;
+    public var cInputFmt:TextFormat;
+    public var cOutputFmt:TextFormat;
+    public function new(){
+        cInputFmt = new TextFormat(Assets.getFont("fonts/Terminus.ttf").fontName, 24, 0xffffff);
+        cOutputFmt = new TextFormat(Assets.getFont("fonts/Terminus.ttf").fontName, 24, 0xffffff);
+    }
+    public static function getFormats():TextFormats
+    {
+        if(formats == null){
+            formats = new TextFormats();
+        }
+        return formats;
+    }
+    
+}

hGameTest/src/game/video/Mode.hx

@@ -0,0 +1,35 @@
+package game.video;
+
+import game.ui.ConVar;
+import openfl.Lib;
+import openfl.display.StageDisplayState;
+
+class Mode
+{
+    public static function getWindow():lime.ui.Window
+    {
+        return Lib.application.window;
+    }
+    public static function setVideoMode(width:Int, height:Int, fs:Int = null){
+        getWindow().resize(width,height);
+        if(fs != null){
+            switchFsMode(fs);
+        }
+    }
+    public static var cvMatSetVideoMode:engine.typedefs.CCmd = ConVar.registerCCmd("mat_setvideomode",(args:Array<String>)->{
+        setVideoMode(Std.parseInt(args[0]), Std.parseInt(args[1]), Std.parseInt(args[2]));
+    });
+    public static function switchFsMode(toState:Int = 0){
+        if(toState == 0){
+            if(Lib.current.stage.displayState != StageDisplayState.FULL_SCREEN_INTERACTIVE){
+                Lib.current.stage.displayState = StageDisplayState.FULL_SCREEN_INTERACTIVE;
+            }
+            else{
+                Lib.current.stage.displayState = StageDisplayState.NORMAL;
+            }
+        }
+        else{
+            
+        }
+    }
+}