Sorry your browser is not supported!

            var attrs = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyTitleAttribute), false).FirstOrDefault() as AssemblyTitleAttribute;
            var title = attrs.Title;

            Core.CreateWindow(title, 640, 480, false);

static void Main(string[] args)

namespace AGKCore
{
    public class App
    {
        static Form m_Window;
        static bool m_bMaximized = false;
        static bool m_bBreakLoop = false;
        public static bool DisableEscape { get; set; } = false;

        public static AppConfig Config;

	…
    }

    public struct AppConfig
    {
        public int LogLevel;
        public ScreenConfig Screen;
    }

    public struct ScreenConfig
    {
        public int Width;
        public int Height;
        public int X1;
        public int Y1;
        public int X2;
        public int Y2;
        public int CenterX;
        public int CenterY;
        public int Layout;
        public bool Fullscreen;
        public bool Vsync;
    }
}

        public static void Init(string[] args, string title)
        {
            //config defaults
            App.Config.LogLevel = 3;
            App.Config.Screen.Fullscreen = true;
            App.Config.Screen.Width = 0;
            App.Config.Screen.Height = 0;
            App.Config.Screen.Vsync = true;

            //config overrides
            foreach (string arg in args)
            {
                switch (arg.Split('=').First().ToLower())
                {
                    case "sw": App.Config.Screen.Width = Convert.ToInt32(arg.Split('=').Last()); break;
                    case "sh": App.Config.Screen.Height = Convert.ToInt32(arg.Split('=').Last()); break;
                    case "fs": App.Config.Screen.Fullscreen = Convert.ToBoolean(arg.Split('=').Last()); break;
                    case "vsync": App.Config.Screen.Vsync = Convert.ToBoolean(arg.Split('=').Last()); break;
                    case "log": App.Config.LogLevel = Convert.ToInt32(arg.Split('=').Last()); break;
                    default: break;
                }
            }

            //init the screen

            if (App.Config.Screen.Width == 0)
            {
                App.Config.Screen.Width = System.Windows.Forms.SystemInformation.PrimaryMonitorSize.Width;
                App.Config.Screen.Height = System.Windows.Forms.SystemInformation.PrimaryMonitorSize.Height;
            }

            App.Config.Screen.CenterX = (int)Math.Floor(App.Config.Screen.Width * 0.5);
            App.Config.Screen.CenterY = (int)Math.Floor(App.Config.Screen.Height * 0.5);

            App.CreateWindow(title, App.Config.Screen.Width, App.Config.Screen.Height, App.Config.Screen.Fullscreen);

            if (!App.InitAGK())
            {
                return;
            }

            Agk.SetResolutionMode(1);
            Agk.SetOrientationAllowed(0, 0, 1, 0);
            if (!App.Config.Screen.Fullscreen)
            {
                Agk.SetWindowAllowResize(0);
            }
            Agk.SetVirtualResolution(App.Config.Screen.Width, App.Config.Screen.Height);
            Agk.SetScissor(0, 0, 0, 0);

            Agk.SetVSync(App.Config.Screen.Vsync);
            if (!App.Config.Screen.Vsync)
            {
                Agk.SetSyncRate(0, 0);
            }

            //init AGK Misc
            Agk.SetPrintSize(16.0f);
            Agk.SetPrintColor(255, 255, 255);
            Agk.SetClearColor(0, 0, 0);
            Agk.UseNewDefaultFonts(1);
        }

        static void Main(string[] args)
        {
            var attrs = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyTitleAttribute), false).FirstOrDefault() as AssemblyTitleAttribute;

            App.Init(args, attrs.Title);

            // display a background and center it
            uint bgImg = Agk.CreateSprite(Agk.LoadImage("media/background.jpg"));
            Agk.SetSpritePosition(bgImg, App.Config.Screen.CenterX - 160, App.Config.Screen.CenterY - 240);

            // create a sprite and center it
            Agk.CreateSprite(1, 0);
            Agk.SetSpritePosition(1, App.Config.Screen.CenterX - 30, App.Config.Screen.CenterY - 44);

            …

        public static bool Init(string[] args, string title)
        {
            App.Status.LoadState = 1;
            App.Status.LoadStage = 1;

            //config defaults
            App.Config.Log.Level = 3;
            App.Config.Log.File = System.AppDomain.CurrentDomain.BaseDirectory + "app.log";
            App.Config.Log.Channels = "*";

            App.Config.Screen.Fullscreen = true;
            App.Config.Screen.Width = 0;
            App.Config.Screen.Height = 0;
            App.Config.Screen.Vsync = true;

            //config overrides
            foreach (string arg in args)
            {
                switch (arg.Split('=').First().ToLower())
                {
                    case "sw": App.Config.Screen.Width = Convert.ToInt32(arg.Split('=').Last()); break;
                    case "sh": App.Config.Screen.Height = Convert.ToInt32(arg.Split('=').Last()); break;
                    case "fs": App.Config.Screen.Fullscreen = Convert.ToBoolean(arg.Split('=').Last()); break;
                    case "vsync": App.Config.Screen.Vsync = Convert.ToBoolean(arg.Split('=').Last()); break;
                    case "log": App.Config.Log.Level = Convert.ToInt32(arg.Split('=').Last()); break;
                    default: break;
                }
            }

            //init the screen

            if (App.Config.Screen.Width == 0)
            {
                App.Config.Screen.Width = System.Windows.Forms.SystemInformation.PrimaryMonitorSize.Width;
                App.Config.Screen.Height = System.Windows.Forms.SystemInformation.PrimaryMonitorSize.Height;
            }

            App.Config.Screen.CenterX = (int)Math.Floor(App.Config.Screen.Width * 0.5);
            App.Config.Screen.CenterY = (int)Math.Floor(App.Config.Screen.Height * 0.5);

            if (App.Config.Screen.Width > 1280)
            {
                App.Config.Screen.Layout = 1;
            }
            else {
                App.Config.Screen.Layout = 2;
            }

            App.CreateWindow(title, App.Config.Screen.Width, App.Config.Screen.Height, App.Config.Screen.Fullscreen);

            if (!App.InitAGK())
            {
                return false;
            }

            Agk.SetResolutionMode(1);
            Agk.SetOrientationAllowed(0, 0, 1, 0);
            if (!App.Config.Screen.Fullscreen)
            {
                Agk.SetWindowAllowResize(0);
            }
            Agk.SetVirtualResolution(App.Config.Screen.Width, App.Config.Screen.Height);
            Agk.SetScissor(0, 0, 0, 0);

            Agk.SetVSync(App.Config.Screen.Vsync);
            if (!App.Config.Screen.Vsync)
            {
                Agk.SetSyncRate(0, 0);
            }

            //init AGK Misc
            Agk.SetPrintSize(16.0f);
            Agk.SetPrintColor(255, 255, 255);
            Agk.SetClearColor(0, 0, 0);
            Agk.UseNewDefaultFonts(1);

            //init log
            System.IO.File.WriteAllText(App.Config.Log.File, "Timestamp    | File            | Level | Channel    | Log" + Environment.NewLine);
            System.IO.File.AppendAllText(App.Config.Log.File, "==================================================================" + Environment.NewLine);

            App.Status.IsRunning = true;

            return true;
        }

        public static void Log(string rSource, int rLevel, string rChannel, string rContent)
        {
            if(rLevel >= App.Config.Log.Level)
            {
                if(App.Config.Log.Channels == "*" || App.Config.Log.Channels.Contains("|" + rChannel + "|"))
                {
                    System.IO.File.AppendAllText(App.Config.Log.File, DateTime.Now.ToString("HH:mm:ss.fff") + " | " + rSource.PadRight(15) + " | " + rLevel.ToString().PadRight(5) + " | " + rChannel.PadRight(10) + " | " + rContent + Environment.NewLine);
                }
            }
        }

    }

    public struct AppConfig
    {
        public LogConfig Log;
        public ScreenConfig Screen;
    }

    public struct ScreenConfig
    {
        public int Width;
        public int Height;
        public int X1;
        public int Y1;
        public int X2;
        public int Y2;
        public int CenterX;
        public int CenterY;
        public int Layout;
        public bool Fullscreen;
        public bool Vsync;
    }

    public struct LogConfig
    {
        public int Level;
        public string Channels;
        public string File;
    }

    public struct AppStatus
    {
        public bool IsRunning;
        public int LoadState; //0 not loaded | 1 loading | 2 title loop (UI only) | 3 level load finished | 4 game in progress | 5 level reload/transition
        public int LoadStage; //0 init resources | 1 transition in | 2 body | 3 transition out
        public int LoadType; //0 not loading | 1 title load | 2 level load	
    }

    static class Program
    {
        [STAThread]
        static void Main(string[] args)
        {
            var attrs = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyTitleAttribute), false).FirstOrDefault() as AssemblyTitleAttribute;

            if(!App.Init(args, attrs.Title))
            {
                return;
            }

#if DEBUG
            App.Log("Program.cs", 3, "main", "> Init Complete");
#endif

            // display a background and center it
            uint bgImg = Agk.CreateSprite(Agk.LoadImage("media/background.jpg"));
            Agk.SetSpritePosition(bgImg, App.Config.Screen.CenterX - 160, App.Config.Screen.CenterY - 240);

            // create a sprite and center it
            Agk.CreateSprite(1, 0);
            Agk.SetSpritePosition(1, App.Config.Screen.CenterX - 30, App.Config.Screen.CenterY - 44);

            // add individual images into an animation list
            Agk.AddSpriteAnimationFrame(1, Agk.LoadImage("media/item0.png"));
            Agk.AddSpriteAnimationFrame(1, Agk.LoadImage("media/item1.png"));
            Agk.AddSpriteAnimationFrame(1, Agk.LoadImage("media/item2.png"));
            Agk.AddSpriteAnimationFrame(1, Agk.LoadImage("media/item3.png"));
            Agk.AddSpriteAnimationFrame(1, Agk.LoadImage("media/item4.png"));

            // play the sprite at 10 fps, looping, going from frame 1 to 5
            Agk.PlaySprite(1, 10.0f, 1, 1, 5);
           
            while (App.LoopAGK())
            {
#if DEBUG
                App.Log("Program.cs", 1, "main", "--- Begin main loop ---");
#endif
                Agk.Sync();
            }
            App.CleanUp();
        }

    }
 

Timestamp    | File            | Level | Channel    | Log
==================================================================
 

Timestamp    | File            | Level | Channel    | Log
==================================================================
22:40:39.732 | Program.cs      | 3     | main       | > Init Complete

Timestamp    | File            | Level | Channel    | Log
==================================================================
22:52:50.737 | Program.cs      | 3     | main       | > Init Complete
22:52:50.810 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:50.874 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:50.923 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:50.956 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:50.990 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:51.023 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:51.074 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:51.123 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:51.156 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:51.190 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:51.223 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:51.256 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:51.306 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:51.340 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:51.390 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:51.423 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:51.457 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:51.507 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:51.540 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:51.623 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:51.657 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:51.691 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:51.724 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:51.774 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:51.808 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:51.840 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:51.874 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:51.907 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:51.941 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:51.974 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:52.007 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:52.041 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:52.074 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:52.124 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:52.174 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:52.207 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:52.258 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:52.308 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:52.343 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:52.375 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:52.408 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:52.442 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:52.474 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:52.508 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:52.558 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:52.591 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:52.625 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:52.657 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:52.690 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:52.707 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:52.742 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:52.792 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:52.825 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:52.857 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:52.891 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:52.926 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:52.974 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:53.008 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:53.024 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:53.057 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:53.091 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:53.126 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:53.412 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:53.545 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:53.578 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:53.608 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:53.642 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:53.691 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:53.725 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:53.759 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:53.791 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:53.808 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:53.841 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:53.874 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:53.907 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:53.941 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:53.991 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:54.024 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:54.074 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:54.107 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:54.141 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:54.175 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:54.207 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:54.241 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:54.292 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:54.324 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:54.358 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:54.391 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:54.425 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:54.475 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:54.541 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:54.557 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:54.591 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:54.626 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:54.658 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:54.691 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:54.725 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:54.792 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:54.824 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:54.857 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:54.874 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:54.892 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:54.925 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:54.958 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:54.991 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:55.025 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:55.042 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:55.075 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:55.092 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:55.126 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:55.175 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:55.209 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:55.260 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:55.292 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:55.325 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:55.358 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:55.393 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:55.443 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:55.493 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:55.543 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:55.576 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:55.626 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:55.659 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:55.692 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:55.725 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:55.742 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:55.775 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:55.813 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:55.843 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:55.876 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:55.910 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:55.943 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:55.976 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:56.010 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:56.042 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:56.075 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:56.110 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:56.142 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:56.176 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:56.226 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:56.277 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:56.309 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:56.342 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:56.376 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:56.409 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:56.459 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:56.511 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:56.542 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:56.560 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:56.593 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:56.626 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:56.642 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:56.676 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:56.710 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:56.743 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:56.761 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:56.793 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:56.844 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:56.894 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:56.945 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:56.977 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:57.010 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:57.043 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:57.076 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:57.110 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:57.160 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:57.194 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:57.244 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:57.294 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:57.326 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:57.361 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:57.411 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:57.460 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:57.493 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:57.526 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:57.577 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:57.611 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:57.644 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:57.677 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:57.727 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:57.778 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:57.811 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:57.844 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:57.877 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:57.910 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:57.944 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:57.995 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:58.044 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:58.077 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:58.110 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:58.144 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:58.194 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:58.227 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:58.261 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:58.294 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:58.327 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:58.378 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:58.428 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:58.462 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:58.495 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:58.544 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:58.578 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:58.629 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:58.661 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:58.694 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:58.730 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:58.778 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:58.811 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:58.861 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:58.895 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:58.928 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:58.961 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:58.995 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:59.028 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:59.078 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:59.128 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:59.162 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:59.230 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:59.295 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:59.329 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:59.362 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:59.395 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:59.428 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:59.462 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:59.495 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:59.544 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:59.580 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:59.611 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:59.645 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:59.678 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:59.713 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:59.746 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:59.779 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:59.812 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:59.845 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:59.896 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:59.929 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:59.963 | Program.cs      | 1     | main       | --- Begin main loop ---
22:52:59.995 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:00.045 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:00.080 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:00.113 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:00.146 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:00.178 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:00.229 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:00.262 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:00.313 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:00.345 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:00.379 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:00.430 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:00.496 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:00.547 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:00.596 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:00.630 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:00.680 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:00.732 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:00.797 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:00.829 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:00.862 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:00.896 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:00.930 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:00.980 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:01.013 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:01.046 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:01.080 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:01.112 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:01.162 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:01.197 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:01.230 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:01.280 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:01.313 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:01.363 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:01.412 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:01.446 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:01.497 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:01.564 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:01.629 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:01.664 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:01.696 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:01.730 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:01.764 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:01.797 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:01.831 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:01.897 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:01.947 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:01.998 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:02.030 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:02.063 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:02.096 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:02.130 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:02.163 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:02.214 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:02.264 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:02.296 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:02.330 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:02.363 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:02.397 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:02.430 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:02.464 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:02.514 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:02.547 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:02.580 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:02.615 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:02.681 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:02.714 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:02.764 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:02.798 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:02.831 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:02.865 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:02.898 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:02.932 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:02.965 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:02.999 | Program.cs      | 1     | main       | --- Begin main loop ---
22:53:03.031 | Program.cs      | 1     | main       | --- Begin main loop ---

If GetRawKeyState(uparrow)
	Move character forward…
endif

…hardware controller
uparrow.wasDown = uparrow.isDown
uparrow.isDown = GetRawKeyState(uparrow)

… player controls
myCharacter.isMoving = uparrow.isDown

…character controller
If thisCharacter.isMoving
	Move character forward…
endif 

/*
	-------------------------------------------------------------------------------------
	System Utility
	-------------------------------------------------------------------------------------
	Author: Josh Kirklin (Ortu) http://joshkirklin.com | http://githubn.com/ortu-
	-------------------------------------------------------------------------------------
	Contributors:
	-------------------------------------------------------------------------------------

	Description:

		Provides various OS, hardware, timing and performance monitoring processes.

	*******************************************
	
*/

//Declare System -----------------------------------------------------------------

type System_type_timingData
	timer as integer
	delta as integer
	updateMark as integer
	pauseState as integer
	pauseMark as integer
	pauseElapsed as integer
	pauseHold as integer
endtype

type System_type_logData
	fileNumber as integer
	includeLevel as integer
	includeChannels as string
endtype

type System_type_mouseInputData
	moveX as float
	moveY as float
	moveZ as float
	posX as integer
	posY as integer
endtype

type CLASS_SystemInterval
	id as string
	target as string
	mark as integer
	interval as integer
	doneTicks as integer
	maxTicks as integer
	callback as string
	args as string
endtype

type STATIC_CLASS_System
	log as System_type_logData
	timing as System_type_timingData
	mouse as System_type_mouseInputData
	input as integer[222] //keystates :: bit 1 = isDown, bit 2 = wasDown >> TODO: 0 not pressed, 1 new press, 2 new release, 3 held
	intervalList as CLASS_SystemInterval[]
endtype

//==================================

GLOBAL System as STATIC_CLASS_System

// ==================================

#CONSTANT BIT_System_pauseHoldSystem 1
#CONSTANT BIT_System_pauseHoldUI 2

//Module Functions ---------------------------------------------------------------

function System_init()
	
	//init log file
	//================================================================================================================================================================================
	//================================================================================================================================================================================

	System.log.includeChannels = "*"
	//System.log.includeChannels = "|!|error|main|ai|ui|ui-event|"

	//================================================================================================================================================================================
	//================================================================================================================================================================================	
	
	System.log.includeLevel = App.config.logLevel
	System.log.fileNumber = OpenToWrite("log.txt")
	WriteLine(System.log.fileNumber, "Runtime   | File            | Level | Channel    | Log")
	WriteLine(System.log.fileNumber, "==================================================================")
	
	App_addUpdate("System_updateIntervals", "", FALSE)
	
endfunction


function System_updateTiming()
	
	System.timing.timer = GetMilliseconds()
	System.timing.delta = abs(System.timing.timer - System.timing.delta)
	
	oldPause = System.timing.pauseState
	if System.timing.pauseHold = 0
		System.timing.pauseState = 0
	else
		System.timing.pauseState = 1
		if oldPause = 0
			System.timing.pauseMark = System.timing.timer //new pause
		else
			System.timing.pauseElapsed = abs(System.timing.timer - System.timing.pauseMark)
		endif
	endif
	
	if System.timing.pauseState = 2
		//pause ended and elapsed time has been applied, clear down
		System.timing.pauseState = 0
		System.timing.pauseMark = 0
		System.timing.pauseElapsed = 0
	endif
	
	if System.timing.pauseState = 0 and oldPause = 1
		//pause ended, resume all updates but keep the elapsed time available for paused updates to adjust against elapsed times.
		System.timing.pauseState = 2
		System.mouse.moveX = 0.0
		System.mouse.moveY = 0.0
		System.mouse.moveZ = 0.0
	endif
		
endfunction


function System_log(rSource as string, rLevel as integer, rChannel as string, rContent as string)
	if rLevel >= System.log.includeLevel
		if System.log.includeChannels = "*" or FindString(System.log.includeChannels, "|" + rChannel + "|") > 0
			WriteLine(System.log.fileNumber, PadRight(System_printfRuntime(), 9) + " | " + PadRight(Left(rSource, 15), 15) + " | " + PadRight(Str(rLevel), 5) + " | " + PadRight(Left(rChannel, 10), 10) + " | " + rContent)
		endif
	endif
endfunction


function System_printfRuntime()
	e as string
	h = 0
	m = 0
	s = 0
	t = System.timing.timer
	while t > 3600000
		inc h
		dec t, 3600000
	endwhile
	while t > 60000
		inc m
		dec t, 60000
	endwhile
	while t > 1000
		inc s
		dec t, 1000
	endwhile
	e = Str(h) + ":" + Str(m) + ":" + Str(s) + ":" + Str(t)
endfunction e


function System_getHardwareInput()
	
	System.input[ENUM_KEY_MOUSEL] = SetBit(2, System.input[ENUM_KEY_MOUSEL], GetBit(1, System.input[ENUM_KEY_MOUSEL]))
	System.input[ENUM_KEY_MOUSEL] = SetBit(1, System.input[ENUM_KEY_MOUSEL], GetRawMouseLeftState())

	System.input[ENUM_KEY_MOUSER] = SetBit(2, System.input[ENUM_KEY_MOUSER], GetBit(1, System.input[ENUM_KEY_MOUSER]))
	System.input[ENUM_KEY_MOUSER] = SetBit(1, System.input[ENUM_KEY_MOUSER], GetRawMouseRightState())

	for i = 3 to System.input.length
		System.input[i] = SetBit(2, System.input[i], GetBit(1, System.input[i]))
		System.input[i] = SetBit(1, System.input[i], GetRawKeyState(i))
	next i

	oX = System.mouse.posX
	oY = System.mouse.posY
	System.mouse.posX = GetRawMouseX()
	System.mouse.posY = GetRawMouseY()
	System.mouse.moveX = oX - System.mouse.posX
	System.mouse.moveY = oY - System.mouse.posY
	System.mouse.moveZ = GetRawMouseWheelDelta() 
	
	//TODO: touch input, sensor input
endfunction


function System_setInterval(rCallback as string, rArgs as string, rTicks as integer, rInterval as integer, rTarget as string)
	tInterval as CLASS_SystemInterval
	tInterval.id = Sha256(Str(System.timing.timer) + rCallback + rTarget + rArgs + Str(rTicks) + Str(rInterval))
	tInterval.target = rTarget
	tInterval.mark = System.timing.timer
	tInterval.interval = rInterval
	tInterval.doneTicks = 0
	tInterval.maxTicks = rTicks
	tInterval.callback = rCallback
	tInterval.args = rArgs
	System.intervalList.insert(tInterval)
endfunction tInterval.id


function System_clearInterval(rID as string)
	for i = 0 to System.intervalList.length
		if System.intervalList[i].id = rID
			System.intervalList.remove(i)
			exitfunction
		endif
	next i
endfunction


function System_getInterval(rCallback as string, rTarget as string)
	for i = 0 to System.intervalList.length
		if System.intervalList[i].callback = rCallback and System.intervalList[i].target = rTarget
			exitfunction i
		endif
	next i	
endfunction -1


function System_updateIntervals()
	GCcount = 0
	GCindex = -1
	tArrCount = System.intervalList.length
	if tArrCount > -1
		for i = 0 to tArrCount
			if System.timing.timer - (System.intervalList[i].mark + System.timing.pauseElapsed) >= System.intervalList[i].interval
				System.intervalList[i].mark = System.timing.timer
				inc System.intervalList[i].doneTicks
				App_callFunction(System.intervalList[i].callback, Str(i) + "," + System.intervalList[i].args)
				if System.intervalList[i].maxTicks > -1
					if System.intervalList[i].doneTicks >= System.intervalList[i].maxTicks
						System.intervalList[i].id = "GC_THIS"
						inc GCcount
						GCindex = i
					endif
				endif
			endif
		next i
		if GCcount > 0
			if GCcount > 1
				for c = 1 to GCcount
					for i = 0 to System.intervalList.length
						if System.intervalList[i].id = "GC_THIS"
							System.intervalList.remove(i)
							exit
						endif
					next i
				next c
			else
				System.intervalList.remove(GCindex)
			endif
		endif
	endif
endfunction

/*
	-------------------------------------------------------------------------------------
	Standard Constants
	-------------------------------------------------------------------------------------
	Author: Josh Kirklin (Ortu)
	-------------------------------------------------------------------------------------
	Contributors:
	-------------------------------------------------------------------------------------

	Description:

		Define common generic constants that can be used to manage raw values by more easily readable names.

	*******************************************

	Notes:



*/

type keyValueData
	key as string
	value as string
endtype

#CONSTANT TRUE 1
#CONSTANT FALSE 0

#CONSTANT NEWLINE chr$(13)+chr$(10)

#CONSTANT ENUM_KEY_ESC 27
#CONSTANT ENUM_KEY_F1 112
#CONSTANT ENUM_KEY_F2 113
#CONSTANT ENUM_KEY_F3 114
#CONSTANT ENUM_KEY_F4 115
#CONSTANT ENUM_KEY_F5 116
#CONSTANT ENUM_KEY_F6 117
#CONSTANT ENUM_KEY_F7 118
#CONSTANT ENUM_KEY_F8 119
//#CONSTANT ENUM_KEY_F9 
//#CONSTANT ENUM_KEY_F10 
//#CONSTANT ENUM_KEY_F11 
//#CONSTANT ENUM_KEY_F12 
//#CONSTANT ENUM_KEY_PRINT 
#CONSTANT ENUM_KEY_SCROLL 145
//#CONSTANT ENUM_KEY_PAUSE 
#CONSTANT ENUM_KEY_TILDE 192
#CONSTANT ENUM_KEY_0 48
#CONSTANT ENUM_KEY_1 49
#CONSTANT ENUM_KEY_2 50
#CONSTANT ENUM_KEY_3 51
#CONSTANT ENUM_KEY_4 52
#CONSTANT ENUM_KEY_5 53
#CONSTANT ENUM_KEY_6 54
#CONSTANT ENUM_KEY_7 55
#CONSTANT ENUM_KEY_8 56
#CONSTANT ENUM_KEY_9 57
#CONSTANT ENUM_KEY_DASH 189
#CONSTANT ENUM_KEY_EQUAL 187
#CONSTANT ENUM_KEY_BACKSPACE 8
#CONSTANT ENUM_KEY_TAB 9
#CONSTANT ENUM_KEY_Q 81
#CONSTANT ENUM_KEY_W 87
#CONSTANT ENUM_KEY_E 69
#CONSTANT ENUM_KEY_R 82
#CONSTANT ENUM_KEY_T 84
#CONSTANT ENUM_KEY_Y 89
#CONSTANT ENUM_KEY_U 85
#CONSTANT ENUM_KEY_I 73
#CONSTANT ENUM_KEY_O 79
#CONSTANT ENUM_KEY_P 80
#CONSTANT ENUM_KEY_BRACKETL 219
#CONSTANT ENUM_KEY_BRACKETR 221
#CONSTANT ENUM_KEY_BACKSLASH 220
//#CONSTANT ENUM_KEY_CAPSLOCK 
#CONSTANT ENUM_KEY_A 65
#CONSTANT ENUM_KEY_S 83
#CONSTANT ENUM_KEY_D 68
#CONSTANT ENUM_KEY_F 70
#CONSTANT ENUM_KEY_G 71
#CONSTANT ENUM_KEY_H 72
#CONSTANT ENUM_KEY_J 74
#CONSTANT ENUM_KEY_K 75
#CONSTANT ENUM_KEY_L 76
#CONSTANT ENUM_KEY_COLON 186
#CONSTANT ENUM_KEY_QUOTE 222
#CONSTANT ENUM_KEY_ENTER 13
#CONSTANT ENUM_KEY_SHIFTL 16
#CONSTANT ENUM_KEY_Z 90
#CONSTANT ENUM_KEY_X 88
#CONSTANT ENUM_KEY_C 67
#CONSTANT ENUM_KEY_V 86
#CONSTANT ENUM_KEY_B 66
#CONSTANT ENUM_KEY_N 78
#CONSTANT ENUM_KEY_M 77
#CONSTANT ENUM_KEY_COMMA 188
#CONSTANT ENUM_KEY_PERIOD 190
#CONSTANT ENUM_KEY_SLASH 191
#CONSTANT ENUM_KEY_SHIFTR 16
#CONSTANT ENUM_KEY_CTRLL 17
#CONSTANT ENUM_KEY_ALTL 18
#CONSTANT ENUM_KEY_SPACE 32
#CONSTANT ENUM_KEY_ALTR 18
#CONSTANT ENUM_KEY_MENU 93
#CONSTANT ENUM_KEY_CTRLR 17
#CONSTANT ENUM_KEY_INSERT 45
#CONSTANT ENUM_KEY_DELETE 46
#CONSTANT ENUM_KEY_HOME 36
#CONSTANT ENUM_KEY_END 35
#CONSTANT ENUM_KEY_PAGEUP 33
#CONSTANT ENUM_KEY_PAGEDOWN 34
#CONSTANT ENUM_KEY_ARROWUP 38
#CONSTANT ENUM_KEY_ARROWDOWN 40
#CONSTANT ENUM_KEY_ARROWLEFT 37
#CONSTANT ENUM_KEY_ARROWRIGHT 39
//#CONSTANT ENUM_KEY_NUMLOCK 
#CONSTANT ENUM_KEY_NUMDIV 192
#CONSTANT ENUM_KEY_NUMMUL 106
#CONSTANT ENUM_KEY_NUMSUB 189
#CONSTANT ENUM_KEY_NUMADD 107
#CONSTANT ENUM_KEY_NUMENTER 13
#CONSTANT ENUM_KEY_NUMDECIMAL 190
#CONSTANT ENUM_KEY_NUM0 48
#CONSTANT ENUM_KEY_NUM1 49
#CONSTANT ENUM_KEY_NUM2 50
#CONSTANT ENUM_KEY_NUM3 51
#CONSTANT ENUM_KEY_NUM4 52
#CONSTANT ENUM_KEY_NUM5 53
#CONSTANT ENUM_KEY_NUM6 54
#CONSTANT ENUM_KEY_NUM7 55
#CONSTANT ENUM_KEY_NUM8 56
#CONSTANT ENUM_KEY_NUM9 57

#CONSTANT ENUM_KEY_MOUSEL 1
#CONSTANT ENUM_KEY_MOUSER 2


function GetBit(rBit as integer, rData as integer)
endfunction (%1 << rBit) && rData


function SetBit(rBit as integer, rData as integer, rVal as integer)
	if rVal
		rData = rData || (%1 << rBit)
	else
		if (%1 << rBit) && rData > 0
			rData = rData ~~ (%1 << rBit)
		endif
	endif
endfunction rData


function GetByte(rByte as integer, rData as integer)
endfunction (rData >> (rByte * 8)) && 0xff


function SetByte(rByte as integer, rData as integer, rVal as integer)
endfunction rData || (rVal << (rByte * 8))


function PadRight(rContent as string, rCount as integer)
	while Len(rContent) < rCount
		rContent = rContent + " "
	endwhile
endfunction rContent


function PadLeft(rContent as string, rCount as integer)
	while Len(rContent) < rCount
		rContent = " " + rContent
	endwhile
endfunction rContent


function HexToByte(rHex as string)
	tVal = 0
	select left(lower(rHex), 1)
		case "0": inc tVal, 0 : endcase
		case "1": inc tVal, 16 : endcase
		case "2": inc tVal, 32 : endcase
		case "3": inc tVal, 48 : endcase
		case "4": inc tVal, 64 : endcase
		case "5": inc tVal, 80 : endcase
		case "6": inc tVal, 96 : endcase
		case "7": inc tVal, 112 : endcase
		case "8": inc tVal, 128 : endcase
		case "9": inc tVal, 144 : endcase
		case "a": inc tVal, 160 : endcase
		case "b": inc tVal, 176 : endcase
		case "c": inc tVal, 192 : endcase
		case "d": inc tVal, 208 : endcase
		case "e": inc tVal, 224 : endcase
		case "f": inc tVal, 240 : endcase
	endselect
	select right(lower(rHex), 1)
		case "0": inc tVal, 0 : endcase
		case "1": inc tVal, 1 : endcase
		case "2": inc tVal, 2 : endcase
		case "3": inc tVal, 3 : endcase
		case "4": inc tVal, 4 : endcase
		case "5": inc tVal, 5 : endcase
		case "6": inc tVal, 6 : endcase
		case "7": inc tVal, 7 : endcase
		case "8": inc tVal, 8 : endcase
		case "9": inc tVal, 9 : endcase
		case "a": inc tVal, 10 : endcase
		case "b": inc tVal, 11 : endcase
		case "c": inc tVal, 12 : endcase
		case "d": inc tVal, 13 : endcase
		case "e": inc tVal, 14 : endcase
		case "f": inc tVal, 15 : endcase
	endselect	
endfunction tVal


function ParseColor(rValue as string)
	res as integer
	valFirstChar as string
	valR as string
	valG as string
	valB as string
	valLen as integer
	valFirstChar = left(rValue, 1)
	valLen = len(rValue)
	if valFirstChar = "#"
		if valLen = 4
			//short form hex #000
			valR = mid(rValue, 2, 1)
			valG = mid(rValue, 3, 1)
			valB = mid(rValue, 4, 1)
			res = MakeColor(HexToByte(valR + valR), HexToByte(valG + valG), HexToByte(valB + valB))
		else
			if valLen = 7
				//rgb hex #000000
				valR = mid(rValue, 2, 2)
				valG = mid(rValue, 4, 2)
				valB = mid(rValue, 6, 2)
				res = MakeColor(HexToByte(valR), HexToByte(valG), HexToByte(valB))
			else
				//argb hex #ff000000
				valR = mid(rValue, 4, 2)
				valG = mid(rValue, 6, 2)
				valB = mid(rValue, 8, 2)
				res = MakeColor(HexToByte(valR), HexToByte(valG), HexToByte(valB))
			endif
		endif
	else
		if valFirstChar = "r"
			//rgb cast rgb(0, 0, 0)
			rValue = mid(rValue, 5, valLen - 5)
			valR = getStringToken2(rValue, ",", 1)
			valG = getStringToken2(rValue, ",", 2)
			valB = getStringToken2(rValue, ",", 3)
			res = MakeColor(val(valR), val(valG), val(valB))
		endif
	endif
endfunction res


function WrapValue(rMin, rMax, rVal)
	while rVal > rMax
		rVal = rVal - rMax - 1
	endwhile
	while rVal < rMin
		rVal = rMax + rVal + 1
	endwhile
endfunction rVal
 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AGKCore
{
    public static class Data
    {

        public static int GetBit(int rBit, int rData)
        {
            return Convert.ToInt32((rData & (1 << (rBit - 1))) != 0);
        }

        public static int SetBit(int rBit, int rData, int rVal)
        {
            if(rVal > 0)
            {
                rData = rData | (1 << (rBit - 1));
            }
            else if((rData & (1 << (rBit - 1))) != 0)
            {
                rData = ~(rData & (1 << (rBit - 1)));
            }
            return rData;
        }
    }
}

            Console.WriteLine("0 : bit 1:" + Data.GetBit(1, 0));
            Console.WriteLine("1 : bit 1:" + Data.GetBit(1, 1));
            Console.WriteLine("2 : bit 1:" + Data.GetBit(1, 2));
            Console.WriteLine("3 : bit 1:" + Data.GetBit(1, 3));
            Console.WriteLine("4 : bit 1:" + Data.GetBit(1, 4));
            Console.WriteLine("0 : bit 2:" + Data.GetBit(2, 0));
            Console.WriteLine("1 : bit 2:" + Data.GetBit(2, 1));
            Console.WriteLine("2 : bit 2:" + Data.GetBit(2, 2));
            Console.WriteLine("3 : bit 2:" + Data.GetBit(2, 3));
            Console.WriteLine("4 : bit 2:" + Data.GetBit(2, 4));

            int testVal = 0;
            testVal = Data.SetBit(1, testVal, 1);
            testVal = Data.SetBit(3, testVal, 1);

            Console.WriteLine(testVal.ToString() + " : bit 1:" + Data.GetBit(1, testVal));
            Console.WriteLine(testVal.ToString() + " : bit 2:" + Data.GetBit(2, testVal));
            Console.WriteLine(testVal.ToString() + " : bit 3:" + Data.GetBit(3, testVal));
            Console.WriteLine(testVal.ToString() + " : bit 4:" + Data.GetBit(4, testVal));

-- The output --
0 : bit 1:0
1 : bit 1:1
2 : bit 1:0
3 : bit 1:1
4 : bit 1:0
0 : bit 2:0
1 : bit 2:0
2 : bit 2:1
3 : bit 2:1
4 : bit 2:0
5 : bit 1:1
5 : bit 2:0
5 : bit 3:1
5 : bit 4:0

using AgkSharp;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace AGKCore
{
    public static class Hardware
    {
        public struct MouseInput
        {
            public float MoveX;
            public float MoveY;
            public float MoveZ;
            public int PosX;
            public int PosY;
        }

        public static MouseInput Mouse = new MouseInput();
        public static int[] Input = new int[255]; //bit 1 = isDown, bit 2 = wasDown
        
        public static uint MouseEnum(int rBtn)
        {
            switch (rBtn)
            {
                case 1048576:
                    return 1; //Left
                case 2097152:
                    return 2; //Right
                case 4194304:
                    return 4; //Middle
                default:
                    return 0;
            }
        }

        public static void OnMouseDown(object sender, MouseEventArgs e)
        {
            Input[MouseEnum((int)e.Button)] = Data.SetBit(2, Input[MouseEnum((int)e.Button)], Data.GetBit(1, Input[MouseEnum((int)e.Button)]));
            Input[MouseEnum((int)e.Button)] = Data.SetBit(1, Input[MouseEnum((int)e.Button)], 1);
        }

        public static void OnMouseUp(object sender, MouseEventArgs e)
        {
            Input[MouseEnum((int)e.Button)] = Data.SetBit(2, Input[MouseEnum((int)e.Button)], 0);
            Input[MouseEnum((int)e.Button)] = Data.SetBit(1, Input[MouseEnum((int)e.Button)], 0);
        }

        public static void OnMouseMove(object sender, MouseEventArgs e)
        {
            Mouse.MoveX = e.X;
            Mouse.MoveY = e.Y;
        }

        public static void OnMouseWheel(object sender, MouseEventArgs e)
        {
            Mouse.MoveZ = e.Delta;
        }

        
        public static void OnKeyDown(object sender, KeyEventArgs e)
        {
            Input[e.KeyValue] = Data.SetBit(2, Input[e.KeyValue], Data.GetBit(1, Input[e.KeyValue]));
            Input[e.KeyValue] = Data.SetBit(1, Input[e.KeyValue], 1);
        }

        public static void OnKeyUp(object sender, KeyEventArgs e)
        {
            Input[e.KeyValue] = Data.SetBit(2, Input[e.KeyValue], 0);
            Input[e.KeyValue] = Data.SetBit(1, Input[e.KeyValue], 0);
        }

    }
}

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using AgkSharp;

namespace AGKCore
{
    public static class App
    {
        static Form m_Window;
        static bool m_bMaximized = false;
        public static bool DisableEscape { get; set; } = false;

        public static AppConfig Config;
        public static AppStatus Status;

        [DllImport("user32.dll", SetLastError = true)]
        static extern bool GetKeyboardState(byte[] lpKeyState);
        [DllImport("user32.dll", SetLastError = true)]
        static extern uint MapVirtualKey(uint uCode, uint uMapType);
        [DllImport("user32.dll", SetLastError = true)]
        static extern IntPtr GetKeyboardLayout(uint idThread);
        [DllImport("user32.dll", SetLastError = true)]
        static extern int ToUnicodeEx(uint wVirtKey, uint wScanCode, byte[] lpKeyState, [Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pwszBuff, int cchBuff, uint wFlags, IntPtr dwhkl);
        [DllImport("user32.dll", SetLastError = true)]
        static extern bool PostMessage(HandleRef hWnd, uint Msg, IntPtr wParam, IntPtr lParam);

        public static Form CreateWindow(string title, int width, int height, bool fullscreen) => CreateWin32Window(title, width, height, fullscreen);

        public static Form CreateWin32Window(string title, int width, int height, bool fullscreen)
        {
            m_Window = new Form
            {
                Text = title,
                ClientSize = new Size(width, height),
                StartPosition = FormStartPosition.CenterScreen,
            };

            if (fullscreen)
            {
                m_Window.WindowState = FormWindowState.Normal;
                m_Window.FormBorderStyle = FormBorderStyle.None;
                m_Window.Bounds = Screen.PrimaryScreen.Bounds;
            }

            if (System.IO.File.Exists("icon.ico"))
                m_Window.Icon = new Icon("icon.ico");

            m_Window.MouseDown += Hardware.OnMouseDown;
            m_Window.MouseUp += Hardware.OnMouseUp;
            m_Window.MouseWheel += Hardware.OnMouseWheel;
            m_Window.MouseMove += Hardware.OnMouseMove;
            m_Window.KeyDown += Hardware.OnKeyDown;
            m_Window.KeyUp += Hardware.OnKeyUp;

            m_Window.SizeChanged += Core_OnSizeChanged;
            m_Window.Move += Core_OnMove;
            m_Window.Activated += Core_OnActivated;
            m_Window.Deactivate += Core_OnDeactivate;
            m_Window.GotFocus += Core_OnGotFocus;
            m_Window.LostFocus += Core_OnLostFocus;
            m_Window.FormClosing += Core_OnClose;

            m_Window.Show();

            return m_Window;
        }

        static void Core_OnClose(object sender, EventArgs e)
        {
            App.Status.IsRunning = false;
        }

        static void Core_OnSizeChanged(object sender, EventArgs e)
        {
            m_bMaximized = m_Window.WindowState == FormWindowState.Maximized;
            m_Window.TopMost = m_bMaximized;
            m_Window.Update();

            Agk.UpdateDeviceSize();
            Agk.WindowMoved();
        }

        static void Core_OnMove(object sender, EventArgs e)
        {
            Agk.WindowMoved();
        }

        static void Core_OnDeactivate(object sender, EventArgs e)
        {
            Agk.MouseLeftButton(0, 0);
            Agk.MouseRightButton(0, 0);
            Agk.MouseMiddleButton(0, 0);

            m_Window.TopMost = m_bMaximized;
            m_Window.Update();
            Agk.Paused();

            Agk.WindowMoved();
        }

        static void Core_OnActivated(object sender, EventArgs e)
        {
            m_Window.TopMost = m_bMaximized;
            m_Window.Update();
            Agk.Resumed();

            Agk.WindowMoved();
        }

        static void Core_OnGotFocus(object sender, EventArgs e)
        {
            Agk.WindowMoved();
        }

        static void Core_OnLostFocus(object sender, EventArgs e)
        {
            Agk.WindowMoved();
        }

        public static bool InitAGK(Form window)
        {
            if (window.Handle != null)
                Agk.InitGL(window.Handle);

            return true;
        }

        public static bool InitAGK()
        {
            if (m_Window.Handle != null)
                Agk.InitGL(m_Window.Handle);

            return true;
        }

        public static bool LoopAGK()
        {
            Application.DoEvents();

            if (Agk.IsCapturingImage() > 0)
                System.Threading.Thread.Sleep(10);

            return App.Status.IsRunning;
        }

        public static void CleanUp()
        {
            Agk.CleanUp();
        }

        public static bool Init(string[] args, string title)
        {
            App.Status.LoadState = 1;
            App.Status.LoadStage = 1;

            //config defaults
            App.Config.Log.Level = 3;
            App.Config.Log.File = System.AppDomain.CurrentDomain.BaseDirectory + "app.log";
            App.Config.Log.Channels = "*";

            App.Config.Screen.Fullscreen = true;
            App.Config.Screen.Width = 0;
            App.Config.Screen.Height = 0;
            App.Config.Screen.Vsync = true;

            //config overrides
            foreach (string arg in args)
            {
                switch (arg.Split('=').First().ToLower())
                {
                    case "sw": App.Config.Screen.Width = Convert.ToInt32(arg.Split('=').Last()); break;
                    case "sh": App.Config.Screen.Height = Convert.ToInt32(arg.Split('=').Last()); break;
                    case "fs": App.Config.Screen.Fullscreen = Convert.ToBoolean(arg.Split('=').Last()); break;
                    case "vsync": App.Config.Screen.Vsync = Convert.ToBoolean(arg.Split('=').Last()); break;
                    case "log": App.Config.Log.Level = Convert.ToInt32(arg.Split('=').Last()); break;
                    default: break;
                }
            }

            //init the screen

            if (App.Config.Screen.Width == 0)
            {
                App.Config.Screen.Width = System.Windows.Forms.SystemInformation.PrimaryMonitorSize.Width;
                App.Config.Screen.Height = System.Windows.Forms.SystemInformation.PrimaryMonitorSize.Height;
            }

            App.Config.Screen.CenterX = (int)Math.Floor(App.Config.Screen.Width * 0.5);
            App.Config.Screen.CenterY = (int)Math.Floor(App.Config.Screen.Height * 0.5);

            if (App.Config.Screen.Width > 1280)
            {
                App.Config.Screen.Layout = 1;
            }
            else {
                App.Config.Screen.Layout = 2;
            }

            App.CreateWindow(title, App.Config.Screen.Width, App.Config.Screen.Height, App.Config.Screen.Fullscreen);

            if (!App.InitAGK())
            {
                return false;
            }

            Agk.SetResolutionMode(1);
            Agk.SetOrientationAllowed(0, 0, 1, 0);
            if (!App.Config.Screen.Fullscreen)
            {
                Agk.SetWindowAllowResize(0);
            }
            Agk.SetVirtualResolution(App.Config.Screen.Width, App.Config.Screen.Height);
            Agk.SetScissor(0, 0, 0, 0);

            Agk.SetVSync(App.Config.Screen.Vsync);
            if (!App.Config.Screen.Vsync)
            {
                Agk.SetSyncRate(0, 0);
            }

            //init AGK Misc
            Agk.SetPrintSize(16.0f);
            Agk.SetPrintColor(255, 255, 255);
            Agk.SetClearColor(0, 0, 0);
            Agk.UseNewDefaultFonts(1);

            //init log
            System.IO.File.WriteAllText(App.Config.Log.File, "Timestamp    | File            | Level | Channel    | Log" + Environment.NewLine);
            System.IO.File.AppendAllText(App.Config.Log.File, "==================================================================" + Environment.NewLine);

            App.Status.IsRunning = true;

            return true;
        }

        public static void Log(string rSource, int rLevel, string rChannel, string rContent)
        {
            if(rLevel >= App.Config.Log.Level)
            {
                if(App.Config.Log.Channels == "*" || App.Config.Log.Channels.Contains("|" + rChannel + "|"))
                {
                    System.IO.File.AppendAllText(App.Config.Log.File, DateTime.Now.ToString("HH:mm:ss.fff") + " | " + rSource.PadRight(15) + " | " + rLevel.ToString().PadRight(5) + " | " + rChannel.PadRight(10) + " | " + rContent + Environment.NewLine);
                }
            }
        }

    }

    public struct AppConfig
    {
        public LogConfig Log;
        public ScreenConfig Screen;
    }

    public struct ScreenConfig
    {
        public int Width;
        public int Height;
        public int X1;
        public int Y1;
        public int X2;
        public int Y2;
        public int CenterX;
        public int CenterY;
        public int Layout;
        public bool Fullscreen;
        public bool Vsync;
    }

    public struct LogConfig
    {
        public int Level;
        public string Channels;
        public string File;
    }

    public struct AppStatus
    {
        public bool IsRunning;
        public int LoadState; //0 not loaded | 1 loading | 2 title loop (UI only) | 3 level load finished | 4 game in progress | 5 level reload/transition
        public int LoadStage; //0 init resources | 1 transition in | 2 body | 3 transition out
        public int LoadType; //0 not loading | 1 title load | 2 level load	

    }

}

using System;
using AgkSharp;
using AGKCore;
using System.Reflection;
using System.Linq;
using System.Drawing;
using System.Windows.Forms;

namespace AgkSharp_Template
{
    static class Program
    {
        [STAThread]
        static void Main(string[] args)
        {
            var attrs = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyTitleAttribute), false).FirstOrDefault() as AssemblyTitleAttribute;

            if(!App.Init(args, attrs.Title))
            {
                return;
            }

#if DEBUG
            App.Log("Program.cs", 3, "main", "> Init Complete");
#endif

            // display a background and center it
            uint bgImg = Agk.CreateSprite(Agk.LoadImage("media/background.jpg"));
            Agk.SetSpritePosition(bgImg, App.Config.Screen.CenterX - 160, App.Config.Screen.CenterY - 240);

            // create a sprite and center it
            Agk.CreateSprite(1, 0);
            Agk.SetSpritePosition(1, App.Config.Screen.CenterX - 30, App.Config.Screen.CenterY - 44);

            // add individual images into an animation list
            Agk.AddSpriteAnimationFrame(1, Agk.LoadImage("media/item0.png"));
            Agk.AddSpriteAnimationFrame(1, Agk.LoadImage("media/item1.png"));
            Agk.AddSpriteAnimationFrame(1, Agk.LoadImage("media/item2.png"));
            Agk.AddSpriteAnimationFrame(1, Agk.LoadImage("media/item3.png"));
            Agk.AddSpriteAnimationFrame(1, Agk.LoadImage("media/item4.png"));

            // play the sprite at 10 fps, looping, going from frame 1 to 5
            Agk.PlaySprite(1, 10.0f, 1, 1, 5);
           
            while (App.LoopAGK())
            {
#if DEBUG
                App.Log("Program.cs", 1, "main", "--- Begin main loop ---");
#endif

                Agk.Print(Agk.ScreenFPS());

                Agk.Print("A is down: " + Data.GetBit(1, Hardware.Input[(int)System.Windows.Forms.Keys.A]));
                Agk.Print("A was down: " + Data.GetBit(2, Hardware.Input[(int)System.Windows.Forms.Keys.A]));

                Agk.Print("Left mouse is down: " + Data.GetBit(1, Hardware.Input[Hardware.MouseEnum((int)MouseButtons.Left)]));
                Agk.Print("Left mouse was down: " + Data.GetBit(2, Hardware.Input[Hardware.MouseEnum((int)MouseButtons.Left)]));
                

                Agk.Sync();
            }

            App.CleanUp();
        }

    }
}

using System.Collections.Generic;
using System.Threading;

namespace AGKCore
{
    public static class Scheduler
    {
        public static List<Timer> Scheduled = new List<Timer>();

        public static void SetInterval()
        {
            Timer t = new Timer(App.DoStuff, null, 0, 3000);
            Scheduled.Add(t);
        }

    }

}

        public static void DoStuff(object rArgs)
        {
            MessageBox.Show("did stuff");
        }

            Agk.PlaySprite(1, 10.0f, 1, 1, 5);

            Scheduler.SetInterval();

            while (App.LoopAGK())
            {
#if DEBUG
                App.Log("Program.cs", 1, "main", "--- Begin main loop ---");
#endif

using System.Collections.Generic;
using System.Threading;

namespace AGKCore
{
    public static class Scheduler
    {
        public static List<TimerState> Scheduled = new List<TimerState>();

        public static void SetInterval(TimerCallback rCallback, string rArgs, int rTicks, int rInterval, int rDelay, string rTarget)
        {
            TimerState ts = new TimerState
            {
                Callback = rCallback.ToString(),
                Args = rArgs,
                Target = rTarget,
                MaxTicks = rTicks,
                DoneTicks = 1
            };

            rCallback += TickInterval;
            Timer t = new Timer(rCallback, ts, rDelay, rInterval);
            ts.Timer = t;
            Scheduled.Add(ts);

#if DEBUG
            App.Log("Scheduler.cs", 2, "main", " > Set new timer: " + rCallback.ToString() + " | " + rArgs + " | " + rTicks.ToString() + " ticks @ " + rInterval.ToString() + " ms, delay: " + rDelay.ToString());
#endif
        }

        public static void TickInterval(object sender)
        {
            TimerState ts = (TimerState)sender;
            var i = Scheduled.IndexOf(ts);
            ++Scheduled[i].DoneTicks;

#if DEBUG
            App.Log("Scheduler.cs", 1, "main", " > Ticked timer: " + Scheduled[i].Callback + " | " + Scheduled[i].Args + " | " + Scheduled[i].DoneTicks.ToString() + "/" + Scheduled[i].MaxTicks.ToString());
#endif

            if (Scheduled[i].MaxTicks > -1 && Scheduled[i].DoneTicks > Scheduled[i].MaxTicks)
            {
#if DEBUG
                App.Log("Scheduler.cs", 2, "main", "    Timer complete, disposing.");
#endif
                Scheduled.RemoveAt(i);
                ts.Timer.Dispose();
            }
        }

        public class TimerState
        {
            public Timer Timer;
            public string Callback;
            public string Args;
            public string Target;
            public int MaxTicks;
            public int DoneTicks;
        }

    }

}

        public static void DoStuff(object sender)
        {
            TimerState ts = (TimerState)sender;
            var i = Scheduled.IndexOf(ts);
            MessageBox.Show(Scheduled[i].Args + " #" + Scheduled[i].DoneTicks.ToString());
        }

            Agk.PlaySprite(1, 10.0f, 1, 1, 5);

            Scheduler.SetInterval(App.DoStuff, "Showing popup", 3, 3000, 5000, null);

            while (App.LoopAGK())
            {
#if DEBUG
                App.Log("Program.cs", 1, "main", "--- Begin main loop ---");
#endif

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Threading;

namespace AGKCore
{
    public static class Scheduler
    {
        public static List<TimerState> Scheduled = new List<TimerState>();

        public static void SetInterval(TimerCallback rCallback, string rArgs, int rTicks, int rInterval, int rDelay, string rTarget)
        {
            TimerState ts = new TimerState
            {
                Callback = rCallback,
                Args = rArgs,
                Target = rTarget,
                MaxTicks = rTicks,
                DoneTicks = 0
            };

            Timer t = new Timer(TickInterval, ts, rDelay, rInterval);
            ts.Timer = t;
            Scheduled.Add(ts);
        }

        public static void TickInterval(object sender)
        {
            TimerState ts = (TimerState)sender;
            var i = Scheduled.IndexOf(ts);
            ++Scheduled[i].DoneTicks;

            bool isDone = Scheduled[i].MaxTicks > -1 && Scheduled[i].DoneTicks >= Scheduled[i].MaxTicks;
            if (isDone)
            {
                Scheduled[i].Timer.Dispose();
            }

            Scheduled[i].Callback.DynamicInvoke(sender);

            if (isDone)
            {
                i = Scheduled.IndexOf(ts); //list may have changed, have to relocate this timer before removing it.
                Scheduled.RemoveAt(i);
            }
        }

        public class TimerState
        {
            public Timer Timer;
            public Delegate Callback;
            public string Args;
            public string Target;
            public int MaxTicks;
            public int DoneTicks;
        }

    }

}

            Scheduler.SetInterval(App.DoStuff, "Showing popup", 3, 3000, 5000, "blahblah");
            Scheduler.SetInterval(App.DoStuff, "Showing alternate", 3, 3000, 5500, null);
            
            var s = Scheduler.Scheduled.FirstOrDefault(el => el.Name == "App.DoStuff" && el.Target == "blahblah");
            s.Timer.Dispose();
            Scheduler.Scheduled.Remove(s);
            
            while (App.LoopAGK())
            {
#if DEBUG
                App.Log("Program.cs", 1, "main", "--- Begin main loop ---");
#endif 

using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Reflection;
using System.Threading;

namespace AGKCore
{
    public static class Scheduler
    {
        public static List<TimerState> Scheduled = new List<TimerState>();

        public static void SetInterval(TimerCallback rCallback, string rArgs, int rTicks, int rInterval, int rDelay, string rTarget)
        {
            TimerState ts = new TimerState
            {
                Callback = rCallback,
                Name = rCallback.GetMethodInfo().DeclaringType.Name + "." + rCallback.GetMethodInfo().Name,
                Args = rArgs,
                Target = rTarget,
                MaxTicks = rTicks,
                DoneTicks = 0
            };

            Timer t = new Timer(TickInterval, ts, rDelay, rInterval);
            ts.Timer = t;
            Scheduled.Add(ts);
        }

        public static void TickInterval(object sender)
        {
            TimerState ts = (TimerState)sender;
            var i = Scheduled.IndexOf(ts);
            ++Scheduled[i].DoneTicks;

            bool isDone = Scheduled[i].MaxTicks > -1 && Scheduled[i].DoneTicks >= Scheduled[i].MaxTicks;
            if (isDone)
            {
                Scheduled[i].Timer.Dispose();
            }

            Scheduled[i].Callback.DynamicInvoke(sender);

            if (isDone)
            {
                i = Scheduled.IndexOf(ts); //list may have changed, have to relocate this timer before removing it.
                Scheduled.RemoveAt(i);
            }
        }

        public class TimerState
        {
            public Timer Timer;
            public Delegate Callback;
            public string Name;
            public string Args;
            public string Target;
            public int MaxTicks;
            public int DoneTicks;
        }

    }

}

function App_callFunction(rFunctionName as string, rArgs as string)
`NOTE: this is a workaround replacement for matrix1 call function name
`	there is an odd conflict between AdvLighting and the mat1 command which causes a graphical error.

	<?System_log("main.dbx", 2, "main", "Executing callback " + rFunctionName)?>
	err = TRUE
	returnStr$ = ""

	select rFunctionName

		//TODO: build this function list via the preprocessor.

		//anim3d.dbx
		case "Anim3d_updateActiveAnimations": Anim3d_updateActiveAnimations() : err = FALSE : endcase
		case "Anim3d_clearAppliedAnimationsDeferred": Anim3d_clearAppliedAnimationsDeferred(intval(rArgs)) : err = FALSE : endcase

		//characters.dbx
		case "Characters_updateCharacterStates": Characters_updateCharacterStates() : err = FALSE : endcase
		case "CharacterEntity_addJump": CharacterEntity_addJump(rArgs) : err = FALSE : endcase
		case "CharacterEntity_resetLocomotion": CharacterEntity_resetLocomotion(intval(rArgs)) : err = FALSE : endcase
		case "CharacterEntity_setToDead" : CharacterEntity_setToDead(intval(rArgs)) : err = FALSE : endcase

`		`controls.dbx
		case "Camera_updatePhysicalState": Camera_updatePhysicalState() : err = FALSE : endcase
		case "Controls_getGameplayInput": Controls_getGameplayInput() : err = FALSE : endcase
		<?case "Controls_getDevInput": Controls_getDevInput() : err = FALSE : endcase?>

		`events
		case "Events_updateInteractableTarget": Events_updateInteractableTarget() : err = FALSE : endcase
		case "Events_setInteractableTargetState": Events_setInteractableTargetState(rArgs) : err = FALSE : endcase
		case "Events_setInteractableCollisionState": Events_setInteractableCollisionState(rArgs) : err = FALSE : endcase

		`math.dbx
		`TODO: add arc, remove arc
		case "Math3d_updateArcs": Math3d_updateArcs() : err = FALSE : endcase

		`media.dbx
		case "Media_updateBoundObjects": Media_updateBoundObjects() : err = FALSE : endcase

		`system.dbx
		case "System_updateIntervals": System_updateIntervals() : err = FALSE : endcase
		case "System_updateMetrics": System_updateMetrics() : err = FALSE : endcase
		case "System_cpuSleep": System_cpuSleep() : err = FALSE : endcase
		case "System_getHardwareInput": System_getHardwareInput() : err = FALSE : endcase
		case "System_getFileFromDialog": System_getFileFromDialog(rArgs) : err = FALSE : endcase

		`user_interface.dba
		case "UI_updatePageFlow": UI_updatePageFlow() : err = FALSE : endcase
		case "UI_getInterfaceInput": UI_getInterfaceInput() : err = FALSE : endcase
		case "UI_element_hide": UI_element_hide(rArgs) : err = FALSE : endcase

		`UI controllers
		case "UI_controller_common_doHoverByType": UI_controller_common_doHoverByType(rArgs) : err = FALSE : endcase
		case "UI_controller_common_doUnHoverByType": UI_controller_common_doUnHoverByType(rArgs) : err = FALSE : endcase
		case "UI_controller_common_doPressByType": UI_controller_common_doPressByType(rArgs) : err = FALSE : endcase
		case "UI_controller_common_doReleaseByType": UI_controller_common_doReleaseByType(rArgs) : err = FALSE : endcase
		case "UI_controller_titleMenu_resumeGame": UI_controller_titleMenu_resumeGame(rArgs) : err = FALSE : endcase
		case "UI_controller_titleMenu_newGame": UI_controller_titleMenu_newGame(rArgs) : err = FALSE : endcase
		case "UI_controller_titleMenu_newGameCreate": UI_controller_titleMenu_newGameCreate(rArgs) : err = FALSE : endcase
		case "UI_controller_titleMenu_newGameCancel": UI_controller_titleMenu_newGameCancel(rArgs) : err = FALSE : endcase
		case "UI_controller_titleMenu_loadGame": UI_controller_titleMenu_loadGame(rArgs) : err = FALSE : endcase
		case "UI_controller_titleMenu_quitGame": UI_controller_titleMenu_quitGame(rArgs) : err = FALSE : endcase

		`world.dbx
		case "World_updateEnvironment": World_updateEnvironment() : err = FALSE : endcase
		case "World_updateWeather": World_updateWeather(intval(rArgs)) : err = FALSE : endcase

	endselect

	if err = TRUE
		System_log("main.dbx", 4, "error", "ERROR: Callback function not registered: " + rFunctionName)
		App_closeGame(TRUE)
	endif

endfunction returnStr$

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Threading;

namespace AGKCore
{
    public static class StaticInvoke
    {
        private static List<Invokable> _FunctionList = new List<Invokable>();

        public static void Add(TimerCallback rCallable)
        {
            Invokable inv = new Invokable
            {
                Function = rCallable,
                Name = rCallable.GetMethodInfo().DeclaringType.Name + "." + rCallable.GetMethodInfo().Name,
            };
            _FunctionList.Add(inv);
        }

        public static object Call(string rCallable, string rArgs)
        {
            return _FunctionList.FirstOrDefault(el => el.Name == rCallable).Function.DynamicInvoke(rArgs);
        }
    }

    public class Invokable
    {
        public Delegate Function;
        public string Name;
    }
}

        public static bool Init(string[] args, string title)
        {
            StaticInvoke.Add(App.Log);
            StaticInvoke.Add(App.DoStuff);

            App.Status.LoadState = 1;
            App.Status.LoadStage = 1;

            //config defaults
            App.Config.Log.Level = 3;
            App.Config.Log.File = System.AppDomain.CurrentDomain.BaseDirectory + "app.log";
            App.Config.Log.Channels = "*";

…

        public static void Log(string rSource, int rLevel, string rChannel, string rContent)
        {
            if(rLevel >= App.Config.Log.Level)
            {
                if(App.Config.Log.Channels == "*" || App.Config.Log.Channels.Contains("|" + rChannel + "|"))
                {
                    System.IO.File.AppendAllText(App.Config.Log.File, DateTime.Now.ToString("HH:mm:ss.fff") + " | " + rSource.PadRight(15) + " | " + rLevel.ToString().PadRight(5) + " | " + rChannel.PadRight(10) + " | " + rContent + Environment.NewLine);
                }
            }
        }
        
        public static void Log(object rArgs)
        {
            dynamic a = JsonConvert.DeserializeObject<dynamic>(rArgs.ToString());
            Log(a.Source.ToString(), (int)a.Level, a.Channel.ToString(), a.Content.ToString());
        }

            Agk.PlaySprite(1, 10.0f, 1, 1, 5);

            Scheduler.SetInterval(App.DoStuff, "Showing popup", 3, 3000, 5000, "blahblah");
            Scheduler.SetInterval(App.DoStuff, "Showing alternate", 3, 3000, 5500, null);

            StaticInvoke.Call("App.Log", "{Source:\"Program.cs\", Level:3, Channel:\"!\", Content:\"Hey! called this dynamically by name.\"}");
            
            while (App.LoopAGK())
            {
#if DEBUG
                App.Log("Program.cs", 1, "main", "--- Begin main loop ---");
#endif

namespace AGKCore
{
    public static class App
    {
        static Form m_Window;
        static bool m_bMaximized = false;
        public static bool DisableEscape { get; set; } = false;

        public static AppConfig Config;
        public static AppStatus Status;
        public static TimingStatus Timing;

	…

        public static void UpdateTiming()
        {
            App.Timing.Timer = Agk.GetMilliseconds();
            App.Timing.Delta = (uint)Agk.Abs(App.Timing.Timer - App.Timing.Delta);

            int oldPause = App.Timing.PauseState;
            if(App.Timing.PauseHold == 0)
            {
                App.Timing.PauseState = 0;
            }
            else
            {
                App.Timing.PauseState = 1;
                if(oldPause == 0)
                {
                    App.Timing.PauseMark = App.Timing.Timer;
                }
                else
                {
                    App.Timing.PauseElapsed = (uint)Agk.Abs(App.Timing.Timer - App.Timing.PauseMark);
                }
            }

            if(App.Timing.PauseState == 2)
            {
                //pause ended and elapsed time has been applied, clear down
                App.Timing.PauseState = 0;
                App.Timing.PauseMark = 0;
                App.Timing.PauseElapsed = 0;
            }

            if(App.Timing.PauseState == 0 && oldPause == 1)
            {
                //pause ended, resume all updates but keep the elapsed time available for paused updates to adjust against elapsed times.
                App.Timing.PauseState = 2;
                Hardware.Mouse.MoveX = 0.0f;
                Hardware.Mouse.MoveY = 0.0f;
                Hardware.Mouse.MoveZ = 0.0f;
            }
        }
        public static void DoStuff(object rArgs)
        {
            MessageBox.Show("doing stuff");
        }

        public static void DoStuff2(object sender, KeyEventArgs e)
        {
            if(Data.GetBit(1, Hardware.Input[(int)Keys.A]) == 1)
            {
                App.Timing.PauseHold = Data.SetBit((int)TimingStatus.PauseType.Player, App.Timing.PauseHold, 1 - Data.GetBit((int)TimingStatus.PauseType.Player, App.Timing.PauseHold));
            }
        }

        public static void AddKeyDownHandler()
        {
            m_Window.KeyDown += DoStuff2;
        }
        }

    public struct TimingStatus
    {
        public uint Timer;
        public uint Delta;
        public uint UpdateMark;
        public uint PauseMark;
        public uint PauseElapsed;
        public int PauseState;
        public int PauseHold;
        public enum PauseType
        {
            None,
            System,
            UI,
            Player
        }
    }
}

        public static void TickInterval(object sender)
        {
            if(App.Timing.PauseState == 1)
            {
                return;
            }

		…

            App.AddKeyDownHandler();

            Scheduler.SetInterval(App.DoStuff, null, 10, 3000, 3000, null);

            while (App.LoopAGK())
            {
#if DEBUG
                App.Log("Program.cs", 1, "main", "--- Begin main loop ---");
#endif
                //Always update timing, and do it first
                App.UpdateTiming();

using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Reflection;
using System.Threading;

namespace AGKCore
{
    public static class Scheduler
    {
        public static List<TimerState> Scheduled = new List<TimerState>();

        public static void SetInterval(TimerCallback rCallback, string rArgs, int rTicks, int rInterval, int rDelay, string rTarget)
        {
            TimerState ts = new TimerState
            {
                Callback = rCallback,
                Name = rCallback.GetMethodInfo().DeclaringType.Name + "." + rCallback.GetMethodInfo().Name,
                Args = rArgs,
                Target = rTarget,
                MaxTicks = rTicks,
                Interval = rInterval,
                DoneTicks = 0
            };

            Timer t = new Timer(TickInterval, ts, rDelay, rInterval);
            ts.Timer = t;
            Scheduled.Add(ts);
        }

        public static void TickInterval(object sender)
        {
            if(App.Timing.PauseState == 1)
            {
                return;
            }

            TimerState ts = (TimerState)sender;
            var i = Scheduled.IndexOf(ts);
            ++Scheduled[i].DoneTicks;
            ts.LastTick = App.Timing.Timer;

            if (App.Timing.PauseState == 2)
            {
                if(App.Timing.Timer < ts.LastTick + ts.Interval + App.Timing.PauseElapsed)
                {
                    return;
                }
            }

            bool isDone = Scheduled[i].MaxTicks > -1 && Scheduled[i].DoneTicks >= Scheduled[i].MaxTicks;
            if (isDone)
            {
                Scheduled[i].Timer.Dispose();
            }

            Scheduled[i].Callback.DynamicInvoke(sender);

            if (isDone)
            {
                i = Scheduled.IndexOf(ts); //list may have changed, have to relocate this timer before removing it.
                Scheduled.RemoveAt(i);
            }
        }

        public class TimerState
        {
            public Timer Timer;
            public Delegate Callback;
            public string Name;
            public string Args;
            public string Target;
            public int MaxTicks;
            public int DoneTicks;
            public int Interval;
            public uint LastTick;
        }

    }

}

//Main Loop -------------------------------------------------------------------

while App.status.isRunning
	
	App.debug = ""
	
	//Always update timing, and do it first
	System_updateTiming()
	
	if App.status.loadState > 1
	
		//Always get raw input if not loading
		System_getHardwareInput()
	
		//Title Menu Loop ---(process UI only) ---
		
		if App.status.loadState = 2
			System_updateIntervals()
			UI_updatePageFlow()
			UI_getInterfaceInput()
			if App.status.loadState = 2
				Sync()
			endif
		endif
		
		//Transition Load Out -----------------------
		
		if App.status.loadState = 3
			//STUB: music handling
		endif
		
		//Standard Gameplay Loop -----------------------------

		if App.status.loadState >= 3
			
			for i = 0 to App.updateQueue.length
				if System.timing.pauseState <> 1 or App.updateQueue[i].ignorePause
					res = App_callFunction(App.updateQueue[i].functionName, "")
				endif
			next i
			
			//temp debugging
				PrintC( "FPS: " ) : Print( ScreenFPS() )
			//end temp debugging
			
			Sync()			
			
		endif

		//Transition Load In ------------------------
		
		if App.status.loadState = 5
			App.status.loadState = 1
			App.status.loadType = 2
			App.status.loadStage = 0
			App_updateSplashScreen("- Initializing Level")
			
			DrawBox(-10, -10, App.config.screenWidth + 10, App.config.screenHeight + 10, MakeColor(20, 20, 20), MakeColor(20, 20, 20), MakeColor(20, 20, 20), MakeColor(20, 20, 20), 1)
			//TODO: draw splash screen
			Sync()
			//TODO: music
			//TODO: load scene			
			App.status.loadStage = 3
			App_updateSplashScreen(" - Finishing")
			
		endif
    
	endif
    
    //allow escape
    if getrawkeystate(ENUM_KEY_ESC) then end
    
endwhile

end

			for i = 0 to App.updateQueue.length
				if System.timing.pauseState <> 1 or App.updateQueue[i].ignorePause
					res = App_callFunction(App.updateQueue[i].functionName, "")
				endif
			next i

			//temp debugging
				PrintC( "FPS: " ) : Print( ScreenFPS() )
			//end temp debugging
			
			Sync()	

function App_addUpdate(rName as string, rRequired as string, rPauseIgnore as integer)
	tUpdate as App_type_updateHandlerData
	tUpdate.functionName = rName
	tUpdate.required = rRequired
	tUpdate.ignorePause = rPauseIgnore
	App.updateList.insert(tUpdate)
endfunction


function App_addRequiredToUpdate(rName as string, rRequired as string)
	for i = 0 to App.updateList.length
		if App.updateList[i].functionName = rName
			if App.updateList[i].required <> ""
				App.updateList[i].required = App.updateList[i].required + "," + rRequired
			else
				App.updateList[i].required = rRequired
			endif
			exitfunction
		endif
	next i
endfunction


function App_sortUpdateQueue()
	App.updateQueue.length = -1
	GCcount = 0
	GCindex = -1
	for i = 0 to App.updateList.length
		if App.updateList[i].required = ""
			App.updateQueue.insert(App.updateList[i])
			App.updateList[i].required = "GC_THIS"
			inc GCcount
			GCindex = i
		endif
	next i
	if GCcount > 0
		if GCcount > 1
			for c = 1 to GCcount
				for i = 0 to App.updateList.length
					if App.updateList[i].required = "GC_THIS"
						App.updateList.remove(i)
						exit
					endif
				next i
			next c
		else
			App.updateList.remove(GCindex)
		endif
	endif
	
	req as string
	while App.updateList.length > -1
		for i = 0 to App.updateList.length
			okCount = 0
			reqCount = CountStringTokens2(App.updateList[i].required, ",")
			for r = 1 to reqCount
				req = GetStringToken2(App.updateList[i].required, ",", r)
				for c = 0 to App.updateQueue.length
					if App.updateQueue[c].functionName = req
						inc okCount
					endif
				next c
			next r
			
			if okCount = reqCount
				App.updateQueue.insert(App.updateList[i])
				GCindex = i
				exit
			endif
		next i
		App.updateList.remove(GCindex)
	endwhile
endfunction

    public class UpdateHandler
    {
        public bool IgnorePause;
        public string FunctionName;
        public string Required;

        public UpdateHandler(string rName, string rRequired, bool rIgnore)
        {
            FunctionName = rName;
            Required = rRequired;
            IgnorePause = rIgnore;
        }

        public void Run()
        {
            var res = StaticInvoke.Call(this.FunctionName, null);
        }

        public static void AddRequiredToUpdate(string rName, string rRequired)
        {
            var tUpdate = App.UpdateList.FirstOrDefault(u => u.FunctionName == rName);
            if (String.IsNullOrEmpty(tUpdate.Required))
            {
                tUpdate.Required = rRequired;
            }
            else
            {
                tUpdate.Required += "," + rRequired;
            }
        }

        public static void SortUpdateList()
        {
#if DEBUG
            App.Log("Core.cs", 2, "main", "Begin sorting update queue");
#endif            
            var updateQueue = new List<UpdateHandler>();
            for (int i = App.UpdateList.Count - 1; i >= 0; i--)
            {
                if (String.IsNullOrEmpty(App.UpdateList[i].Required))
                {
#if DEBUG
                    App.Log("Core.cs", 2, "main", "> moved " + App.UpdateList[i].FunctionName + " to queue");
#endif
                    updateQueue.Add(App.UpdateList[i]);
                    App.UpdateList.RemoveAt(i);
                }
            }
#if DEBUG
            App.Log("Core.cs", 2, "main", "  finished updates without requirements. " + App.UpdateList.Count.ToString() + " remain");
#endif
            while (App.UpdateList.Count > 0)
            {
                for(int i = 0; i < App.UpdateList.Count; i++)
                {
                    var req = App.UpdateList[i].Required.Split(',');
                    int okCount = 0;
                    int reqCount = req.Length;
                    foreach(var r in req)
                    {
                        foreach(var u in updateQueue)
                        {
                            if(u.FunctionName == r)
                            {
                                ++okCount;
                            }
                        }
                    }

                    if(okCount == reqCount)
                    {
#if DEBUG
                        App.Log("Core.cs", 2, "main", "> moved " + App.UpdateList[i].FunctionName + " to queue");
#endif
                        updateQueue.Add(App.UpdateList[i]);
                        App.UpdateList.RemoveAt(i);
                        break;
                    }
                }
            }

            App.UpdateList = new List<UpdateHandler>(updateQueue);
#if DEBUG
            App.Log("Core.cs", 2, "main", "End sorting update queue");
#endif     
        }

    }

    public static class App
    {
        static Form m_Window;
        static bool m_bMaximized = false;
        public static bool DisableEscape { get; set; } = false;

        public static AppConfig Config;
        public static AppStatus Status;
        public static TimingStatus Timing;
        public static List<UpdateHandler> UpdateList = new List<UpdateHandler>();

	…
        public static bool Init(string[] args, string title)
        {
	…
            //init log
            System.IO.File.WriteAllText(App.Config.Log.File, "Timestamp    | File            | Level | Channel    | Log" + Environment.NewLine);
            System.IO.File.AppendAllText(App.Config.Log.File, "==================================================================" + Environment.NewLine);

            //temp
            App.UpdateList.Add(new UpdateHandler("update1", null, false));
            App.UpdateList.Add(new UpdateHandler("update2", "update1,update3", false));
            App.UpdateList.Add(new UpdateHandler("update3", "update1", false));
            App.UpdateList.Add(new UpdateHandler("update4", null, true));

            //finish up
            UpdateHandler.SortUpdateList();
            foreach(var u in App.UpdateList)
            {
                Console.WriteLine(u.FunctionName + " : " + u.Required);
            }

            App.Status.IsRunning = true;
            return true;
        }

            while (App.LoopAGK())
            {
#if DEBUG
                App.Log("Program.cs", 1, "main", "--- Begin main loop ---");
#endif
                //Always update timing, and do it first
                App.UpdateTiming();

                foreach(var u in App.UpdateList)
                {
                    if(App.Timing.PauseState != 1 || u.IgnorePause)
                    {
                        u.Run();
                    }
                }

using AgkSharp;
using System;
using System.Collections.Generic;

namespace AGKCore
{
    public static class Media
    {
        public static List<ImageAsset> ImageList = new List<ImageAsset>();

        public static ImageAsset GetImageAsset(string rFilename, float rScaleX, float rScaleY)
        {
#if DEBUG
            App.Log("Media.cs", 2, "media", "Requested image: " + rFilename + " " + rScaleX.ToString() + " " + rScaleY.ToString());
#endif  
            foreach (var i in Media.ImageList)
            {
                if(i.File == rFilename)
                {
                    if(i.ScaleX == rScaleX && i.ScaleY == rScaleY)
                    {
                        if (Agk.GetImageExists(i.Number) == 1)
                        {
#if DEBUG
                            App.Log("Media.cs", 2, "media", " > found image on " + i.Number.ToString());
#endif  
                            return i;
                        }
                        else
                        {
#if DEBUG
                            App.Log("Media.cs", 2, "media", " > found image on " + i.Number.ToString() + "but is not valid: reload it");
#endif  
                            if (Agk.GetFileExists(rFilename) == 1)
                            {
                                i.Number = Agk.LoadImageResized(rFilename, rScaleX, rScaleY, 0);
                                return i;
                            }
                        }
                    }
                }
            }

            if (Agk.GetFileExists(rFilename) == 1)
            {
#if DEBUG
                App.Log("Media.cs", 2, "media", " > image not loaded: load it");
#endif  
                var tImg = Agk.LoadImageResized(rFilename, rScaleX, rScaleY, 0);
                var i = new ImageAsset(){
                    Number = tImg,
                    File = rFilename,
                    ScaleX = rScaleX,
                    ScaleY = rScaleY
                };
                Media.ImageList.Add(i);
                return i;
            }
            else
            {
                if (rFilename.Contains("media"))
                {
                    //if filename does not include the media folder, we are looking for a generated sprite color image, just return null and keep running
                    //if filename does include media folder, the file is not found and we got problems.
#if DEBUG
                    App.Log("Media.cs", 5, "error", "ERROR: File not found: " + rFilename + " on Media.GetImageAsset");
#endif  
                    App.StopRunning(true);
                }
            }

            return null;
        }

        public static ImageAsset MakeColorImage(uint rSizeX, uint rSizeY, uint rColor1, uint rColor2, uint rColor3, uint rColor4, int rFill)
        {
            string tName = rSizeX.ToString() + "," + rSizeY.ToString() + "," + rColor1.ToString() + "," + rColor2.ToString() + "," + rColor3.ToString() + "," + rColor4.ToString() + "," + rFill.ToString();

            var tImg = Media.GetImageAsset(tName, 1.0f, 1.0f);
            if (tImg != null)
            {
                return tImg;
            }

            Agk.Swap();
            Agk.DrawBox(0, 0, rSizeX, rSizeY, rColor1, rColor2, rColor3, rColor4, rFill);
            Agk.Render();
            var tNum = Agk.GetImage(0, 0, rSizeX, rSizeY);
            Agk.ClearScreen();
            Agk.Swap();
#if DEBUG
            App.Log("Media.cs", 2, "media", " > made image from color");
#endif  
            tImg = new ImageAsset()
            {
                Number = tNum,
                File = tName,
                ScaleX = 1.0f,
                ScaleY = 1.0f
            };
            Media.ImageList.Add(tImg);
            return tImg;
        }

        public static void UnloadAllImageAssets()
        {
            foreach(var i in Media.ImageList)
            {
                Agk.DeleteImage(i.Number);
            }
            Media.ImageList.Clear();
        }
        
    }

    public class MediaAsset
    {
        public uint Number;
        public string File;
    }

    public class ImageAsset : MediaAsset
    {
        public float ScaleX;
        public float ScaleY;

        public void UnloadAsset()
        {
            Media.ImageList.Remove(this);
            Agk.DeleteImage(this.Number);
        }
    }

}

        public static void StopRunning(bool rError)
        {
            App.Log("Core.cs", 255, "!", "Program end. Error: " + rError.ToString());
            if (rError)
            {
                MessageBox.Show("The application has encountered an error.\r\nCheck the log for details.");
            }
            App.Status.IsRunning = false;
        }

            while (App.LoopAGK())
            {
#if DEBUG
                App.Log("Program.cs", 1, "main", "--- Begin main loop ---");
#endif
                //Always update timing, and do it first
                App.UpdateTiming();

                foreach(var u in App.UpdateList)
                {
                    if (!App.Status.IsRunning)
                    {
                        break;
                    }
                    if(App.Timing.PauseState != 1 || u.IgnorePause)
                    {
                        u.Run();
                    }
                }
                if (!App.Status.IsRunning)
                {
                    break;
                }

                Agk.Print(Agk.ScreenFPS());

                Agk.Sync();
            }

            App.CleanUp();

using AgkSharp;
using System;
using System.Collections.Generic;

namespace AGKCore.UI
{
    public static class UserInterface
    {

    }

    public class Element
    {

    }

    public class StyleClass
    {

    }

}

    public class BorderData
    {
        public string Size = "0px";
        public uint Color = 0x00000000;
    }

    public class SizeData
    {
        public bool IsPercent;
        public int Value;
    }

    public class StylePropertyData
    {
        //Flow Props
        public readonly string  PositionAlignH = "left";            //left|right|center
        public readonly string  PositionAlignV = "top";             //top|bottom|center
        public readonly string  Position = "relative";              //relative|absolute
        public readonly string  Top = "0px";                        //#px|#%
        public readonly string  Left = "0px";                       //#px|#%
        public readonly string  PaddingTop = "0px";                 //#px|#%
        public readonly string  PaddingBottom = "0px";              //#px|#%
        public readonly string  PaddingLeft = "0px";                //#px|#%
        public readonly string  PaddingRight = "0px";               //#px|#%
        public readonly string  Width = "100%";                     //#px|#%
        public readonly string  Height = "100%";                    //#px|#%
        public readonly BorderData BorderTop;
        public readonly BorderData BorderBottom;
        public readonly BorderData BorderLeft;
        public readonly BorderData BorderRight;
        //TODO: BorderImage
        public readonly string  MarginTop = "0px";                  //#px|#%
        public readonly string  MarginBottom = "0px";               //#px|#%
        public readonly string  MarginLeft = "0px";                 //#px|#%
        public readonly string  MarginRight = "0px";                //#px|#%
        public readonly string  MinWidth = "0px";                   //#px|#%
        public readonly string  MaxWidth = "0px";                   //#px|#%
        public readonly string  MinHeight = "0px";                  //#px|#%
        public readonly string  MaxHeight = "0px";                  //#px|#%

        //Visual Props
        public readonly uint    BackgroundColor = 0x00000000;
        public readonly uint    BackgroundOpacity = 100;            //% as 0-100
        public readonly string  BackgroundImage = "";               //filepath
        public readonly string  BackgroundRepeat = "no-repeat";     //no-repeat|repeat|repeat-x|repeat-y|cover
        public readonly string  BackgroundAlignH = "left";          //left|right|center
        public readonly string  BackgroundAlignV = "top";           //top|bottom|center
        public readonly string  Display = "visible";                //visible|hidden :: inheritable
        public readonly uint    Opacity = 100;                      //% as 0-100 :: inheritable
        public readonly uint    ZIndex = 10;                        //0 = top most, 10000 = back most :: inheritable
        public readonly string  Cursor = "default";                 // :: inheritable
        public readonly uint    Color = 0xffffffff;                 // :: inheritable
        public readonly string  Font = "Arial";                     // font name :: inheritable
        public readonly uint    FontSize = 18;                      // :: inheritable
        public readonly string  TextDecoration = "none";            //none|bold|italic|underline :: inheritable
        public readonly string  TextTransform = "none";             //upper|lower|capitalize :: inheritable
        public readonly string  TextIndent = "0px";                 //#px|#% first line indent :: inheritable
        public readonly string  TextAlignH = "left";                //left|right|center :: inheritable
        public readonly string  TextAlignV = "top";                 //top|bottom|center :: inheritable
        public readonly uint    Rotation = 0;                       //angle as 0-360 :: inheritable

        //Resolved Props
        public readonly int _FinalX;                                //final resolved px coord
        public readonly int _FinalY;
        public readonly int _FinalW;
        public readonly int _FinalH;
        public readonly int _InnerX;
        public readonly int _InnerY;
        public readonly int _InnerW;
        public readonly int _InnerH;
        public readonly int _IsResolved;
        public readonly uint _FlowPropertyEnabled;
        public readonly uint _VisualPropertyEnabled;
    }
 

    public enum FlowPropBit
    {
        PositionAlignH,
        PositionAlignV,
        Position,
        Top,
        Left,
        PaddingTop,
        PaddingBottom,
        PaddingLeft,
        PaddingRight,
        Width,
        Height,
        BorderTop,
        BorderBottom,
        BorderLeft,
        BorderRight,
        BorderImage,
        MarginTop,
        MarginBottom,
        MarginLeft,
        MarginRight,
        MinWidth,
        MaxWidth,
        MinHeight,
        MaxHeight
    }

    public enum VisualPropBit
    {
        BackgroundColor,
        BackgroundOpacity,
        BackgroundImage,
        BackgroundRepeat,
        BackgroundAlignH,
        BackgroundAlignV,
        Display,
        Opacity,
        ZIndex,
        Cursor,
        Color,
        Font,
        FontSize,
        TextDecoration,
        TextTransform,
        TextIndent,
        TextAlignH,
        TextAlignV,
        Rotation
    }

    public class StatusData
    {
        public string MouseMode; //ui|gameplay|disabled
        public string KeyMode; //ui|gameplay|disabled
        public string MouseModeForced;
        public string KeyModeForced;
        public bool InputReady;
        public uint InputMark;
        public uint LastUpdate;
    }
    public class ElementDragData
    {
        public bool IsActive;
        public int OffsetX;
        public int OffsetY;
        public UI.Element DragElement;
        public UI.Element TargetElement;
    }

    public class TransitionData
    {
        public UI.Element Element;
        public string Property;
        public string InitialValue;
        public string TargetValue;
        public uint Duration;
        public uint Start;
        public string Callback;
    }

    public static class UserInterface
    {
        public static UI.StatusData Status = new StatusData();
        public static UI.ElementDragData ElementDrag = new ElementDragData();
        public static List<UI.TransitionData> TransitionList = new List<TransitionData>();
        public static List<UI.Element> ElementList = new List<Element>();
        public static List<UI.StyleClass> StyleClassList = new List<StyleClass>();
    }

    public class Element
    {
        public string Id;
        public string Name;
        public string Tag;
        public Element Parent;
        public List<UI.StyleClass> StyleClassList = new List<StyleClass>();
        public StylePropertyData Style = new StylePropertyData();
        public StylePropertyData ResolvedStyle = new StylePropertyData();
        public string Value;
        public int ScrollX;
        public int ScrollY;
        public string OnPress; //name of callback function to execute on event
        public string OnRelease;
        public string OnMouseIn;
        public string OnMouseOut;
        public bool MouseIsOver; //mouse curser is within element bounds?
        public bool PressIsHeld; //mouseclick or hotkey press is held down?
        public uint KeyBind; //key id to act as hotkey to trigger onPress event
        public uint EnableEvents; //0 disabled | 1 enabled mouse | 2 enabled keybind | 3 enabled mouse and keybind | 4 enable drag and drop
        public uint EnableMove; //0-disabled | 1-freely drag around within parent bounds | 2-freely drag parent around within parent's parent bounds | 3-drag and drop from sockets
        public uint EnableSize; //grabbing an edge (2px?) or border will allow to resize the width/height
        public bool HoldPause; //gameplay is paused while element is visible
        public bool HoldMouseFocus; //gameplay ignores mouse input while element is visible
        public bool HoldKeyFocus; //gameplay ignores key input while element is visible
        public int SelectedIndex;
        public bool IsDirty;
    }

    public class StyleClass
    {
        public string ClassName;
        public StylePropertyData Style;
    }

    public class StylePropertyData
    {
        //Flow Props
        public string PositionAlignH { get; private set; } = "left";            //left|right|center
        public string PositionAlignV { get; private set; } = "top";             //top|bottom|center
        public string Position { get; private set; } = "relative";              //relative|absolute
        public string Top { get; private set; } = "0px";                        //#px|#%
        public string Left { get; private set; } = "0px";                       //#px|#%
        public string PaddingTop { get; private set; } = "0px";                 //#px|#%
        public string PaddingBottom { get; private set; } = "0px";              //#px|#%
        public string PaddingLeft { get; private set; } = "0px";                //#px|#%
        public string PaddingRight { get; private set; } = "0px";               //#px|#%
        public string Width { get; private set; } = "100%";                     //#px|#%
        public string Height { get; private set; } = "100%";                    //#px|#%
        public BorderData BorderTop { get; private set; }
        public BorderData BorderBottom { get; private set; }
        public BorderData BorderLeft { get; private set; }
        public BorderData BorderRight { get; private set; }
        //TODO: BorderImage
        public string MarginTop { get; private set; } = "0px";                  //#px|#%
        public string MarginBottom { get; private set; } = "0px";               //#px|#%
        public string MarginLeft { get; private set; } = "0px";                 //#px|#%
        public string MarginRight { get; private set; } = "0px";                //#px|#%
        public string MinWidth { get; private set; } = "0px";                   //#px|#%
        public string MaxWidth { get; private set; } = "0px";                   //#px|#%
        public string MinHeight { get; private set; } = "0px";                  //#px|#%
        public string MaxHeight { get; private set; } = "0px";                  //#px|#%

        //Visual Props
        public uint    BackgroundColor { get; private set; } = 0x00000000;
        public uint    BackgroundOpacity { get; private set; } = 100;            //% as 0-100
        public string  BackgroundImage { get; private set; } = "";               //filepath
        public string  BackgroundRepeat { get; private set; } = "no-repeat";     //no-repeat|repeat|repeat-x|repeat-y|cover
        public string  BackgroundAlignH { get; private set; } = "left";          //left|right|center
        public string  BackgroundAlignV { get; private set; } = "top";           //top|bottom|center
        public string  Display { get; private set; } = "visible";                //visible|hidden :: inheritable
        public uint    Opacity { get; private set; } = 100;                      //% as 0-100 :: inheritable
        public uint    ZIndex { get; private set; } = 10;                        //0 = top most, 10000 = back most :: inheritable
        public string  Cursor { get; private set; } = "default";                 // :: inheritable
        public uint    Color { get; private set; } = 0xffffffff;                 // :: inheritable
        public string  Font { get; private set; } = "Arial";                     // font name :: inheritable
        public uint    FontSize { get; private set; } = 18;                      // :: inheritable
        public string  TextDecoration { get; private set; } = "none";            //none|bold|italic|underline :: inheritable
        public string  TextTransform { get; private set; } = "none";             //upper|lower|capitalize :: inheritable
        public string  TextIndent { get; private set; } = "0px";                 //#px|#% first line indent :: inheritable
        public string  TextAlignH { get; private set; } = "left";                //left|right|center :: inheritable
        public string  TextAlignV { get; private set; } = "top";                 //top|bottom|center :: inheritable
        public uint    Rotation { get; private set; } = 0;                       //angle as 0-360 :: inheritable

        //Resolved Props
        public int _FinalX { get; private set; }                                 //final resolved px coord
        public int _FinalY { get; private set; }
        public int _FinalW { get; private set; }
        public int _FinalH { get; private set; }
        public int _InnerX { get; private set; }
        public int _InnerY { get; private set; }
        public int _InnerW { get; private set; }
        public int _InnerH { get; private set; }
        public int _IsResolved { get; private set; }
        public uint _FlowPropertyEnabled { get; private set; }
        public uint _VisualPropertyEnabled { get; private set; }

        public void SetProp(string rProp, string rValue)
        {
            switch (rProp.ToLower())
            {
                case "position-alignh":
                    PositionAlignH = rValue;
                    _FlowPropertyEnabled = Data.SetBit((int)UI.FlowPropBit.PositionAlignH, _FlowPropertyEnabled, 1);
                    break;
                case "position-alignv":
                    PositionAlignV = rValue;
                    _FlowPropertyEnabled = Data.SetBit((int)UI.FlowPropBit.PositionAlignV, _FlowPropertyEnabled, 1);
                    break;

                case "width":
                    Width = rValue;
                    _FlowPropertyEnabled = Data.SetBit((int)UI.FlowPropBit.Width, _FlowPropertyEnabled, 1);
                    break;
            }
        }

            UI.Element tElement = new UI.Element();
            tElement.Style.SetProp("Width", "100px");
            MessageBox.Show(tElement.Style.Width + " : " + Data.GetBit((int)UI.FlowPropBit.Width, tElement.Style._FlowPropertyEnabled).ToString());

    public class Element
    {
        public Element()
        {
            Style = new StylePropertyData(this);
            ResolvedStyle = new StylePropertyData(this);
        }
…

    public class StylePropertyData
    {
        dynamic Owner;
        StylePropertyData(dynamic rObject)
        {
            Owner = rObject;
        }

        public void SetProp(string rProp, string rValue)
        {
            try
            {
                //styleClass owner won't have this.
                Owner.IsDirty = true;
            }
            catch(Exception ex) { }

            switch (rProp.ToLower())
            { 
		…

function HexToByte(rHex as string)
	tVal = 0
	select left(lower(rHex), 1)
		case "0": inc tVal, 0 : endcase
		case "1": inc tVal, 16 : endcase
		case "2": inc tVal, 32 : endcase
		case "3": inc tVal, 48 : endcase
		case "4": inc tVal, 64 : endcase
		case "5": inc tVal, 80 : endcase
		case "6": inc tVal, 96 : endcase
		case "7": inc tVal, 112 : endcase
		case "8": inc tVal, 128 : endcase
		case "9": inc tVal, 144 : endcase
		case "a": inc tVal, 160 : endcase
		case "b": inc tVal, 176 : endcase
		case "c": inc tVal, 192 : endcase
		case "d": inc tVal, 208 : endcase
		case "e": inc tVal, 224 : endcase
		case "f": inc tVal, 240 : endcase
	endselect
	select right(lower(rHex), 1)
		case "0": inc tVal, 0 : endcase
		case "1": inc tVal, 1 : endcase
		case "2": inc tVal, 2 : endcase
		case "3": inc tVal, 3 : endcase
		case "4": inc tVal, 4 : endcase
		case "5": inc tVal, 5 : endcase
		case "6": inc tVal, 6 : endcase
		case "7": inc tVal, 7 : endcase
		case "8": inc tVal, 8 : endcase
		case "9": inc tVal, 9 : endcase
		case "a": inc tVal, 10 : endcase
		case "b": inc tVal, 11 : endcase
		case "c": inc tVal, 12 : endcase
		case "d": inc tVal, 13 : endcase
		case "e": inc tVal, 14 : endcase
		case "f": inc tVal, 15 : endcase
	endselect	
endfunction tVal


function ParseColor(rValue as string)
	res as integer
	valFirstChar as string
	valR as string
	valG as string
	valB as string
	valLen as integer
	valFirstChar = left(rValue, 1)
	valLen = len(rValue)
	if valFirstChar = "#"
		if valLen = 4
			//short form hex #000
			valR = mid(rValue, 2, 1)
			valG = mid(rValue, 3, 1)
			valB = mid(rValue, 4, 1)
			res = MakeColor(HexToByte(valR + valR), HexToByte(valG + valG), HexToByte(valB + valB))
		else
			if valLen = 7
				//rgb hex #000000
				valR = mid(rValue, 2, 2)
				valG = mid(rValue, 4, 2)
				valB = mid(rValue, 6, 2)
				res = MakeColor(HexToByte(valR), HexToByte(valG), HexToByte(valB))
			else
				//argb hex #ff000000
				valR = mid(rValue, 4, 2)
				valG = mid(rValue, 6, 2)
				valB = mid(rValue, 8, 2)
				res = MakeColor(HexToByte(valR), HexToByte(valG), HexToByte(valB))
			endif
		endif
	else
		if valFirstChar = "r"
			//rgb cast rgb(0, 0, 0)
			rValue = mid(rValue, 5, valLen - 5)
			valR = getStringToken2(rValue, ",", 1)
			valG = getStringToken2(rValue, ",", 2)
			valB = getStringToken2(rValue, ",", 3)
			res = MakeColor(val(valR), val(valG), val(valB))
		endif
	endif
endfunction res

        public static uint ParseColor(string rValue)
        {
            string valR;
            string valG;
            string valB;
            if(rValue[0] == '#')
            {
                if (rValue.Length == 4)
                {
                    //short form hex #000
                    valR = rValue[1].ToString();
                    valG = rValue[2].ToString();
                    valB = rValue[3].ToString();
                    return Agk.MakeColor(
                                byte.Parse(valR + valR, NumberStyles.HexNumber, CultureInfo.InvariantCulture),
                                byte.Parse(valG + valG, NumberStyles.HexNumber, CultureInfo.InvariantCulture),
                                byte.Parse(valB + valB, NumberStyles.HexNumber, CultureInfo.InvariantCulture)
                           );
                }
                else if(rValue.Length == 7)
                {
                    //rgb hex #000000
                    valR = rValue.Substring(1, 2);
                    valG = rValue.Substring(3, 2);
                    valB = rValue.Substring(5, 2);
                    return Agk.MakeColor(
                                byte.Parse(valR, NumberStyles.HexNumber, CultureInfo.InvariantCulture),
                                byte.Parse(valG, NumberStyles.HexNumber, CultureInfo.InvariantCulture),
                                byte.Parse(valB, NumberStyles.HexNumber, CultureInfo.InvariantCulture)
                           );
                }
                else
                {
                    //argb hex #00000000
                    valR = rValue.Substring(3, 2);
                    valG = rValue.Substring(5, 2);
                    valB = rValue.Substring(7, 2);
                    return Agk.MakeColor(
                                byte.Parse(valR, NumberStyles.HexNumber, CultureInfo.InvariantCulture),
                                byte.Parse(valG, NumberStyles.HexNumber, CultureInfo.InvariantCulture),
                                byte.Parse(valB, NumberStyles.HexNumber, CultureInfo.InvariantCulture)
                           );
                }
            }
            else if(rValue[0] == 'r')
            {
                rValue = rValue.Substring(4, rValue.Length - 4);
                var c = rValue.Split(',');
                {
                    return Agk.MakeColor(Convert.ToUInt32(c[0]), Convert.ToUInt32(c[1]), Convert.ToUInt32(c[2]));
                }
            }

            return 0;
        }

        public void SetProp(string rProp, string rValue)
        {
            try
            {
                //styleClass owner won't have this.
                Owner.IsDirty = true;
            }
            catch(Exception ex) { }

            if (rProp.ToLower().Contains("color"))
            {
                rValue = Data.ParseColor(rValue).ToString();
            } 

    public static class UserInterface
    {
        public static UI.StatusData Status = new StatusData();
        public static UI.ElementDragData ElementDrag = new ElementDragData();
        public static List<UI.TransitionData> TransitionList = new List<TransitionData>();
        public static List<UI.Element> ElementList = new List<Element>();
        public static List<UI.StyleClass> StyleClassList = new List<StyleClass>();

        public static void ResetResolvedStyleProps()
        {
            ElementList[0].IsDirty = false; //skip root element
            foreach(var e in ElementList)
            {
                //if parent is dirty, child also needs to be resolved
                if (e.Parent.IsDirty)
                {
                    e.IsDirty = true;
                }
                if (e.IsDirty)
                {
                    e.ResolvedStyle = new StylePropertyData(e);
                }
            }

            //root element is always = app window dimensions and provides context for all child %
            ElementList[0].ResolvedStyle.ResolveAsScreen();
        }
    }

    public class StylePropertyData
    {

	…

        public void ResolveAsScreen()
        {
            Width = App.Config.Screen.Width.ToString();
            Height = App.Config.Screen.Height.ToString();
            _FinalW = App.Config.Screen.Width;
            _FinalH = App.Config.Screen.Height;
            _InnerW = App.Config.Screen.Width;
            _InnerH = App.Config.Screen.Height;
            _FinalX = 0;
            _FinalY = 0;
            _InnerX = 0;
            _InnerY = 0;
            _IsResolved = true;
        }

    public class StylePropertyData
    {

	…

        public void ApplyInheritedStyleProps()
        {
	     //this should be applied to element.ResolvedStyle
            Display = Owner.ResolvedStyle.Display;
            Opacity = Owner.ResolvedStyle.Opacity;
            ZIndex = Owner.ResolvedStyle.ZIndex;
            Cursor = Owner.ResolvedStyle.Cursor;
            Color = Owner.ResolvedStyle.Color;
            Font = Owner.ResolvedStyle.Font;
            FontSize = Owner.ResolvedStyle.FontSize;
            TextDecoration = Owner.ResolvedStyle.TextDecoration;
            TextTransform = Owner.ResolvedStyle.TextTransform;
            TextIndent = Owner.ResolvedStyle.TextIndent;
            TextAlignH = Owner.ResolvedStyle.TextAlignH;
            TextAlignV = Owner.ResolvedStyle.TextAlignV;
            Rotation = Owner.ResolvedStyle.Rotation;
        }

    public class StylePropertyData
    {

	…

        public void ApplyStyleProps(StylePropertyData rSource)
        {
            //this should be applied to element.ResolvedStyle
            //Flow props
            if (Data.GetBit((int)UI.FlowPropBit.PositionAlignH, rSource._FlowPropertyEnabled) == 1)
            {
                PositionAlignH = rSource.PositionAlignH;
            }
            if (Data.GetBit((int)UI.FlowPropBit.PositionAlignV, rSource._FlowPropertyEnabled) == 1)
            {
                PositionAlignV = rSource.PositionAlignV;
            }

	     …

        }

        public void ResolveFlowValues()
        {
            //this should be applied to element.ResolvedStyle
            //if position is absolute, use root values as parent values;
            UI.Element parent;
            if (Position.ToLower() == "absolute")
            {
                parent = UserInterface.ElementList[0];
            }
            else
            {
                parent = Owner.Parent;
            }

            //get parent values
            int parentW = Convert.ToInt32(parent.ResolvedStyle.Width);
            int parentH = Convert.ToInt32(parent.ResolvedStyle.Height);

            int parentContentW = Convert.ToInt32(parent.ResolvedStyle._InnerW);
            int parentContentH = Convert.ToInt32(parent.ResolvedStyle._InnerH);

            int parentX = Convert.ToInt32(parent.ResolvedStyle._FinalX);
            int parentY = Convert.ToInt32(parent.ResolvedStyle._FinalY);

            int parentContentX = Convert.ToInt32(parent.ResolvedStyle._InnerX);
            int parentContentY = Convert.ToInt32(parent.ResolvedStyle._InnerY);

        public static ParsedSizeData ParseSize(string rValue)
        {
            ParsedSizeData res = new ParsedSizeData();
            if (String.IsNullOrEmpty(rValue))
            {
                rValue = "0px";
            }
            if(rValue[rValue.Length - 1] == '%')
            {
                res.IsPercent = true;
                res.Value = Convert.ToInt32(rValue.Substring(0, rValue.Length - 1));
            }
            else if (rValue[rValue.Length - 1] == 'x')
            {
                res.IsPercent = false;
                res.Value = Convert.ToInt32(rValue.Substring(0, rValue.Length - 2));
            }
            else
            {
                res.IsPercent = false;
                res.Value = Convert.ToInt32(rValue);
            }
            return res;
        }

    public struct ParsedSizeData
    {
        public bool IsPercent;
        public int Value;
    }

        public void ResolveFlowValues()
        {
            //this should be applied to element.ResolvedStyle
            //if position is absolute, use root values as parent values;
            UI.Element parent;
            if (Position.ToLower() == "absolute")
            {
                parent = UserInterface.ElementList[0];
            }
            else
            {
                parent = Owner.Parent;
            }

            //get parent values
            int parentW = Convert.ToInt32(parent.ResolvedStyle.Width);
            int parentH = Convert.ToInt32(parent.ResolvedStyle.Height);

            int parentContentW = Convert.ToInt32(parent.ResolvedStyle._InnerW);
            int parentContentH = Convert.ToInt32(parent.ResolvedStyle._InnerH);

            int parentX = Convert.ToInt32(parent.ResolvedStyle._FinalX);
            int parentY = Convert.ToInt32(parent.ResolvedStyle._FinalY);

            int parentContentX = Convert.ToInt32(parent.ResolvedStyle._InnerX);
            int parentContentY = Convert.ToInt32(parent.ResolvedStyle._InnerY);

            //get element values
            int resolvedW;
            int resolvedH;
            int resolvedContentW;
            int resolvedContentH;
            int resolvedPadT;
            int resolvedPadB;
            int resolvedPadL;
            int resolvedPadR;
            int resolvedMargT;
            int resolvedMargB;
            int resolvedMargL;
            int resolvedMargR;
            int resolvedBorderT;
            int resolvedBorderB;
            int resolvedBorderL;
            int resolvedBorderR;
            int resolvedTextIndent;
            int resolvedTop;
            int resolvedLeft;
            int resolvedX;
            int resolvedY;

            //width
            var parsedSize = Data.ParseSize(Width);
            resolvedW = parsedSize.Value;
            if (parsedSize.IsPercent)
            {
                //remove parent padding from child final width if child width is % of parent
                //NOTE: when the parent was resolved, it's padding gets added to its width making the resolved width larger than its content width.
                //	child % needs to look at the parents final content width.		
                float tFactor = parsedSize.Value * 0.01f;
                resolvedW = (int)Math.Floor(parentContentW * tFactor);
            }
            //min/max should only be specified in pixels, after the element % mhas been converted to pixels, we can check against the min/max values
            if (MinWidth[0] != '0')
            {
                int minW = Data.ParseSize(MinWidth).Value;
                if(resolvedW < minW)
                {
                    resolvedW = minW;
                }
            }
            if (MaxWidth[0] != '0')
            {
                int maxW = Data.ParseSize(MaxWidth).Value;
                if (resolvedW < maxW)
                {
                    resolvedW = maxW;
                }
            }
            //padding may expand resolvedW after this, capture current size as the inner content size
            resolvedContentW = resolvedW;

            //height
            parsedSize = Data.ParseSize(Height);
            resolvedH = parsedSize.Value;
            if (parsedSize.IsPercent)
            {
                float tFactor = parsedSize.Value * 0.01f;
                resolvedH = (int)Math.Floor(parentContentH * tFactor);
            }
            if (MinHeight[0] != '0')
            {
                int minH = Data.ParseSize(MinHeight).Value;
                if (resolvedH < minH)
                {
                    resolvedH = minH;
                }
            }
            if (MaxHeight[0] != '0')
            {
                int maxH = Data.ParseSize(MaxHeight).Value;
                if (resolvedH < maxH)
                {
                    resolvedH = maxH;
                }
            }
            resolvedContentH = resolvedH;

            //TODO: handle overflow: visible|hidden|scroll

            //padding
            parsedSize = Data.ParseSize(PaddingTop);
            resolvedPadT = parsedSize.Value;
            if (parsedSize.IsPercent)
            {
                float tFactor = parsedSize.Value * 0.01f;
                resolvedPadT = (int)Math.Floor(parentContentH * tFactor);
                resolvedH += resolvedPadT;
            }
            parsedSize = Data.ParseSize(PaddingBottom);
            resolvedPadB = parsedSize.Value;
            if (parsedSize.IsPercent)
            {
                float tFactor = parsedSize.Value * 0.01f;
                resolvedPadB = (int)Math.Floor(parentContentH * tFactor);
                resolvedH += resolvedPadB;
            }
            parsedSize = Data.ParseSize(PaddingLeft);
            resolvedPadL = parsedSize.Value;
            if (parsedSize.IsPercent)
            {
                float tFactor = parsedSize.Value * 0.01f;
                resolvedPadL = (int)Math.Floor(parentContentW * tFactor);
                resolvedW += resolvedPadL;
            }
            parsedSize = Data.ParseSize(PaddingRight);
            resolvedPadR = parsedSize.Value;
            if (parsedSize.IsPercent)
            {
                float tFactor = parsedSize.Value * 0.01f;
                resolvedPadR = (int)Math.Floor(parentContentW * tFactor);
                resolvedW += resolvedPadR;
            }

            //margin
            parsedSize = Data.ParseSize(MarginTop);
            resolvedMargT = parsedSize.Value;
            if (parsedSize.IsPercent)
            {
                float tFactor = parsedSize.Value * 0.01f;
                resolvedMargT = (int)Math.Floor(parentContentH * tFactor);
            }
            parsedSize = Data.ParseSize(MarginBottom);
            resolvedMargB = parsedSize.Value;
            if (parsedSize.IsPercent)
            {
                float tFactor = parsedSize.Value * 0.01f;
                resolvedMargB = (int)Math.Floor(parentContentH * tFactor);
            }
            parsedSize = Data.ParseSize(MarginLeft);
            resolvedMargL = parsedSize.Value;
            if (parsedSize.IsPercent)
            {
                float tFactor = parsedSize.Value * 0.01f;
                resolvedMargL = (int)Math.Floor(parentContentW * tFactor);
            }
            parsedSize = Data.ParseSize(MarginRight);
            resolvedMargR = parsedSize.Value;
            if (parsedSize.IsPercent)
            {
                float tFactor = parsedSize.Value * 0.01f;
                resolvedMargR = (int)Math.Floor(parentContentW * tFactor);
            }

            //border-width
            //NOTE: per css spec, border cannot be assigned as %
            resolvedBorderT = Data.ParseSize(BorderTop.Size).Value;
            resolvedBorderB = Data.ParseSize(BorderBottom.Size).Value;
            resolvedBorderL = Data.ParseSize(BorderLeft.Size).Value;
            resolvedBorderR = Data.ParseSize(BorderRight.Size).Value;

            //text-indent
            parsedSize = Data.ParseSize(TextIndent);
            resolvedTextIndent = parsedSize.Value;
            if (parsedSize.IsPercent)
            {
                float tFactor = parsedSize.Value * 0.01f;
                resolvedTextIndent = (int)Math.Floor(parentContentW * tFactor);
            }

            //position
            if(UserInterface.ElementDrag.IsActive && UserInterface.ElementDrag.DragElement == Owner)
            {
                //if this element is being dragged, position will be set by the mouse
                resolvedTop = 0;
                resolvedLeft = 0;
                resolvedX = Hardware.Mouse.PosX - UserInterface.ElementDrag.OffsetX;
                resolvedY = Hardware.Mouse.PosY - UserInterface.ElementDrag.OffsetY;
            }
            else
            {
                parsedSize = Data.ParseSize(Top);
                resolvedTop = parsedSize.Value;
                if (parsedSize.IsPercent)
                {
                    float tFactor = parsedSize.Value * 0.01f;
                    resolvedTop = (int)Math.Floor(parentContentH * tFactor);
                }
                parsedSize = Data.ParseSize(Left);
                resolvedLeft = parsedSize.Value;
                if (parsedSize.IsPercent)
                {
                    float tFactor = parsedSize.Value * 0.01f;
                    resolvedLeft = (int)Math.Floor(parentContentW * tFactor);
                }

                switch (PositionAlignH)
                {
                    case "left":
                        resolvedX = parentContentX + resolvedMargL + resolvedBorderL + resolvedLeft;
                        break;
                    case "right":
                        resolvedX = (parentContentX + parentContentW) - (resolvedMargR + resolvedW + resolvedBorderR) + resolvedLeft;
                        break;
                    case "center":
                        resolvedX = (int)Math.Floor((parentContentX + (parentContentW * 0.5)) - (resolvedMargR + (resolvedW * 0.5) + resolvedBorderR) + resolvedLeft);
                        break;
                    default: //left
                        resolvedX = parentContentX + resolvedMargL + resolvedBorderL + resolvedLeft;
                        break;
                }

                switch (PositionAlignV)
                {
                    case "top":
                        resolvedY = parentContentY + resolvedMargT + resolvedBorderT + resolvedTop;
                        break;
                    case "bottom":
                        resolvedY = (parentContentY + parentContentH) - (resolvedMargB + resolvedH + resolvedBorderB) + resolvedTop;
                        break;
                    case "center":
                        resolvedY = (int)Math.Floor((parentContentY + (parentContentH * 0.5)) - (resolvedMargB + (resolvedH * 0.5) + resolvedBorderB) + resolvedTop);
                        break;
                    default: //top
                        resolvedY = parentContentY + resolvedMargT + resolvedBorderT + resolvedTop;
                        break;
                }
            }

            //apply it all down
            Width = resolvedW.ToString();
            Height = resolvedH.ToString();
            PaddingTop = resolvedPadT.ToString();
            PaddingBottom = resolvedPadB.ToString();
            PaddingLeft = resolvedPadL.ToString();
            PaddingRight = resolvedPadR.ToString();
            MarginTop = resolvedMargT.ToString();
            MarginBottom = resolvedMargB.ToString();
            MarginLeft = resolvedMargL.ToString();
            MarginRight = resolvedMargR.ToString();
            BorderTop.Size = resolvedBorderT.ToString();
            BorderBottom.Size = resolvedBorderB.ToString();
            BorderLeft.Size = resolvedBorderL.ToString();
            BorderRight.Size = resolvedBorderR.ToString();
            TextIndent = resolvedTextIndent.ToString();
            Top = resolvedTop.ToString();
            Left = resolvedLeft.ToString();
            _FinalX = resolvedX;
            _FinalY = resolvedY;
            _FinalW = resolvedW;
            _FinalH = resolvedH;
            _InnerX = resolvedX + resolvedPadL;
            _InnerY = resolvedY + resolvedPadT;
            _InnerW = resolvedContentW;
            _InnerH = resolvedContentH;

            //enforce visibility
            if(parent.ResolvedStyle.Display == "hidden")
            {
                Display = "hidden";
            }

            uint tIndex = UserInterface.ElementList.IndexOf(Owner);
            int tVisible = Display == "hidden" ? 0 : 1;
            if (Agk.GetSpriteVisible(tIndex) != tVisible)
            {
                Agk.SetSpriteVisible(tIndex, tVisible);
            }
            if (Agk.GetTextVisible(tIndex) != tVisible)
            {
                Agk.SetTextVisible(tIndex, tVisible);
            }

            _IsResolved = true;
        }

                foreach(var u in App.UpdateList)
                {
                    if (!App.Status.IsRunning)
                    {
                        break;
                    }
                    if(App.Timing.PauseState != 1 || u.IgnorePause)
                    {
                        Dispatcher.Invoke(u.FunctionName, null);
                    }

    public class UserInterface
    {
        public static UI.StatusData Status = new StatusData();
        public static UI.ElementDragData ElementDrag = new ElementDragData();
        public static List<UI.TransitionData> TransitionList = new List<TransitionData>();
        public static List<UI.Element> ElementList = new List<Element>();
        public static List<UI.StyleClass> StyleClassList = new List<StyleClass>();

        public UserInterface()
        {
            Dispatcher.Add(UserInterface.UpdatePageFlow);
            App.UpdateList.Add(new UpdateHandler("UserInterface.UpdatePageFlow", null, true));
        }

        public static void UpdatePageFlow(object rArgs)
        {
            
        }

        static void Main(string[] args)
        {
            var attrs = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyTitleAttribute), false).FirstOrDefault() as AssemblyTitleAttribute;

            if(!App.Init(args, attrs.Title))
            {
                return;
            }

            var ui = new UI.UserInterface();

	     UpdateHandler.SortUpdateList();

#if DEBUG
            App.Log("Program.cs", 3, "main", "> Init Complete");
#endif

        public UserInterface()
        {
            Dispatcher.Add(UpdatePageFlow);
            App.UpdateList.Add(new UpdateHandler("UpdatePageFlow", null, true));
        }

        public UserInterface()
        {
            Dispatcher.Add(UserInterface.UpdatePageFlow);
            App.UpdateList.Add(new UpdateHandler("UserInterface.UpdatePageFlow", null, true));
        }

        public UserInterface()
        {
#if DEBUG
            App.Log("UserInterface.cs", 2, "main", "> Begin Init UI");
#endif
            Dispatcher.Add(UserInterface.UpdatePageFlow);
            App.UpdateList.Add(new UpdateHandler("UserInterface.UpdatePageFlow", null, true));

            //set up root element
            UI.Element tElement = new UI.Element();
            tElement.Id = "root";
            tElement.Style.SetProp("width", App.Config.Screen.Width.ToString() + "px");
            tElement.Style.SetProp("height", App.Config.Screen.Height.ToString() + "px");
            ElementList.Add(tElement);
#if DEBUG
            App.Log("UserInterface.cs", 2, "main", "> End Init UI");
#endif
        }

        public static void UpdatePageFlow(object rArgs)
        {
#if DEBUG
            App.Log("UserInterface.cs", 1, "ui", "> Begin UpdatePageFlow");
#endif
            int dirtyCount = 0;
            if(ElementList.Count == 0)
            {
                return;
            }

            //TODO: updateTransitions()
            UserInterface.ResetResolvedStyleProps();

            //----- resolve styling and page flow ----------------------

            bool keepResolvingDeferred = true;
            while (keepResolvingDeferred)
            {
                keepResolvingDeferred = false;

                for (uint iElementIndex = 0; iElementIndex < ElementList.Count; iElementIndex++)
                {
                    //skip root
                    if (ElementList[(int)iElementIndex] == ElementList[0])
                    {
                        continue; 
                    }

                    bool resolveThis = true;

                    //skip if already resolved
                    if (ElementList[(int)iElementIndex].ResolvedStyle._IsResolved)
                    {
                        resolveThis = false; 
                    }

                    //defer if parent is not yet resolved
                    if(resolveThis && !ElementList[(int)iElementIndex].Parent.ResolvedStyle._IsResolved)
                    {
                        resolveThis = false;
                        keepResolvingDeferred = true;
                    }

                    if (resolveThis)
                    {
                        ElementList[(int)iElementIndex].ResolvedStyle.ApplyInheritedStyleProps();
                        foreach(var iStyleClass in ElementList[(int)iElementIndex].StyleClassList)
                        {
                            ElementList[(int)iElementIndex].ResolvedStyle.ApplyStyleProps(iStyleClass.Style);
                        }
                        ElementList[(int)iElementIndex].ResolvedStyle.ApplyStyleProps(ElementList[(int)iElementIndex].Style);
                        ElementList[(int)iElementIndex].ResolvedStyle.ResolveFlowValues();
                    }
                }
            }

            //----- render UI ----------------------

            for (uint iElementIndex = 0; iElementIndex < ElementList.Count; iElementIndex++)
            {
                //skip root
                if (iElementIndex == 0)
                {
                    continue;
                }

                if(ElementList[(int)iElementIndex].ResolvedStyle.Display == "visible")
                {
                    if(ElementList[(int)iElementIndex].IsDirty || !String.IsNullOrEmpty(ElementList[(int)iElementIndex].Value))
                    {
                        //get flow data
                        int borderSizeT = Convert.ToInt32(ElementList[(int)iElementIndex].ResolvedStyle.BorderTop.Size);
                        int borderSizeB = Convert.ToInt32(ElementList[(int)iElementIndex].ResolvedStyle.BorderBottom.Size);
                        int borderSizeL = Convert.ToInt32(ElementList[(int)iElementIndex].ResolvedStyle.BorderLeft.Size);
                        int borderSizeR = Convert.ToInt32(ElementList[(int)iElementIndex].ResolvedStyle.BorderRight.Size);
                        int finalX = ElementList[(int)iElementIndex].ResolvedStyle._FinalX;
                        int finalY = ElementList[(int)iElementIndex].ResolvedStyle._FinalY;
                        int finalW = ElementList[(int)iElementIndex].ResolvedStyle._FinalW;
                        int finalH = ElementList[(int)iElementIndex].ResolvedStyle._FinalH;
                        int contentX = ElementList[(int)iElementIndex].ResolvedStyle._InnerX;
                        int contentY = ElementList[(int)iElementIndex].ResolvedStyle._InnerY;
                        int contentW = ElementList[(int)iElementIndex].ResolvedStyle._InnerW;
                        int contentH = ElementList[(int)iElementIndex].ResolvedStyle._InnerH;

                        //draw element background
                        if(ElementList[(int)iElementIndex].ResolvedStyle.BackgroundOpacity > 0)
                        {
                            //TODO: handle overflow and repeat
                            if (String.IsNullOrEmpty(ElementList[(int)iElementIndex].ResolvedStyle.BackgroundImage))
                            {
#if DEBUG
                                App.Log("UserInterface.cs", 1, "ui", "  no backgroundImage, make a color image");
#endif
                                //no image, make color
                                var tColor = Media.MakeColorImage((uint)finalW, (uint)finalH, ElementList[(int)iElementIndex].ResolvedStyle.BackgroundColor, ElementList[(int)iElementIndex].ResolvedStyle.BackgroundColor, ElementList[(int)iElementIndex].ResolvedStyle.BackgroundColor, ElementList[(int)iElementIndex].ResolvedStyle.BackgroundColor, 1);
                                ElementList[(int)iElementIndex].Style.SetProp("background-image", tColor.File);
                                ElementList[(int)iElementIndex].ResolvedStyle.SetProp("background-image", tColor.File);
                            }
                            var tImg = Media.GetImageAsset(ElementList[(int)iElementIndex].ResolvedStyle.BackgroundImage, 1.0f, 1.0f);
                            if (!Agk.IsSpriteExists(iElementIndex))
                            {
#if DEBUG
                                App.Log("UserInterface.cs", 1, "ui", $"  no sprite for background. make a sprite {iElementIndex.ToString()}");
#endif
                                Agk.CreateSprite(iElementIndex, tImg.Number);
                            }
                            Agk.SetSpriteImage(iElementIndex, tImg.Number);
                            Agk.SetSpriteScale(iElementIndex, contentW / Agk.GetImageWidth(tImg.Number), contentH / Agk.GetImageHeight(tImg.Number));
                            Agk.SetSpritePosition(iElementIndex, contentX, contentY);
                            Agk.SetSpriteColorAlpha(iElementIndex, (int)(ElementList[(int)iElementIndex].ResolvedStyle.BackgroundOpacity * 0.01 * 255));
                            Agk.SetSpriteDepth(iElementIndex, (int)ElementList[(int)iElementIndex].ResolvedStyle.ZIndex);
                            Agk.SetSpriteAngle(iElementIndex, ElementList[(int)iElementIndex].ResolvedStyle.Rotation);
                        }

                        //draw borders
                        //TODO: convert to sprite, apply backgroundOpacity
                        if(borderSizeT > 0)
                        {
                            Agk.DrawBox(finalX, finalY, (finalX + finalW), (finalY + borderSizeT), ElementList[(int)iElementIndex].ResolvedStyle.BorderTop.Color, ElementList[(int)iElementIndex].ResolvedStyle.BorderTop.Color, ElementList[(int)iElementIndex].ResolvedStyle.BorderTop.Color, ElementList[(int)iElementIndex].ResolvedStyle.BorderTop.Color, 1);
                        }
                        if (borderSizeB > 0)
                        {
                            Agk.DrawBox(finalX, (finalY + finalH - borderSizeB), (finalX + finalW), (finalY + finalH), ElementList[(int)iElementIndex].ResolvedStyle.BorderBottom.Color, ElementList[(int)iElementIndex].ResolvedStyle.BorderBottom.Color, ElementList[(int)iElementIndex].ResolvedStyle.BorderBottom.Color, ElementList[(int)iElementIndex].ResolvedStyle.BorderBottom.Color, 1);
                        }
                        if (borderSizeR > 0)
                        {
                            Agk.DrawBox((finalX + finalW - borderSizeR), (finalY + borderSizeT), (finalX + finalW), (finalY + finalH - borderSizeB), ElementList[(int)iElementIndex].ResolvedStyle.BorderRight.Color, ElementList[(int)iElementIndex].ResolvedStyle.BorderRight.Color, ElementList[(int)iElementIndex].ResolvedStyle.BorderRight.Color, ElementList[(int)iElementIndex].ResolvedStyle.BorderRight.Color, 1);
                        }
                        if (borderSizeL > 0)
                        {
                            Agk.DrawBox(finalX, (finalY + borderSizeT), (finalX + borderSizeL), (finalY + finalH - borderSizeB), ElementList[(int)iElementIndex].ResolvedStyle.BorderLeft.Color, ElementList[(int)iElementIndex].ResolvedStyle.BorderLeft.Color, ElementList[(int)iElementIndex].ResolvedStyle.BorderLeft.Color, ElementList[(int)iElementIndex].ResolvedStyle.BorderLeft.Color, 1);
                        }

                        //draw text
                        if (!String.IsNullOrEmpty(ElementList[(int)iElementIndex].Value))
                        {
                            if (!Agk.IsTextExists(iElementIndex))
                            {
#if DEBUG
                                App.Log("UserInterface.cs", 1, "ui", $"  no text for element {iElementIndex.ToString()}. make a text");
#endif
                                Agk.CreateText(iElementIndex, ElementList[(int)iElementIndex].Value);
                            }
                            switch(ElementList[(int)iElementIndex].ResolvedStyle.TextTransform.ToLower())
                            {
                                case "lower":
                                    Agk.SetTextString(iElementIndex, ElementList[(int)iElementIndex].Value.ToLower());
                                    break;
                                case "upper":
                                    Agk.SetTextString(iElementIndex, ElementList[(int)iElementIndex].Value.ToUpper());
                                    break;
                                case "capitalize":
                                    Agk.SetTextString(iElementIndex, ElementList[(int)iElementIndex].Value[0].ToString().ToUpper() + ElementList[(int)iElementIndex].Value.Substring(1));
                                    break;
                                default:
                                    Agk.SetTextString(iElementIndex, ElementList[(int)iElementIndex].Value);
                                    break;
                            }
                            Agk.SetTextMaxWidth(iElementIndex, contentW);
                            Agk.SetTextSize(iElementIndex, ElementList[(int)iElementIndex].ResolvedStyle.FontSize);
                            Agk.SetTextColor(iElementIndex, Agk.GetColorRed(ElementList[(int)iElementIndex].ResolvedStyle.Color), Agk.GetColorGreen(ElementList[(int)iElementIndex].ResolvedStyle.Color), Agk.GetColorBlue(ElementList[(int)iElementIndex].ResolvedStyle.Color), (uint)(ElementList[(int)iElementIndex].ResolvedStyle.Opacity * 0.01 * 255));
                            Agk.SetTextDepth(iElementIndex, (int)(ElementList[(int)iElementIndex].ResolvedStyle.ZIndex - 1));
                            if (ElementList[(int)iElementIndex].ResolvedStyle.TextDecoration.ToLower().Contains("bold"))
                            {
                                Agk.SetTextBold(iElementIndex, 1);
                            }
                            else
                            {
                                Agk.SetTextBold(iElementIndex, 0);
                            }

                            int textPosH = 0;
                            int textPosV = 0;
                            switch (ElementList[(int)iElementIndex].ResolvedStyle.TextAlignH)
                            {
                                case "right":
                                    Agk.SetTextAlignment(iElementIndex, 2);
                                    textPosH = finalX + finalW;
                                    break;
                                case "center":
                                    Agk.SetTextAlignment(iElementIndex, 1);
                                    textPosH = finalX + (int)(finalW * 0.5);
                                    break;
                                default: //left
                                    Agk.SetTextAlignment(iElementIndex, 0);
                                    textPosH = finalX;
                                    break;
                            }
                            switch (ElementList[(int)iElementIndex].ResolvedStyle.TextAlignV)
                            {
                                case "bottom":
                                    textPosV = finalY + finalH - (int)(Agk.GetTextTotalHeight(iElementIndex));
                                    break;
                                case "center":
                                    textPosV = finalY + (int)(finalH * 0.5) - (int)(Agk.GetTextTotalHeight(iElementIndex) * 0.5);
                                    break;
                                default: //top
                                    textPosV = finalY;
                                    break;
                            }
                            Agk.SetTextPosition(iElementIndex, textPosH, textPosV);
                            Agk.SetTextAngle(iElementIndex, ElementList[(int)iElementIndex].ResolvedStyle.Rotation);
                        }
                    }
                }

                if (ElementList[(int)iElementIndex].IsDirty)
                {
                    ElementList[(int)iElementIndex].IsDirty = false;
                    ++dirtyCount;
                }
            }
#if DEBUG
            App.Log("UserInterface.cs", 1, "ui", "> End UpdatePageFlow");
#endif
        }

    }

            /*
            // display a background and center it
            uint bgImg = Agk.CreateSprite(Agk.LoadImage("media/background.jpg"));
            Agk.SetSpritePosition(bgImg, App.Config.Screen.CenterX - 160, App.Config.Screen.CenterY - 240);

            // create a sprite and center it
            Agk.CreateSprite(1, 0);
            Agk.SetSpritePosition(1, App.Config.Screen.CenterX - 30, App.Config.Screen.CenterY - 44);

            // add individual images into an animation list
            Agk.AddSpriteAnimationFrame(1, Agk.LoadImage("media/item0.png"));
            Agk.AddSpriteAnimationFrame(1, Agk.LoadImage("media/item1.png"));
            Agk.AddSpriteAnimationFrame(1, Agk.LoadImage("media/item2.png"));
            Agk.AddSpriteAnimationFrame(1, Agk.LoadImage("media/item3.png"));
            Agk.AddSpriteAnimationFrame(1, Agk.LoadImage("media/item4.png"));

            // play the sprite at 10 fps, looping, going from frame 1 to 5
            Agk.PlaySprite(1, 10.0f, 1, 1, 5);
            */

            UI.Element tElement = new UI.Element();
            tElement.Style.SetProp("width", "100px");
            tElement.Style.SetProp("height", "40px");
            tElement.Style.SetProp("background-color", "#f00");
            tElement.Style.SetProp("text-decoration", "bold");
            tElement.Style.SetProp("position-alignH", "center");
            tElement.Style.SetProp("position-alignV", "bottom");
            tElement.Style.SetProp("margin-bottom", "20%");
            tElement.Style.SetProp("text-alignH", "center");
            tElement.Style.SetProp("text-alignV", "center");
            tElement.Value = "Hi there!";
            tElement.Parent = UI.UserInterface.ElementList[0];
            UI.UserInterface.ElementList.Add(tElement);

    public class Element
    {
	…
        public void SetParent(string rParentId)
        {
            Parent = UserInterface.ElementList.FirstOrDefault(el => el.Id == rParentId);
            Parent.IsDirty = true;
            IsDirty = true;
        }

        public void SetStyleClass(string rStyleClass)
        {
            StyleClassList.Add(UserInterface.StyleClassList.FirstOrDefault(cl => cl.ClassName == rStyleClass));
            Parent.IsDirty = true;
            IsDirty = true;
        }

    public class UserInterface
    {
	…
        public Element GetElementById(string rId)
        {
            return ElementList.FirstOrDefault(el => el.Id == rId);
        }

        public List<Element> GetElementsByName(string rName)
        {
            return ElementList.FindAll(el => el.Name == rName).ToList();
        }

        public List<Element> GetElementsByTagName(string rName)
        {
            return ElementList.FindAll(el => el.Tag == rName).ToList();
        }

        public List<Element> GetElementsByClassName(string rName)
        {
            return ElementList.FindAll(el => el.StyleClassList.First(cl => cl.ClassName == rName) != null).ToList();
        }
        public StyleClass GetStyleClassByName(string rStyleClass)
        {
            return UserInterface.StyleClassList.FirstOrDefault(cl => cl.ClassName == rStyleClass);
        }

                        //draw element background
                        if(ElementList[(int)iElementIndex].ResolvedStyle.BackgroundOpacity > 0)
                        {
                            //TODO: handle overflow and repeat
                            if (String.IsNullOrEmpty(ElementList[(int)iElementIndex].ResolvedStyle.BackgroundImage))
                            {
#if DEBUG
                                App.Log("UserInterface.cs", 1, "ui", "  no backgroundImage, make a color image");
#endif
                                //no image, make color
                                var tColor = Media.MakeColorImage((uint)finalW, (uint)finalH, ElementList[(int)iElementIndex].ResolvedStyle.BackgroundColor, ElementList[(int)iElementIndex].ResolvedStyle.BackgroundColor, ElementList[(int)iElementIndex].ResolvedStyle.BackgroundColor, ElementList[(int)iElementIndex].ResolvedStyle.BackgroundColor, 1);
                                ElementList[(int)iElementIndex].Style.SetProp("background-image", tColor.File);
                                ElementList[(int)iElementIndex].ResolvedStyle.SetProp("background-image", tColor.File);
                            }
                            //check for animated frames
                            ImageAsset tImg;
                            if (ElementList[(int)iElementIndex].ResolvedStyle.BackgroundImage.Contains("|"))
                            {
                                var imgList = ElementList[(int)iElementIndex].ResolvedStyle.BackgroundImage.Split('|');
                                tImg = Media.GetImageAsset(imgList[0], 1.0f, 1.0f);
                                Agk.CreateSprite(iElementIndex, tImg.Number);
                                for(int i = 1; i < imgList.Count(); i++)
                                {
                                    var frame = Media.GetImageAsset(imgList[i], 1.0f, 1.0f);
                                    Agk.AddSpriteAnimationFrame(iElementIndex, frame.Number);
                                }
                                Agk.PlaySprite(iElementIndex, 10.0f, 1, 1, imgList.Count()); //TODO: add style prop to control speed
                                ElementList[(int)iElementIndex].Style.SetProp("background-image", imgList[0]);
                                ElementList[(int)iElementIndex].ResolvedStyle.SetProp("background-image", imgList[0]);
                            }
                            else
                            {
                                tImg = Media.GetImageAsset(ElementList[(int)iElementIndex].ResolvedStyle.BackgroundImage, 1.0f, 1.0f);
                                if (!Agk.IsSpriteExists(iElementIndex))
                                {
#if DEBUG
                                    App.Log("UserInterface.cs", 1, "ui", $"  no sprite for background. make a sprite {iElementIndex.ToString()}");
#endif
                                    Agk.CreateSprite(iElementIndex, tImg.Number);
                                }
                                Agk.SetSpriteImage(iElementIndex, tImg.Number);
                            }

                            //Agk.SetSpriteImage(iElementIndex, tImg.Number);
                            Agk.SetSpriteScale(iElementIndex, contentW / Agk.GetImageWidth(tImg.Number), contentH / Agk.GetImageHeight(tImg.Number));
                            Agk.SetSpritePosition(iElementIndex, contentX, contentY);
                            Agk.SetSpriteColorAlpha(iElementIndex, (int)(ElementList[(int)iElementIndex].ResolvedStyle.BackgroundOpacity * 0.01 * 255));
                            Agk.SetSpriteDepth(iElementIndex, (int)ElementList[(int)iElementIndex].ResolvedStyle.ZIndex);
                            Agk.SetSpriteAngle(iElementIndex, ElementList[(int)iElementIndex].ResolvedStyle.Rotation);
                        }
 

using System;
using AgkSharp;
using AGKCore;
using System.Reflection;
using System.Linq;
using System.Drawing;
using System.Windows.Forms;
using System.Threading;
using System.Drawing.Imaging;
using System.Runtime.InteropServices;
using System.Diagnostics;
using UI = AGKCore.UI;

namespace AgkSharp_Template
{
    static class Program
    {
        [STAThread]
        static void Main(string[] args)
        {
            var attrs = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyTitleAttribute), false).FirstOrDefault() as AssemblyTitleAttribute;

            if(!App.Init(args, attrs.Title))
            {
                return;
            }

            var ui = new UI.UserInterface();

            UpdateHandler.SortUpdateList();

#if DEBUG
            App.Log("Program.cs", 3, "main", "> Init Complete");
#endif

            UI.Element tElement = new UI.Element();
            tElement.Id = "sky-panel";
            tElement.Style.SetProp("width", "320px");
            tElement.Style.SetProp("height", "480px");
            tElement.Style.SetProp("background-image", "media/background.jpg");
            tElement.Style.SetProp("position-alignH", "center");
            tElement.Style.SetProp("position-alignV", "center");
            tElement.SetParent("root");
            UI.UserInterface.ElementList.Add(tElement);

            tElement = new UI.Element();
            tElement.Id = "balloon";
            tElement.Style.SetProp("width", "60px");
            tElement.Style.SetProp("height", "88px");
            tElement.Style.SetProp("background-image", "media/item0.png|media/item1.png|media/item2.png|media/item3.png|media/item4.png");
            tElement.Style.SetProp("position-alignH", "center");
            tElement.Style.SetProp("position-alignV", "center");
            tElement.SetParent("sky-panel");
            UI.UserInterface.ElementList.Add(tElement);


            while (App.LoopAGK())
            {
#if DEBUG
                App.Log("Program.cs", 1, "main", "--- Begin main loop ---");
#endif
                //Always update timing, and do it first
                App.UpdateTiming();
#if DEBUG
                App.Log("Program.cs", 1, "main", "Processing " + App.UpdateList.Count.ToString() + " updates in queue");
#endif
                foreach (var u in App.UpdateList)
                {
                    if (!App.Status.IsRunning)
                    {
                        break;
                    }
                    if(App.Timing.PauseState != 1 || u.IgnorePause)
                    {
#if DEBUG
                        App.Log("Program.cs", 1, "main", "Process from queue " + u.FunctionName);
#endif
                        Dispatcher.Invoke(u.FunctionName, null);
                    }
                }
                if (!App.Status.IsRunning)
                {
                    break;
                }

                Agk.Print(Agk.ScreenFPS());

                Agk.Sync();
            }

            App.CleanUp();
        }

    }

}

        public static void OnMouseMove(object sender, MouseEventArgs e)
        {
            Mouse.MoveX = e.X - Mouse.PosX;
            Mouse.MoveY = e.Y - Mouse.PosY;
            Mouse.PosX = e.X;
            Mouse.PosY = e.Y;
        }

            int tVisible = Display == "hidden" ? 0 : 1;
            uint tIndex = (uint)UserInterface.ElementList.IndexOf(Owner);
            if (Agk.IsSpriteExists(tIndex))
            {
                if (Agk.GetSpriteVisible(tIndex) != tVisible)
                {
                    Agk.SetSpriteVisible(tIndex, tVisible);
                }
            }
            if (Agk.IsTextExists(tIndex))
            { 
                if (Agk.GetTextVisible(tIndex) != tVisible)
                {
                    Agk.SetTextVisible(tIndex, tVisible);
                }
            }

        public static void ResetResolvedStyleProps()
        {
#if DEBUG
            App.Log("UserInterface.cs", 1, "ui", "> Begin ResetResolvedStyleProps");
#endif
            ElementList[0].IsDirty = false; //skip root element

            if (UserInterface.ElementDrag.DragElement != null)
            {
                UserInterface.ElementDrag.DragElement.IsDirty = true; //always resolve dragging element
            }

            foreach (var e in ElementList)
            {

            tElement = new UI.Element();
            tElement.Id = "balloon";
            tElement.Style.SetProp("width", "60px");
            tElement.Style.SetProp("height", "88px");
            tElement.Style.SetProp("background-image", "media/item0.png|media/item1.png|media/item2.png|media/item3.png|media/item4.png");
            tElement.Style.SetProp("position-alignH", "center");
            tElement.Style.SetProp("position-alignV", "center");
            tElement.SetParent("sky-panel");
            UI.UserInterface.ElementList.Add(tElement);

            UI.UserInterface.ElementDrag.DragElement = tElement;
            UI.UserInterface.ElementDrag.IsActive = true;
            UI.UserInterface.ElementDrag.OffsetX = 30;
            UI.UserInterface.ElementDrag.OffsetY = 40;

            while (App.LoopAGK())
            {
#if DEBUG
                App.Log("Program.cs", 1, "main", "--- Begin main loop ---");
#endif

        public UserInterface()
        {
#if DEBUG
            App.Log("UserInterface.cs", 2, "main", "> Begin Init UI");
#endif
            Dispatcher.Add(UserInterface.UpdatePageFlow);
            App.UpdateList.Add(new UpdateHandler("UserInterface.UpdatePageFlow", null, true));

            Dispatcher.Add(UserInterface.GetInterfaceInput);
            App.UpdateList.Add(new UpdateHandler("UserInterface.GetInterfaceInput", "UserInterface.UpdatePageFlow", true));

        public static void GetInterfaceInput(object rArgs)
        {
            if (Math.Abs(App.Timing.Timer - Status.InputMark) > 200)
            {
                Status.InputReady = true;
            }
            else
            {
                Status.InputReady = false;
            }

            Data.SetBit((int)TimingStatus.PauseType.UI, App.Timing.PauseHold, 0);

            for (int iElementIndex = 0; iElementIndex < ElementList.Count; iElementIndex++)
            {
                //skip root
                if (iElementIndex == 0 || ElementList[iElementIndex].ResolvedStyle.Display == "hidden")
                {
                    continue;
                }
                if (ElementList[iElementIndex].HoldPause)
                {
                    Data.SetBit((int)TimingStatus.PauseType.UI, App.Timing.PauseHold, 1);
                }
                if (ElementList[iElementIndex].HoldMouseFocus)
                {
                    Status.MouseMode = "ui";
                }
                if (ElementList[iElementIndex].HoldKeyFocus)
                {
                    Status.KeyMode = "ui";
                }
                if (Status.MouseMode == "ui" && Status.KeyMode == "ui")
                {
                    if (Data.GetBit((int)TimingStatus.PauseType.UI, App.Timing.PauseHold) == 1)
                    {
                        break;
                    }
                }
            }

            if (Status.MouseMode == "ui")
            {
                Agk.SetRawMouseVisible(1);
            }
            else
            {
                Agk.SetRawMouseVisible(0);
            }

            if (!Status.InputReady)
            {
                return;
            }

namespace AGKCore
{
    public static class MathF
    {
        public static bool IsPointInBox(int px, int py, int x1, int y1, int x2, int y2)
        {
            if (px >= x1 && px <= x2)
            {
                if (py >= y1 && py <= y2)
                {
                    return true;
                }
            }
            return false;
        }


    }

}

            for (uint iElementIndex = 0; iElementIndex < ElementList.Count; iElementIndex++)
            {
                var iElement = ElementList[(int)iElementIndex];

                //skip root
                if (iElementIndex == 0 || iElement.ResolvedStyle.Display == "hidden")
                {
                    continue;
                }

                //mouse events
                if (Status.MouseMode == "ui" && iElement.ResolvedStyle.Display != "hidden")
                {
                    if (iElement.EnableEvents == 1 || iElement.EnableEvents == 3 || (iElement.EnableEvents == 4 && ElementDrag.IsActive))
                    {
                        var oldPressHold = iElement.PressIsHeld;
                        var oldMouseOver = iElement.MouseIsOver;
                        iElement.PressIsHeld = false;
                        iElement.MouseIsOver = false;

                        //if this element is the actively dragging element, enforce mouseOver
                        if (ElementDrag.DragElement == iElement)
                        {
                            oldMouseOver = true;
                            iElement.MouseIsOver = true;
                        }

                        //detect mouse over
                        var x1 = iElement.ResolvedStyle._InnerX;
                        var y1 = iElement.ResolvedStyle._InnerY;
                        var x2 = x1 + iElement.ResolvedStyle._InnerW;
                        var y2 = y1 + iElement.ResolvedStyle._InnerH;
                        if (Agk.IsSpriteHitTest(iElementIndex, Agk.ScreenToWorldX(Hardware.Mouse.PosX), Agk.ScreenToWorldY(Hardware.Mouse.PosY)))
                        {
                            iElement.MouseIsOver = true;
                            if (!oldMouseOver)
                            {
                                //new mouseIn
                                if (!String.IsNullOrEmpty(iElement.OnMouseIn))
                                {
                                    Dispatcher.Invoke(iElement.OnMouseIn, iElementIndex.ToString());
                                    return;
                                }
                            }
                            //handle press
                            if (Data.GetBit(1, Hardware.Input[Hardware.MouseEnum((int)MouseButtons.Left)]) == 1)
                            {
                                iElement.PressIsHeld = true;
                                if (!oldPressHold)
                                {
                                    //new press
                                    Status.InputMark = App.Timing.Timer;
                                    if (!String.IsNullOrEmpty(iElement.OnPress))
                                    {
                                        Dispatcher.Invoke(iElement.OnPress, iElementIndex.ToString());
                                        return;
                                    }
                                }
                            }
                            else
                            {
                                if (oldPressHold)
                                {
                                    //new release
                                    if (!String.IsNullOrEmpty(iElement.OnRelease))
                                    {
                                        Dispatcher.Invoke(iElement.OnRelease, iElementIndex.ToString());
                                        return;
                                    }
                                }
                            }
                        }

                        //detect mouse out
                        if (oldMouseOver && !iElement.MouseIsOver)
                        {
                            if (!String.IsNullOrEmpty(iElement.OnMouseOut))
                            {
                                Dispatcher.Invoke(iElement.OnMouseOut, iElementIndex.ToString());
                                return;
                            }
                        }
                    }
                }
                else
                {
                    //element is hidden or bound to gameplay, if mouse was over, trigger mouseOut
                    if (iElement.MouseIsOver)
                    {
                        iElement.MouseIsOver = false;
                        iElement.PressIsHeld = false;
                        if (!String.IsNullOrEmpty(iElement.OnMouseOut))
                        {
                            Dispatcher.Invoke(iElement.OnMouseOut, iElementIndex.ToString());
                            return;
                        }
                    }
                }

                //key events
                if(Status.KeyMode == "ui")
                {
                    //TODO:
                    //this handles things like entering text into a chatbox where keys should not trigger regular ui events or character control
                    //this would include such events as enter key to finalize an input, escape to cancel an input etc
                    //alphanumerics go to entry buffer, and buffer content will be applied to the active element's value.				
                }
                else
                {
                    //check keybinds
                    if(iElement.EnableEvents == 2 || iElement.EnableEvents == 3)
                    {
                        bool oldPressHold = iElement.PressIsHeld;
                        iElement.PressIsHeld = false;
                        if(iElement.KeyBind > 0)
                        {
                            if(Data.GetBit(1, Hardware.Input[iElement.KeyBind]) == 1)
                            {
                                iElement.PressIsHeld = true;
                                if (!oldPressHold)
                                {
                                    //new press
                                    Status.InputMark = App.Timing.Timer;
                                    if (!String.IsNullOrEmpty(iElement.OnPress))
                                    {
                                        Dispatcher.Invoke(iElement.OnPress, iElementIndex.ToString());
                                        return;
                                    }
                                }
                                else
                                {
                                    if (oldPressHold)
                                    {
                                        //new release
                                        if (!String.IsNullOrEmpty(iElement.OnRelease))
                                        {
                                            Dispatcher.Invoke(iElement.OnRelease, iElementIndex.ToString());
                                            return;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

using System;
using AgkSharp;
using AGKCore;
using System.Reflection;
using System.Linq;
using System.Drawing;
using System.Windows.Forms;
using System.Threading;
using System.Drawing.Imaging;
using System.Runtime.InteropServices;
using System.Diagnostics;
using UI = AGKCore.UI;

namespace AgkSharp_Template
{
    static class Program
    {
        [STAThread]
        static void Main(string[] args)
        {
            var attrs = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyTitleAttribute), false).FirstOrDefault() as AssemblyTitleAttribute;

            //init Agk
            if(!App.Init(args, attrs.Title))
            {
                return;
            }

            //init modules
            var ui = new UI.UserInterface();

            //clean up
            UpdateHandler.SortUpdateList();

#if DEBUG
            App.Log("Program.cs", 3, "main", "> Init Complete");
#endif

            UI.Element tElement = new UI.Element();
            tElement.Id = "sky-panel";
            tElement.Style.SetProp("width", "320px");
            tElement.Style.SetProp("height", "480px");
            tElement.Style.SetProp("background-image", "media/background.jpg");
            tElement.Style.SetProp("position-alignH", "center");
            tElement.Style.SetProp("position-alignV", "center");
            tElement.SetParent("root");
            UI.UserInterface.ElementList.Add(tElement);

            tElement = new UI.Element();
            tElement.Id = "balloon";
            tElement.Style.SetProp("width", "60px");
            tElement.Style.SetProp("height", "88px");
            tElement.Style.SetProp("background-image", "media/item0.png|media/item1.png|media/item2.png|media/item3.png|media/item4.png");
            tElement.Style.SetProp("position-alignH", "center");
            tElement.Style.SetProp("position-alignV", "center");
            tElement.SetParent("sky-panel");
            tElement.HoldMouseFocus = true;
            tElement.EnableEvents = 1;
            tElement.OnPress = "App.DoStuff";
            UI.UserInterface.ElementList.Add(tElement);

            Dispatcher.Add(App.DoStuff);

            /*
            UI.UserInterface.ElementDrag.DragElement = tElement;
            UI.UserInterface.ElementDrag.IsActive = true;
            UI.UserInterface.ElementDrag.OffsetX = 30;
            UI.UserInterface.ElementDrag.OffsetY = 40;
            */

            while (App.LoopAGK())
            {
#if DEBUG
                App.Log("Program.cs", 1, "main", "--- Begin main loop ---");
#endif
                //Always update timing, and do it first
                App.UpdateTiming();
#if DEBUG
                App.Log("Program.cs", 1, "main", "Processing " + App.UpdateList.Count.ToString() + " updates in queue");
#endif
                foreach (var u in App.UpdateList)
                {
                    if (!App.Status.IsRunning)
                    {
                        break;
                    }
                    if(App.Timing.PauseState != 1 || u.IgnorePause)
                    {
#if DEBUG
                        App.Log("Program.cs", 1, "main", "Process from queue " + u.FunctionName);
#endif
                        Dispatcher.Invoke(u.FunctionName, null);
                    }
                }
                if (!App.Status.IsRunning)
                {
                    break;
                }

                Agk.Print(Agk.ScreenFPS());
                Agk.Print(Hardware.Mouse.PosX.ToString() + "," + Hardware.Mouse.PosY.ToString());

                var checkElement = UI.UserInterface.GetElementById("balloon");
                Agk.Print("Mouse is over balloon? " + checkElement.MouseIsOver.ToString());
                Agk.Print("Mouse is pressed? " + Data.GetBit(1, Hardware.Input[Hardware.MouseEnum((int)MouseButtons.Left)]).ToString());

                Agk.Sync();
            }

            App.CleanUp();
        }

    }

}

        public static void DoStuff(object rArgs)
        {
            var a = rArgs as Scheduler.TimerState;
            if (a == null)
            {
                Scheduler.SetInterval(App.DoStuff, rArgs.ToString(), -1, 50, 0, null);
            }
            else
            {
                var tElement = UI.UserInterface.ElementList[Convert.ToInt32(a.Args)];
                tElement.Style.SetProp("rotation", (tElement.Style.Rotation + 1).ToString());
            }
        }

using AgkSharp;
using System;

namespace AGKCore.UI
{
    public class GameMenuController : UI.Controller
    {
        public GameMenuController()
        {
            Dispatcher.Add(GameMenuController.MenuOnPress);
            Dispatcher.Add(GameMenuController.ResumeOnPress);
            Dispatcher.Add(GameMenuController.QuitOnPress);
            UserInterface.LoadPartial("media/ui/partials/gameMenu.json");
        }

        public static void MenuOnPress(object rArgs)
        {
            var tElement = UI.UserInterface.ElementList[Convert.ToInt32(rArgs)];
            if(tElement.Style.Display == "hidden")
            {
                tElement.Style.SetProp("display", "visible");
            }
            else
            {
                tElement.Style.SetProp("display", "hidden");
            }
        }

        public static void ResumeOnPress(object rArgs)
        {
            var tElement = UI.UserInterface.GetElementById("gameMenu");
            tElement.Style.SetProp("display", "hidden");
        }

        public static void QuitOnPress(object rArgs)
        {
            App.StopRunning(false);
        }

    }

}

namespace AGKCore.UI
{
    public class UserInterface
    {
        public static UI.StatusData Status = new StatusData();
        public static UI.ElementDragData ElementDrag = new ElementDragData();
        public static List<UI.TransitionData> TransitionList = new List<TransitionData>();
        public static List<UI.Element> ElementList = new List<Element>();
        public static List<UI.StyleClass> StyleClassList = new List<StyleClass>();
        public static List<UI.Controller> ControllerList = new List<UI.Controller>();

        ...

    public class Controller
    {

    }        

namespace AgkSharp_Template
{
    static class Program
    {
        [STAThread]
        static void Main(string[] args)
        {
            var attrs = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyTitleAttribute), false).FirstOrDefault() as AssemblyTitleAttribute;

            //init Agk
            if(!App.Init(args, attrs.Title))
            {
                return;
            }

            //init modules
            var ui = new UI.UserInterface();
            UI.UserInterface.ControllerList.Add(new UI.GameMenuController());

            //clean up
            UpdateHandler.SortUpdateList();

#if DEBUG
            App.Log("Program.cs", 3, "main", "> Init Complete");
#endif

[
	{"type": "styleClass",
		"name": "btn-text",
		"style": {
			"width": "250px",
			"height": "50px",
			"padding-left": "6%",
			"text-alignV": "center",
			"background-opacity": "0",
			"font-size": "32",
			"z-index": "5"
		}
	},
	{
		"type": "element",
		"tag": "div",
		"id": "gameMenu",
		"holdMouseFocus": "true",
		"holdPause": "true",
		"enableEvents": "2",
		"keyBind": "27",
		"onPress": "GameMenuController.MenuOnPress",
		"style": {
			"width": "100%",
			"height": "100%",
			"display": "hidden"
		},
		"children": [
			{
				"type": "element",
				"tag": "button",
				"id": "btn-resume",
				"styleClass": "btn-text",
				"name": "btn-txt",
				"value": "Resume",
				"enableEvents": "1",
				"onPress": "GameMenuController.ResumeOnPress",
				"style": {
					"position-alignV": "center",
					"top": "-30px"
				}
			},
			{
				"type": "element",
				"tag": "button",
				"id": "btn-close",
				"styleClass": "btn-text",
				"name": "btn-txt",
				"value": "Quit",
				"enableEvents": "1",
				"onPress": "GameMenuController.QuitOnPress",
				"style": {
					"position-alignV": "center",
					"top": "30px"
				}
			}
		]
	}
]

        public static bool HasOwnProperty(dynamic rObject, string rProperty)
        {
            return ((JObject)rObject).Property(rProperty) != null;
        }

        public static void LoadPartial(string rFile)
        {
            string doc = System.IO.File.ReadAllText(rFile);
            var view = JsonConvert.DeserializeObject<List<dynamic>>(doc);
            foreach (var component in view)
            {
                if(component.type == "styleClass")
                {
                    StyleClass tStyleClass = new StyleClass();
                    tStyleClass.ClassName = Data.HasOwnProperty(component, "name") ? component.name : "";
                    if (Data.HasOwnProperty(component, "style"))
                    {
                        foreach (var prop in ((JObject)component.style).Properties())
                        {
                            tStyleClass.Style.SetProp(prop.Name, prop.Value.ToString());
                        }
                    }
                    StyleClassList.Add(tStyleClass);
                }
                if (component.type == "element")
                {
                    LoadElement(component, null);
                }
            }
        }

        public static void LoadElement(dynamic component, string rParentId)
        {
            Element tElement = new Element();
            tElement.Id = Data.HasOwnProperty(component, "id") ? component.id : "";
            tElement.Name = Data.HasOwnProperty(component, "name") ? component.name : "";
            tElement.Tag = Data.HasOwnProperty(component, "tag") ? component.tag : "";
            tElement.Value = Data.HasOwnProperty(component, "value") ? component.value : "";
            tElement.OnPress = Data.HasOwnProperty(component, "onPress") ? component.onPress : "";
            tElement.OnRelease = Data.HasOwnProperty(component, "onRelease") ? component.onRelease : "";
            tElement.OnMouseIn = Data.HasOwnProperty(component, "onMouseIn") ? component.onMouseIn : "";
            tElement.OnMouseOut = Data.HasOwnProperty(component, "onMouseOut") ? component.onMouseOut : "";
            tElement.KeyBind = Data.HasOwnProperty(component, "keyBind") ? Convert.ToInt32(component.keyBind) : 0;
            tElement.EnableEvents = Data.HasOwnProperty(component, "enableEvents") ? Convert.ToUInt32(component.enableEvents) : 0u;
            tElement.HoldPause = Data.HasOwnProperty(component, "holdPause") ? Convert.ToBoolean(component.holdPause) : false;
            tElement.HoldMouseFocus = Data.HasOwnProperty(component, "holdMouseFocus") ? Convert.ToBoolean(component.holdMouseFocus) : false;
            tElement.HoldKeyFocus = Data.HasOwnProperty(component, "holdKeyFocus") ? Convert.ToBoolean(component.holdKeyFocus) : false;

            if (String.IsNullOrEmpty(rParentId))
            {
                tElement.SetParent("root");
            }
            else
            {
                tElement.SetParent(rParentId);
            }

            if (Data.HasOwnProperty(component, "styleClass"))
            {
                var classList = component.styleClass.ToString().Split(' ');
                foreach (var c in classList)
                {
                    tElement.SetStyleClass(c);
                }
            }

            if (Data.HasOwnProperty(component, "style"))
            {
                foreach (var prop in ((JObject)component.style).Properties())
                {
                    tElement.Style.SetProp(prop.Name, prop.Value.ToString());
                }
            }

            ElementList.Add(tElement);

            if (Data.HasOwnProperty(component, "children"))
            {
                foreach(var child in component.children)
                LoadElement(child, tElement.Id);
            }
        }

                        //detect mouse over
                        var x1 = iElement.ResolvedStyle._InnerX;
                        var y1 = iElement.ResolvedStyle._InnerY;
                        var x2 = x1 + iElement.ResolvedStyle._InnerW;
                        var y2 = y1 + iElement.ResolvedStyle._InnerH;

                        bool mouseInBounds;
                        if(iElement.ResolvedStyle.BackgroundOpacity == 0)
                        {
                            mouseInBounds = Agk.IsTextHitTest(iElementIndex, Agk.ScreenToWorldX(Hardware.Mouse.PosX), Agk.ScreenToWorldY(Hardware.Mouse.PosY));
                        }
                        else
                        {
                            mouseInBounds = Agk.IsSpriteHitTest(iElementIndex, Agk.ScreenToWorldX(Hardware.Mouse.PosX), Agk.ScreenToWorldY(Hardware.Mouse.PosY));
                        }

                        if (mouseInBounds)
                        {

using AgkSharp;
using System;

namespace AGKCore.UI
{
    public class CommonController : UI.Controller
    {
        public CommonController()
        {
            Dispatcher.Add(CommonController.DoHoverByType);
            Dispatcher.Add(CommonController.DoUnHoverByType);
            Dispatcher.Add(CommonController.DoPressByType);
            Dispatcher.Add(CommonController.DoReleaseByType);
            UserInterface.LoadPartial("media/ui/partials/common.json");
        }

        public static void DoHoverByType(object rArgs)
        {
            var tElement = UI.UserInterface.ElementList[Convert.ToInt32(rArgs)];
            switch (tElement.Tag)
            {
                case "button":
                    tElement.AddStyleClass(tElement.Name + "-pop");
                    break;
            }
        }

        public static void DoUnHoverByType(object rArgs)
        {
            var tElement = UI.UserInterface.ElementList[Convert.ToInt32(rArgs)];
            switch (tElement.Tag)
            {
                case "button":
                    tElement.RemoveStyleClass(tElement.Name + "-pop");
                    break;
            }
        }

        public static void DoPressByType(object rArgs)
        {
            var tElement = UI.UserInterface.ElementList[Convert.ToInt32(rArgs)];
            switch (tElement.Tag)
            {
                case "button":
                    tElement.AddStyleClass(tElement.Name + "-push");
                    break;
            }
        }

        public static void DoReleaseByType(object rArgs)
        {
            var tElement = UI.UserInterface.ElementList[Convert.ToInt32(rArgs)];
            switch (tElement.Tag)
            {
                case "button":
                    tElement.RemoveStyleClass(tElement.Name + "-push");
                    break;
            }
        }

    }

}

[
    {"type": "styleClass",
        "name": "btn-standard",
        "style": {
            "width": "150px",
            "height": "50px",
            "text-alignH": "center",
            "text-alignV": "center",
            "font-size": "32",
            "z-index": "5",
            "background-color": "#ff777777"
        }
    },
    {"type": "styleClass",
        "name": "btn-standard-pop",
        "style": {
            "width": "150px",
            "height": "50px",
            "text-alignH": "center",
            "text-alignV": "center",
            "background-color": "#ffdddddd",
            "color": "#ff333333"
        }
    },
    {"type": "styleClass",
        "name": "btn-standard-push",
        "style": {
            "width": "150px",
            "height": "50px",
            "text-alignH": "center",
            "text-alignV": "center",
            "background-color": "#ffbbbbbb"
        }
    },
    {"type": "styleClass",
        "name": "btn-text",
        "style": {
            "width": "250px",
            "height": "50px",
            "padding-left": "6%",
            "text-alignV": "center",
            "background-opacity": "0",
            "font-size": "32",
            "z-index": "5",
            "color": "#ffffffff"
        }
    },
    {"type": "styleClass",
        "name": "btn-text-pop",
        "style": {
            "font-size": "36"
        }
    },
    {"type": "styleClass",
        "name": "btn-text-push",
        "style": {
            "font-size": "32",
            "color": "#ffcccccc"
        }
    },
    {"type": "styleClass",
        "name": "btn-textSm",
        "style": {
            "width": "250px",
            "height": "50px",
            "padding-left": "6%",
            "text-alignV": "center",
            "background-opacity": "0",
            "font-size": "14",
            "z-index": "5",
            "color": "#ffffffff"
        }
    },
    {"type": "styleClass",
        "name": "btn-textSm-pop",
        "style": {
            "font-size": "16"
        }
    },
    {"type": "styleClass",
        "name": "btn-textSm-push",
        "style": {
            "font-size": "14",
            "color": "#ffcccccc"
        }
    },
]

[
    {
        "type": "element",
        "tag": "div",
        "id": "gameMenu",
        "holdMouseFocus": "true",
        "holdPause": "true",
        "enableEvents": "2",
        "keyBind": "27",
        "onPress": "GameMenuController.MenuOnPress",
        "style": {
            "width": "100%",
            "height": "100%",
            "display": "hidden"
        },
        "children": [
            {
                "type": "element",
                "tag": "button",
                "id": "btn-resume",
                "styleClass": "btn-text",
                "name": "btn-text",
                "value": "Resume",
                "enableEvents": "1",
                "onMouseIn": "CommonController.DoHoverByType",
                "onMouseOut": "CommonController.DoUnHoverByType",
                "onPress": "CommonController.DoPressByType",
                "onRelease": "GameMenuController.ResumeOnPress",
                "style": {
                    "position-alignV": "center",
                    "top": "-30px"
                }
            },
            {
                "type": "element",
                "tag": "button",
                "id": "btn-close",
                "styleClass": "btn-text",
                "name": "btn-text",
                "value": "Quit",
                "enableEvents": "1",
                "onMouseIn": "CommonController.DoHoverByType",
                "onMouseOut": "CommonController.DoUnHoverByType",
                "onPress": "CommonController.DoPressByType",
                "onRelease": "GameMenuController.QuitOnPress",
                "style": {
                    "position-alignV": "center",
                    "top": "30px"
                }
            }
        ]
    }
]

    public class Element : INotifyPropertyChanged
    {
        public string Id;
        public string Name;
        public string Tag;
        public Element Parent;
        public ObservableCollection<UI.StyleClass> StyleClassList = new ObservableCollection<StyleClass>();
        public StylePropertyData Style;
        public StylePropertyData ResolvedStyle;
        public string Value;
        public int ScrollX;
        public int ScrollY;
        public string OnPress; //name of callback function to execute on event
        public string OnRelease;
        public string OnMouseIn;
        public string OnMouseOut;
        public bool MouseIsOver; //mouse curser is within element bounds?
        public bool PressIsHeld; //mouseclick or hotkey press is held down?
        public int KeyBind = -1; //key id to act as hotkey to trigger onPress event
        public uint EnableEvents; //0 disabled | 1 enabled mouse | 2 enabled keybind | 3 enabled mouse and keybind | 4 enable drag and drop
        public uint EnableMove; //0-disabled | 1-freely drag around within parent bounds | 2-freely drag parent around within parent's parent bounds | 3-drag and drop from sockets
        public uint EnableSize; //grabbing an edge (2px?) or border will allow to resize the width/height
        public bool HoldPause; //gameplay is paused while element is visible
        public bool HoldMouseFocus; //gameplay ignores mouse input while element is visible
        public bool HoldKeyFocus; //gameplay ignores key input while element is visible
        public int SelectedIndex = -1;
        public bool IsDirty = true;

        public Element()
        {
            Style = new StylePropertyData(this);
            ResolvedStyle = new StylePropertyData(this);
            StyleClassList.CollectionChanged += StyleClassList_Changed;
        }

        public event PropertyChangedEventHandler PropertyChanged;

        public void SetParent(string rParentId)
        {
            Parent = UserInterface.ElementList.FirstOrDefault(el => el.Id == rParentId);
            Parent.IsDirty = true;
            IsDirty = true;
        }

        private void StyleClassList_Changed(object sender, NotifyCollectionChangedEventArgs e)
        {
            Parent.IsDirty = true;
            IsDirty = true;
        }

        public void AddStyleClass(string rStyleClass)
        {
            if(UserInterface.StyleClassList == null)
            {
                return;
            }
            var tStyleClass = UserInterface.StyleClassList.FirstOrDefault(cl => cl.ClassName == rStyleClass);
            if (tStyleClass != null)
            {
                StyleClassList.Add(tStyleClass);
            }
            else
            {
                //log warning
            }
        }

        public void RemoveStyleClass(string rStyleClass)
        {
            if (UserInterface.StyleClassList == null)
            {
                return;
            }
            var tStyleClass = UserInterface.StyleClassList.FirstOrDefault(cl => cl.ClassName == rStyleClass);
            if (tStyleClass != null)
            {
                StyleClassList.Remove(tStyleClass);
            }
            else
            {
                //log warning
            }
        }
    }

        public static void PreloadImages()
        {
            foreach(var i in StyleClassList)
            {
                if (!String.IsNullOrEmpty(i.Style.BackgroundImage))
                {
                    Media.GetImageAsset(i.Style.BackgroundImage, 1.0f, 1.0f);
                }
            }
            foreach (var i in ElementList)
            {
                if (!String.IsNullOrEmpty(i.Style.BackgroundImage))
                {
                    Media.GetImageAsset(i.Style.BackgroundImage, 1.0f, 1.0f);
                }
            }
        }

        public static void FadeScreen(int r, int g, int b, int a, int t)
        {
            var tSprite = Agk.CreateSprite(0);
            Agk.SetSpriteDepth(tSprite, 0);
            Agk.SetSpriteTransparency(tSprite, 1);
            Agk.SetSpriteSize(tSprite, App.Config.Screen.Width, App.Config.Screen.Height);
            float fadeLoading;
            var tMark = Agk.GetMilliseconds();
            if(a > 0)
            {
                Agk.SetSpriteColor(tSprite, r, g, b, 0);
                fadeLoading = 0.0f;
                while(fadeLoading < 255.0f)
                {
                    fadeLoading = 0.0f + ((255.0f / t) * Agk.Abs(Agk.GetMilliseconds() - tMark));
                    Agk.SetSpriteColorAlpha(tSprite, (int)fadeLoading);
                    Agk.Sync();
                }
            }
            else
            {
                Agk.SetSpriteColor(tSprite, r, g, b, 255);
                fadeLoading = 255.0f;
                while (fadeLoading > 0.0f)
                {
                    fadeLoading = 255.0f - ((255.0f / t) * Agk.Abs(Agk.GetMilliseconds() - tMark));
                    Agk.SetSpriteColorAlpha(tSprite, (int)fadeLoading);
                    Agk.Sync();
                }
            }
            Agk.DeleteSprite(tSprite);
        }

            while (App.LoopAGK())
            {
#if DEBUG
                App.Log("Program.cs", 1, "main", "--- Begin main loop ---");
#endif
                //Always update timing, and do it first
                App.UpdateTiming();
#if DEBUG
                App.Log("Program.cs", 1, "main", "Processing " + App.UpdateList.Count.ToString() + " updates in queue");
#endif
                foreach (var u in App.UpdateList)
                {
                    if (!App.Status.IsRunning)
                    {
                        break;
                    }
                    if(App.Timing.PauseState != 1 || u.IgnorePause)
                    {
#if DEBUG
                        App.Log("Program.cs", 1, "main", "Process from queue " + u.FunctionName);
#endif
                        
                        Dispatcher.Invoke(u.FunctionName, null);
                    }
                }
                if (!App.Status.IsRunning)
                {
                    break;
                }

                Agk.Print(Agk.ScreenFPS());

                if(App.Timing.Timer - testMark > 3000)
                {
                    int r = (int)Agk.Random(0, 255);
                    int g = (int)Agk.Random(0, 255);
                    int b = (int)Agk.Random(0, 255);
                    UI.UserInterface.FadeScreen(r, g, b, 1, 1200);
                    Agk.Sleep(1200);
                    UI.UserInterface.FadeScreen(r, g, b, 0, 1200);
                    testMark = Agk.GetMilliseconds();
                }

                Agk.Sync();
            }

        public static void UpdateTransitions(object rArgs)
        {
            if(TransitionList.Count == 0)
            {
                return;
            }

            float tElapsed;
            float tInit;
            float tTarget;
            int tVal;

            for(int i = TransitionList.Count - 1; i >= 0; --i)
            {
                var tran = TransitionList[i];
                tElapsed = App.Timing.Timer - tran.Start * 1.0f;

                if (tran.InitialValue.Contains("px"))
                {
                    tInit = Convert.ToSingle(tran.InitialValue.Substring(0, tran.InitialValue.Length - 2));
                }
                else
                {
                    if (tran.InitialValue.Contains("%"))
                    {
                        tInit = Convert.ToSingle(tran.InitialValue.Substring(0, tran.InitialValue.Length - 1));
                    }
                    else
                    {
                        tInit = Convert.ToSingle(tran.InitialValue);
                    }
                }

                if (tran.TargetValue.Contains("px"))
                {
                    tTarget = Convert.ToSingle(tran.TargetValue.Substring(0, tran.TargetValue.Length - 2));
                }
                else
                {
                    if (tran.TargetValue.Contains("%"))
                    {
                        tTarget = Convert.ToSingle(tran.TargetValue.Substring(0, tran.TargetValue.Length - 1));
                    }
                    else
                    {
                        tTarget = Convert.ToSingle(tran.TargetValue);
                    }
                }

                if (tElapsed < tran.Duration)
                {
                    tVal = (int)Math.Floor(tInit + (((tTarget - tInit) / tran.Duration) * tElapsed));
                    tran.Element.Style.SetProp(tran.Property, tVal.ToString());
                    if (tTarget > tInit)
                    {
                        if(tVal >= tTarget)
                        {
                            if (!String.IsNullOrEmpty(tran.Callback))
                            {
                                Dispatcher.Invoke(tran.Callback, tran.Element.Id);
                            }
                            TransitionList.RemoveAt(i);
                        }
                    }
                    else
                    {
                        if(tVal <= tTarget)
                        {
                            if (!String.IsNullOrEmpty(tran.Callback))
                            {
                                Dispatcher.Invoke(tran.Callback, tran.Element.Id);
                            }
                            TransitionList.RemoveAt(i);
                        }
                    }
                }
                else
                {
                    tran.Element.Style.SetProp(tran.Property, tTarget.ToString());
                    if (!String.IsNullOrEmpty(tran.Callback))
                    {
                        Dispatcher.Invoke(tran.Callback, tran.Element.Id);
                    }
                    TransitionList.RemoveAt(i);
                }
            }
        }

        public static void MenuOnPress(object rArgs)
        {
            var tElement = UI.UserInterface.ElementList[Convert.ToInt32(rArgs)];
            if(tElement.Style.Display == "hidden")
            {
                tElement.Style.SetProp("display", "visible");

                tElement = UserInterface.GetElementById("btn-resume");
                tElement.Style.SetProp("opacity", "1");
                var tTran = new UI.TransitionData()
                {
                    Element = tElement,
                    InitialValue = "1",
                    TargetValue = "100",
                    Property = "opacity",
                    Duration = 1200,
                    Start = App.Timing.Timer
                };
                UserInterface.TransitionList.Add(tTran);
                tTran = new UI.TransitionData()
                {
                    Element = tElement,
                    InitialValue = "-1000px",
                    TargetValue = tElement.Style.Top,
                    Property = "top",
                    Duration = 800,
                    Start = App.Timing.Timer
                };
                UserInterface.TransitionList.Add(tTran);

                tElement = UserInterface.GetElementById("btn-close");
                tElement.Style.SetProp("opacity", "1");
                tTran = new UI.TransitionData()
                {
                    Element = tElement,
                    InitialValue = "1",
                    TargetValue = "100",
                    Property = "opacity",
                    Duration = 1200,
                    Start = App.Timing.Timer
                };
                UserInterface.TransitionList.Add(tTran);
                tTran = new UI.TransitionData()
                {
                    Element = tElement,
                    InitialValue = "1000px",
                    TargetValue = tElement.Style.Top,
                    Property = "top",
                    Duration = 800,
                    Start = App.Timing.Timer
                };
                UserInterface.TransitionList.Add(tTran);
            }
            else
            {
                tElement.Style.SetProp("display", "hidden");
            }
        }

[System.Diagnostics.Conditional("DEBUG")]
public static void Log(int rLevel, string rChannel, string rContent)
{
	StackTrace st = new StackTrace(true);
	if (st == null) 
		return;

	string source = st.GetFrame(1).GetMethod().Name;
	//string SourcePath = st.GetFrame(1).GetFileName();		// maybe this is usefull 
	//int SourceLine = st.GetFrame(1).GetFileLineNumber();		// maybe this is usefull
	
	if(rLevel >= App.Config.Log.Level)
	{
		if(App.Config.Log.Channels == "*" || App.Config.Log.Channels.Contains("|" + rChannel + "|"))
		{
			System.IO.File.AppendAllText(App.Config.Log.File, DateTime.Now.ToString("HH:mm:ss.fff") + " | " + source.PadRight(24) + " | " + rLevel.ToString().PadRight(5) + " | " + rChannel.PadRight(10) + " | " + rContent + Environment.NewLine);
		}
	}
}

...
        public static ImageAsset GetImageAsset(string rFilename, float rScaleX, float rScaleY)
        {
#if DEBUG
            App.Log("Media.cs", 2, "media", "Requested image: " + rFilename + " " + rScaleX.ToString() + " " + rScaleY.ToString());
#endif  
            foreach (var i in Media.ImageList)
            {
...

...
        public static ImageAsset GetImageAsset(string rFilename, float rScaleX, float rScaleY)
        {
            App.Log(2, "media", "Requested image: " + rFilename + " " + rScaleX.ToString() + " " + rScaleY.ToString());

            foreach (var i in Media.ImageList)
            {
...

SetErrorMode(2)
SetWindowTitle( "temp" )
SetWindowSize( 1024, 768, 0 )
SetWindowAllowResize( 1 )
SetVirtualResolution( 1024, 768 )
SetOrientationAllowed( 1, 1, 1, 1 )
SetSyncRate( 30, 0 )
SetScissor( 0,0,0,0 )
UseNewDefaultFonts( 1 )

hres=640
vres=480
Setvirtualresolution(hres,vres)
SetClearColor (0, 200, 200 )

ResetTimer()

tObj = LoadObjectWithChildren("test03.dae")

mark = GetMilliseconds()

ay as float
ay = 45.0

animTime as float
animFrame as float
animFrame = 1.0

keyedFPS as float
keyedFPS = 25.0

speedFactor as float
speedFactor = 1.0

minFrame as float
maxFrame as float
minFrame = 1.0
maxFrame = 200.0

Do

	elapsed# = (GetMilliseconds() - mark) * 0.001
	mark = GetMilliseconds()

	animFrame = animFrame + (keyedFPS * speedFactor * elapsed#)
	if animFrame > maxFrame then animFrame = minFrame
	animTime = (animFrame * GetObjectAnimationDuration(tObj, "")) / maxFrame

	SetObjectAnimationFrame(tObj, "", animTime, 0.0)
	SetObjectRotation(tObj, 0.0, ay, 0.0)

	print("animTime: " + str(animTime) + " / " + str(GetObjectAnimationDuration(tObj, "")))
	print("animFrame: " + str(animFrame, 2) + " / " + str(maxFrame))
	print(GetObjectNumAnimations(tObj))
	for i = 0 to GetObjectNumAnimations(tObj)
		print("|" + GetObjectAnimationName(tObj, i) + "|")
	next i
	Sync()
Loop
End

/*
	-------------------------------------------------------------------------------------
	3d Object Animation
	-------------------------------------------------------------------------------------
	Author: Josh Kirklin (Ortu)
	-------------------------------------------------------------------------------------
	Contributors:
	-------------------------------------------------------------------------------------

	Description:

		Provides handling for the loading, handling, and playback of bone-based keyframe animation for 3d objects.

	*******************************************
	Plugin Dependancies:

		Matrix1Util_02.dll (IanM) - timing
		Matrix1Util_05.dll (IanM) - find free
		Matrix1Util_07.dll (IanM) - general
		Matrix1Util_16.dll (IanM) - strings

	*******************************************
	Classes:

		Requires system.dbx
		Requires media.dbx

		=========================================
		Defines STATIC CLASS: Anim3d

			------------------------
			public functions:

				Anim3d_updateActiveAnimations()
					-

				Anim3d_addAppliedAnimation(rAnim as CLASS_AppliedAnimation3d)
					-

				Anim3d_clearAppliedAnimations(rObjectNum as integer)
					-

				Anim3d_getActiveAnimationByObjectNumber(rObjectNum as integer)
					-

				Anim3d_getAnimSetNumber(rFilename as string)
					-

			------------------------
			public data

				Anim3d.animResult as Anim3d_type_activeAnimationData
					-

			------------------------
			private functions

				_Anim3d_init()
					-

				_Anim3d_loadObjectAnimation(rFilename as string, rAnimSetNum as integer)
					-

			------------------------
			private data:

				_Anim3d_animSets[] as Anim3d_type_animationSetData
					-

				_Anim3d_animVariants[] as Anim3d_type_variantData
					-

	*******************************************
	Notes:



*/

anim3d_module_init:

	<?System_log("anim3d.dbx", 2, "main", "Begin module load: anim3d.")?>
	App_updateSplashScreen("- Animation")

	`Declare Anim3d -----------------------------------------------------------

	type Anim3d_type_animationSetData
		file as string
		animSetNum as integer
		keyName as string
		firstFrame as integer
		lastFrame as integer
		enableVariants as boolean
		moveLocked as boolean
	endtype

	type Anim3d_type_variantData
		animSetNum as integer
		baseKeyName as string `name of variant 0 sans id# ie 'idle0' = 'idle'
		baseLen as integer `length of name sans id# ie 'idle0' = 4
		variantCount as integer
	endtype

	type Anim3d_type_activeAnimationData
		index as integer
		keyName as string
		animSetNum as integer
	endtype

	type STATIC_CLASS_Anim3d
		nextAnimSetNum as integer
		keyedFPS as integer
		minVariantDelay as integer
		maxVariantDelay as integer
		animResult as Anim3d_type_activeAnimationData
	endtype

	`private data -------------------------------------------------------------

	dim _Anim3d_animSets[] as Anim3d_type_animationSetData
	dim _Anim3d_animVariants[] as Anim3d_type_variantData
	dim _Anim3d_appliedAnimations[] as CLASS_AppliedAnimation3d
	dim _Anim3d_processedObjects[] as integer

	`public data --------------------------------------------------------------

	dim Anim3d_deferredAnimationFlush[] as integer

	`Declare AppliedAnimation3d -----------------------------------------------------------

	type CLASS_AppliedAnimation3d
		objectNum as integer // req //TODO: use object's guid$ instead ?
		animSetNum as integer // req
		keyName as string // req?
		speedFactor as float //opt default 1.0
		enableLoop as boolean //opt default false
		callback as string // opt
		callbackArgs as string // opt
		//Do not set below props when creating a new object: (these are handled by the system)
		currentFrame as float //animation does not progress if this uses integer
		firstFrame as integer
		lastFrame as integer
		variantCount as integer
		variantMark as integer
		variantDelay as integer
		moveLocked as boolean
	endtype

	`private data -------------------------------------------------------------



	`public data --------------------------------------------------------------



	`Init ---------------------------------------------------------------------

	`==================================

	GLOBAL Anim3d as STATIC_CLASS_Anim3d

	$construct CLASS_AppliedAnimation3d{
		objectNum = -1
		animSetNum = -1
		speedFactor = 1.0
		enableLoop = FALSE
	}

	`==================================

	_Anim3d_init()

	<?System_log("anim3d.dbx", 2, "main", "End module load: anim3d.")?>

return


function _Anim3d_init()

	Anim3d.keyedFPS = 30
	Anim3d.minVariantDelay = 15000
	Anim3d.maxVariantDelay = 65000

	`register updates
	App_addUpdate("Anim3d_updateActiveAnimations", "", FALSE)

	`inject new dependancies
	App_addRequiredToUpdate("Media_updateBoundObjects", "Anim3d_updateActiveAnimations")

endfunction


function Anim3d_unload()
	empty array _Anim3d_animSets[]
	empty array _Anim3d_animVariants[]
	empty array _Anim3d_appliedAnimations[]
	empty array _Anim3d_processedObjects[]
	empty array Anim3d_deferredAnimationFlush[]
endfunction


function Anim3d_updateActiveAnimations()

	local objHasProcessed as boolean
	local loopIsDone as boolean

	local i as integer
	local c as integer
	local totalCountProcessed as integer
	local tSetIndex as integer
	local newVariant as integer
	local GCcount as integer
	local GCindex as integer

	local appliedDelta as float
	local newFrame as float


	<?System_log("anim3d.dbx", 2, "main", "Begin Update: Anim3d_updateActiveAnimations")?>

	//updateMark as dword
	//updateMark = hitimer(1000000)

	empty array _Anim3d_processedObjects[]

	for i = 0 to array count(_Anim3d_appliedAnimations[])
		<?System_log("anim3d.dbx", 1, "anim3d", " > checking if object exists: " + str$(_Anim3d_appliedAnimations[i].objectNum) + " using key: " + _Anim3d_appliedAnimations[i].keyName + " with callback: " + _Anim3d_appliedAnimations[i].callback)?>
		if object exist(_Anim3d_appliedAnimations[i].objectNum)

			objHasProcessed = FALSE
			totalCountProcessed = array count(_Anim3d_processedObjects[])
			if totalCountProcessed > -1
				for c = 0 to totalCountProcessed
					if _Anim3d_processedObjects[c] = _Anim3d_appliedAnimations[i].objectNum
						objHasProcessed = TRUE
						exit
					endif
				next c
			endif

			if objHasProcessed = FALSE

				appliedDelta = System.timing.delta - System.timing.pauseElapsed

				newFrame = _Anim3d_appliedAnimations[i].currentFrame + (Anim3d.keyedFPS * _Anim3d_appliedAnimations[i].speedFactor * 0.001 * appliedDelta)

				if newFrame < _Anim3d_appliedAnimations[i].firstFrame
					newFrame = _Anim3d_appliedAnimations[i].firstFrame
				endif

				if newFrame >= _Anim3d_appliedAnimations[i].lastFrame

					if _Anim3d_appliedAnimations[i].enableLoop

						newFrame = _Anim3d_appliedAnimations[i].firstFrame

						_Anim3d_appliedAnimations[i].currentFrame = newFrame

						set object frame _Anim3d_appliedAnimations[i].objectNum, newFrame

						`check for variant switch
						for c = 0 to array count(_Anim3d_animSets[])
							if _Anim3d_animSets[c].animSetNum = _Anim3d_appliedAnimations[i].animSetNum
								tSetIndex = c
								exit
							endif
						next c
						if _Anim3d_animSets[tSetIndex].enableVariants
							if abs(System.timing.timer - _Anim3d_appliedAnimations[i].variantMark) > _Anim3d_appliedAnimations[i].variantDelay
								newVariant = 1 + rnd(_Anim3d_appliedAnimations[i].variantCount - 1)
								for c = 0 to array count(_Anim3d_animVariants[])
									if _Anim3d_animVariants[c].animSetNum = _Anim3d_appliedAnimations[i].animSetNum
										if _Anim3d_animVariants[c].baseKeyName + str$(newVariant) = _Anim3d_appliedAnimations[i].keyName
											_Anim3d_appliedAnimations[i].firstFrame = _Anim3d_animSets[tSetIndex].firstFrame
											_Anim3d_appliedAnimations[i].lastFrame = _Anim3d_animSets[tSetIndex].lastFrame
											exit
										endif
									endif
								next c
								_Anim3d_appliedAnimations[i].variantMark = System.timing.timer
								_Anim3d_appliedAnimations[i].variantDelay = Anim3d.minVariantDelay + rnd(Anim3d.maxVariantDelay)
							endif
						endif

						array insert at bottom _Anim3d_processedObjects[]
						_Anim3d_processedObjects[] = _Anim3d_appliedAnimations[i].objectNum

						`handle loop callback
						<?System_log("anim3d.dbx", 1, "anim3d", " > checking loopIsDone callback")?>
						loopIsDone = FALSE
						if _Anim3d_appliedAnimations[i].callback > ""
							loopIsDone = App_callFunction(_Anim3d_appliedAnimations[i].callback, _Anim3d_appliedAnimations[i].callbackArgs)
							<?System_log("anim3d.dbx", 1, "anim3d", "  loopIsDone: " + str$(loopIsDone))?>
							if loopIsDone
								<?System_log("anim3d.dbx", 1, "anim3d", "  > loop completed cycle, loop condition failed. flag applied animation for obj " + str$(_Anim3d_appliedAnimations[i].objectNum) + " to GC -1")?>
								_Anim3d_appliedAnimations[i].objectNum = -1
								inc GCcount
								GCindex = i
							endif
						endif

					else

						`played once, end the sequence and remove
						newFrame = _Anim3d_appliedAnimations[i].lastFrame
						set object frame _Anim3d_appliedAnimations[i].objectNum, newFrame

						array insert at bottom _Anim3d_processedObjects[]
						_Anim3d_processedObjects[] = _Anim3d_appliedAnimations[i].objectNum

						<?System_log("anim3d.dbx", 1, "anim3d", "  > played once and finished. flag applied animation for obj " + str$(_Anim3d_appliedAnimations[i].objectNum) + " to GC -1")?>
						if _Anim3d_appliedAnimations[i].callback > ""
							<?System_log("anim3d.dbx", 1, "anim3d", " > Executing callback play once finished: " + _Anim3d_appliedAnimations[i].callback + " " + _Anim3d_appliedAnimations[i].callbackArgs)?>
							loopIsDone = App_callFunction(_Anim3d_appliedAnimations[i].callback, _Anim3d_appliedAnimations[i].callbackArgs)
						endif

						_Anim3d_appliedAnimations[i].objectNum = -1
						inc GCcount
						GCindex = i

					endif

				else

					`sequence is not complete, continue it
					_Anim3d_appliedAnimations[i].currentFrame = newFrame

					set object frame _Anim3d_appliedAnimations[i].objectNum, newFrame

					array insert at bottom _Anim3d_processedObjects[]
					_Anim3d_processedObjects[] = _Anim3d_appliedAnimations[i].objectNum

					`handle variable length animation callback
					<?System_log("anim3d.dbx", 1, "anim3d", " > checking loopIsDone callback")?>
					loopIsDone = FALSE
					if _Anim3d_appliedAnimations[i].enableLoop and _Anim3d_appliedAnimations[i].callback > ""
						loopIsDone = App_callFunction(_Anim3d_appliedAnimations[i].callback, _Anim3d_appliedAnimations[i].callbackArgs)
						<?System_log("anim3d.dbx", 1, "anim3d", "  loopIsDone: " + str$(loopIsDone))?>
						if loopIsDone
							<?System_log("anim3d.dbx", 1, "anim3d", "  > loop not complete, loop condition failed. flag applied animation for obj " + str$(_Anim3d_appliedAnimations[i].objectNum) + " to GC -1")?>
							_Anim3d_appliedAnimations[i].objectNum = -1
							inc GCcount
							GCindex = i
						endif
					endif

				endif
			endif
		else
			_Anim3d_appliedAnimations[i].objectNum = -1
			inc GCcount
			GCindex = i
		endif
	next i

	`process deferred flush
	for i = 0 to array count(Anim3d_deferredAnimationFlush[])
		for c = 0 to array count(_Anim3d_appliedAnimations[])
			if _Anim3d_appliedAnimations[c].objectNum = Anim3d_deferredAnimationFlush[i]
				<?System_log("anim3d.dbx", 1, "anim3d", "  > process deferred flush. flagged " + _Anim3d_appliedAnimations[c].keyName + " on obj " + str$(_Anim3d_appliedAnimations[c].objectNum) + " to GC -1")?>
				_Anim3d_appliedAnimations[c].objectNum = -1
				inc GCcount
				GCindex = c
			endif
		next c
	next i
	empty array Anim3d_deferredAnimationFlush[]

	`garbage collect
	<?System_log("anim3d.dbx", 1, "anim3d", " > garbage collect anim3d, total: " + str$(GCcount))?>
	if GCcount > 0
		if GCcount > 1
			for c = 1 to GCcount
				for i = 0 to array count(_Anim3d_appliedAnimations[])
					if _Anim3d_appliedAnimations[i].objectNum = -1
						<?System_log("anim3d.dbx", 1, "anim3d", "  deleting: " + _Anim3d_appliedAnimations[i].keyName)?>
						array delete element _Anim3d_appliedAnimations[], i
						exit
					endif
				next i
			next c
		else
			<?System_log("anim3d.dbx", 1, "anim3d", "  deleting: " + _Anim3d_appliedAnimations[GCindex].keyName + " from object " + str$(_Anim3d_appliedAnimations[i].objectNum))?>
			array delete element _Anim3d_appliedAnimations[], GCindex
		endif
	endif

	<?System_log("anim3d.dbx", 2, "main", "End Update: Anim3d_updateActiveAnimations," /*+ str$(hitimer(1000000) - updateMark) + "us"*/)?>


endfunction


function _Anim3d_loadObjectAnimation(rFilename as string, rAnimSetNum as integer)

	<?System_log("anim3d.dbx", 2, "anim3d", "Loading animation config file: "+ rFilename +" to setNum: "+ str$(rAnimSetNum))?>

	fHandle = find free file()
	open to read fHandle, rFilename

	while file end(fHandle) = FALSE
		read string fHandle, inputData$
		tKeyName$ = fast lower$(first token$(inputData$, ","))
		tFirstFrame = intval(next token$(","))
		tLastFrame = intval(next token$(","))
		tHasVariants = intval(next token$(","))
		tDoesMoveLock = intval(next token$(","))

		if tFirstFrame > 0
			<?System_log("anim3d.dbx", 1, "anim3d", "> adding key: " + tKeyName$)?>
			if tHasVariants
				<?System_log("anim3d.dbx", 1, "anim3d", "  key has variants")?>
				isNewKey = TRUE
				for i = 0 to array count(_Anim3d_animVariants[])
					if _Anim3d_animVariants[i].baseKeyName = tKeyName$
						isNewKey = FALSE
						inc _Anim3d_animVariants[i].variantCount
						exit
					endif
				next i
				if isNewKey
					array insert at bottom _Anim3d_animVariants[]
					_Anim3d_animVariants[].animSetNum = rAnimSetNum
					_Anim3d_animVariants[].baseKeyName = tKeyName$
					_Anim3d_animVariants[].baseLen = fast len(tKeyName$)
					_Anim3d_animVariants[].variantCount = 0
					tKeyName$ = tKeyName$ + str$(_Anim3d_animVariants[].variantCount)
				endif
			endif

			array insert at bottom _Anim3d_animSets[]
			_Anim3d_animSets[].animSetNum = rAnimSetNum
			_Anim3d_animSets[].keyName = tKeyName$
			_Anim3d_animSets[].firstFrame = tFirstFrame
			_Anim3d_animSets[].lastFrame = tLastFrame
			_Anim3d_animSets[].enableVariants = tHasVariants
			_Anim3d_animSets[].moveLocked = tDoesMoveLock
			<?System_log("anim3d.dbx", 1, "anim3d", "  " + tKeyName$ + " added")?>
		endif
	endwhile

	close file fHandle

endfunction TRUE


function Anim3d_addAppliedAnimation(rAnim as CLASS_AppliedAnimation3d)

	<?System_log("anim3d.dbx", 1, "anim3d", "Requested apply animation: " + rAnim.keyName + " to queue for objectNum: " + str$(rAnim.objectNum) + " speedFactor: " + str$(rAnim.speedFactor))?>

	rAnim.keyName = fast lower$(rAnim.keyName)

	`check for variants, default to base variant
	tVariantCount = -1
	for tVariantIndex = 0 to array count(_Anim3d_animVariants[])
		if _Anim3d_animVariants[tVariantIndex].animSetNum = rAnim.animSetNum
			if _Anim3d_animVariants[tVariantIndex].baseKeyName = fast left$(rAnim.keyName, _Anim3d_animVariants[tVariantIndex].baseLen)
				rAnim.keyName = rAnim.keyName + "0"
				tVariantCount = _Anim3d_animVariants[tVariantIndex].variantCount
				exit
			endif
		endif
	next tVariantIndex

	`get animation data by set and key
	for i = 0 to array count(_Anim3d_animSets[])
		if _Anim3d_animSets[i].animSetNum = rAnim.animSetNum
			if _Anim3d_animSets[i].keyName = rAnim.keyName

				array insert at bottom _Anim3d_appliedAnimations[]

				_Anim3d_appliedAnimations[].objectNum = rAnim.objectNum
				_Anim3d_appliedAnimations[].animSetNum = rAnim.animSetNum
				_Anim3d_appliedAnimations[].keyName = rAnim.keyName
				_Anim3d_appliedAnimations[].enableLoop = rAnim.enableLoop
				_Anim3d_appliedAnimations[].speedFactor = rAnim.speedFactor
				_Anim3d_appliedAnimations[].callback = rAnim.callback
				_Anim3d_appliedAnimations[].callbackArgs = rAnim.callbackArgs

				_Anim3d_appliedAnimations[].currentFrame = _Anim3d_animSets[i].firstFrame
				_Anim3d_appliedAnimations[].firstFrame = _Anim3d_animSets[i].firstFrame
				_Anim3d_appliedAnimations[].lastFrame = _Anim3d_animSets[i].lastFrame
				_Anim3d_appliedAnimations[].moveLocked = _Anim3d_animSets[i].moveLocked

				if _Anim3d_animSets[i].enableVariants
					_Anim3d_appliedAnimations[].variantCount = tVariantCount
					`set random variation change delay
					_Anim3d_appliedAnimations[].variantMark = timer()
					_Anim3d_appliedAnimations[].variantDelay = Anim3d.minVariantDelay + (rnd(Anim3d.maxVariantDelay - Anim3d.minVariantDelay))
				endif

				<?System_log("anim3d.dbx", 1, "anim3d", "> Applied. key: " + _Anim3d_appliedAnimations[].keyName + " obj: " + str$(_Anim3d_appliedAnimations[].objectNum) + " speed: " + str$(_Anim3d_appliedAnimations[].speedFactor) + " loop: " + str$(_Anim3d_appliedAnimations[].enableLoop))?>
				exitfunction
			endif
		endif
	next i
	<?System_log("anim3d.dbx", 3, "anim3d", "WARNING: Requested animation key "+ rAnim.keyName +" was not found. Did not add to queue.")?>
endfunction


function Anim3d_clearAppliedAnimations(rObjectNum as integer)
	<?System_log("anim3d.dbx", 1, "anim3d", "Begin flush applied animations for object number " + str$(rObjectNum))?>
	GCcount = 0
	GCindex = -1
	for i = 0 to array count(_Anim3d_appliedAnimations[])
		if _Anim3d_appliedAnimations[i].objectNum = rObjectNum
			_Anim3d_appliedAnimations[i].objectNum = -1
			inc GCcount
			GCindex = i
		endif
	next i
	if GCcount > 0
		if GCcount > 1
			for c = 1 to GCcount
				for i = 0 to array count(_Anim3d_appliedAnimations[])
					if _Anim3d_appliedAnimations[i].objectNum = -1
						array delete element _Anim3d_appliedAnimations[], i
					endif
				next i
			next c
		else
			array delete element _Anim3d_appliedAnimations[], GCindex
		endif
	endif
endfunction


function Anim3d_clearAppliedAnimationsDeferred(rObjectNum as integer)
	array insert at bottom Anim3d_deferredAnimationFlush[]
	Anim3d_deferredAnimationFlush[] = rObjectNum
endfunction


function Anim3d_getActiveAnimationByObjectNumber(rObjectNum as integer)
	Anim3d.animResult.index = -1
	Anim3d.animResult.keyName = ""
	Anim3d.animResult.animSetNum = -1
	for i = 0 to array count(_Anim3d_appliedAnimations[])
		if _Anim3d_appliedAnimations[i].objectNum = rObjectNum
			Anim3d.animResult.index = i
			Anim3d.animResult.keyName = _Anim3d_appliedAnimations[i].keyName
			Anim3d.animResult.animSetNum = _Anim3d_appliedAnimations[i].animSetNum
			exitfunction
		endif
	next i
endfunction


function Anim3d_isMoveAllowed(rObjectNum as integer)
	for i = 0 to array count(_Anim3d_appliedAnimations[])
		if _Anim3d_appliedAnimations[i].objectNum = rObjectNum
			if _Anim3d_appliedAnimations[i].moveLocked
				exitfunction FALSE
			else
				exitfunction TRUE
			endif
		endif
	next i
endfunction -1


function Anim3d_getAnimSetNumber(rFilename as string)
	rFilename = fast lower$(rFilename)
	tSet = -1

	<?System_log("anim3d.dbx", 1, "anim3d", "Requested animation set for file: " + rFilename)?>

	for i = 0 to array count(_Anim3d_animSets[])
		if _Anim3d_animSets[i].file = rFilename
			tSet = _Anim3d_animSets[i].animSetNum
			exitfunction tSet
		endif
	next i

	`set has not been loaded, verify file and load
	if file exist(rFilename)
		tSet = Anim3d.nextAnimSetNum
		if _Anim3d_loadObjectAnimation(rFilename, tSet)
			array insert at bottom _Anim3d_animSets[]
			_Anim3d_animSets[].file = rFilename
			_Anim3d_animSets[].animSetNum = tSet
			inc Anim3d.nextAnimSetNum
			exitfunction tSet
		else
			System_log("anim3d.dbx", 4, "error", "ERROR: Could not process requested animation file: " + rFilename)
			App_closeGame(TRUE)
		endif
	else
		System_log("anim3d.dbx", 4, "error", "ERROR: Requested animation file not found: " + rFilename)
		App_closeGame(TRUE)
	endif

endfunction tSet

using AgkSharp;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Linq;

namespace AGKCore
{
    public class AnimationHandler
    {
        private List<Animation> _animationList = new List<Animation>();

        public AnimationHandler()
        {
            
        }

        public static void LoadAnimation(string rFilename)
        {

        }

        public static void UnloadAllAnimation()
        {

        }

    }

    public class Animation
    {
        public string FileName;
        public string Name;
        public int FirstFrame;
        public int LastFrame;
        public int Framerate = 30;
        public bool IsMoveEnabled;
        //public bool IsVariantEnabled; // TODO: hold list of variants?
        public int VariantDelayMin = 15000;
        public int VariantDelayMax = 65000;
    }

    public class AppliedAnimation
    {
        public Animation Animation;
        public float Speed = 1.0f;
        public bool IsLoop = false;
        public string Callback;
        public string CallbackArgs;
        public float CurrentFrame;
        public int VariantMark;
        public int VariantDelay;

        public AppliedAnimation()
        {

        }
    }

}

0000I,,,,passive-idle-stationary-standard
0000L,1,91,t,
0000L,92,165,t,
0000L,166,239,t,
0110I,330,360,f,passive-moving-walking-standard
0110L,361,420,f,
0120I,421,435,f,passive-moving-running-standard
0120L,436,479,f,
0130I,480,494,f,passive-moving-sprinting-standard
0130L,495,538,f,
0240I,615,629,f,passive-jumping-forced-standard
0240L,629,629,f,
0240O,629,639,f,
0340I,629,639,f,passive-falling-forced-standard
0340L,639,639,f,
0340O,639,658,f,
1000I,240,258,f,sneaking-idle-stationary-standard
1000L,259,329,f,
1000O,,,,
1040I,,,,sneaking-idle-forced-standard
1040L,,,,
1040O,,,,
1041I,,,,sneaking-idle-forced-strafeRight
1041L,,,,
1041O,,,,
1042I,,,,sneaking-idle-forced-strafeLeft
1042L,,,,
1042O,,,,
1043I,,,,sneaking-idle-forced-backstep
1043L,,,,
1043O,,,,
1110I,539,554,f,sneaking-moving-walking-standard
1110L,555,614,f,
1110O,,,f,
1111I,,,,sneaking-moving-walking-strafeRight
1111L,,,,
1111O,,,,
1112I,,,,sneaking-moving-walking-strafeLeft
1112L,,,,
1112O,,,,
1113I,,,,sneaking-moving-walking-backstep
1113L,,,,
1113O,,,,

[
	{
		"desc": "passive-idle-stationary-standard",
		"name": "0000L",
		"keys": [
			[1, 91],
			[92, 165],
			[166, 239]
		]
	},
	{
		"desc": "passive-moving-walking-standard",
		"name": "0110I",
		"keys": [
			[330, 360]
		]
	},
	{
		"name": "0110L",
		"keys": [
			[361, 420]
		]
	},
	{
		"name": "0110O",
		"keys": [
			[421, 450]
		]
	},
]

using AgkSharp;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Linq;

namespace AGKCore
{
    public class AnimationHandler
    {
        private static List<AnimationSet> _AnimationList = new List<AnimationSet>();

        public AnimationHandler()
        {
            
        }

        public static void LoadAnimation(string rFile)
        {
            string doc = System.IO.File.ReadAllText(rFile);
            _AnimationList.Add(new AnimationSet()
            {
                Name = rFile,
                Animations = JsonConvert.DeserializeObject<List<Animation>>(doc)
            });
        }

        public static void UnloadAllAnimation()
        {
             _AnimationList.Clear();
        }

    }

    public class AnimationSet
    {
        public string Name;
        public List<Animation> Animations = new List<Animation>();
    }

    public class Animation
    {
        public string Name;
        public int Framerate = 30;
        public bool IsMoveEnabled = true;
        public int VariantDelayMin = 15000;
        public int VariantDelayMax = 65000;
        public List<int[]> Keys = new List<int[]>();
    }

    public class AppliedAnimation
    {
        public Animation Animation;
        public float Speed = 1.0f;
        public bool IsLoop = false;
        public string Callback;
        public string CallbackArgs;
        public float CurrentFrame;
        public int VariantMark;
        public int VariantDelay;

        public AppliedAnimation()
        {

        }
    }

}

using AgkSharp;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Linq;

namespace AGKCore
{
    public class AnimationHandler
    {
        private static List<AnimationSet> _AnimationList = new List<AnimationSet>();

        public AnimationHandler()
        {
            
        }

        public static void LoadAnimation(string rFile)
        {
            string doc = System.IO.File.ReadAllText(rFile);
            _AnimationList.Add(new AnimationSet()
            {
                Name = rFile,
                Animations = JsonConvert.DeserializeObject<List<Animation>>(doc)
            });
        }

        public static void UnloadAllAnimation()
        {
            _AnimationList.Clear();
        }

    }

    public class AnimationSet
    {
        public string Name;
        public List<Animation> Animations = new List<Animation>();
    }

    public class Animation
    {
        public string Name;
        public int Framerate = 30;
        public bool IsMoveEnabled = true;
        public int CurrentKey = 0;
        public int VariantDelayMin = 15000;
        public int VariantDelayMax = 65000;
        public List<int[]> Keys = new List<int[]>();
    }

    public class AppliedAnimation
    {
        dynamic Owner;

        public Animation Animation;
        public float Speed = 1.0f;
        public bool IsLoop = false;
        public string Callback;
        public string CallbackArgs;

        private float _CurrentFrame;
        private int _VariantMark;
        private int _VariantDelay;

        public AppliedAnimation()
        {

        }

        public bool Update(bool isObject)
        {
            int firstFrame = Animation.Keys[Animation.CurrentKey][0];
            int lastFrame = Animation.Keys[Animation.CurrentKey][1];

            _CurrentFrame = _CurrentFrame + (Animation.Framerate * Speed * (App.Timing.Delta * 0.001f));

            if(_CurrentFrame < firstFrame)
            {
                _CurrentFrame = firstFrame;
            }

            if (_CurrentFrame >= lastFrame)
            {
                if (IsLoop)
                {
                    //handle frame, looping
                    _CurrentFrame = firstFrame;

                    if (isObject)
                    {
                        float animTime = (_CurrentFrame + Agk.GetObjectAnimationDuration((uint)Owner.ResourceNumber, "")) / Animation.Keys[Animation.CurrentKey][1];
                        Agk.SetObjectAnimationFrame((uint)Owner.ResourceNumber, "", animTime, 0.0f);
                    }
                    else
                    {
                        Agk.SetSpriteFrame((uint)Owner.ResourceNumber, (int)_CurrentFrame);
                    }

                    //handle variant
                    if(Animation.Keys.Count > 1)
                    {
                        if(App.Timing.Timer - _VariantMark >= _VariantDelay)
                        {
                            Animation.CurrentKey = (int)Agk.Random(0, (uint)(Animation.Keys.Count - 1));
                            _VariantDelay = Animation.VariantDelayMin + (int)Agk.Random(0, (uint)Animation.VariantDelayMax);
                            _VariantMark = (int)App.Timing.Timer;
                        }
                    }

                    //handle callback
                    bool isLoopDone = false;
                    if (!String.IsNullOrEmpty(Callback))
                    {
                        isLoopDone = (bool)Dispatcher.Invoke(Callback, CallbackArgs);
                        if (isLoopDone)
                        {
                            return true;
                        }
                    }
                    return false;
                }
                else
                {
                    //handle frame, played once, end it
                    _CurrentFrame = lastFrame;

                    if (isObject)
                    {
                        float animTime = (_CurrentFrame + Agk.GetObjectAnimationDuration((uint)Owner.ResourceNumber, "")) / Animation.Keys[Animation.CurrentKey][1];
                        Agk.SetObjectAnimationFrame((uint)Owner.ResourceNumber, "", animTime, 0.0f);
                    }
                    else
                    {
                        Agk.SetSpriteFrame((uint)Owner.ResourceNumber, (int)_CurrentFrame);
                    }

                    //handle callback
                    if (!String.IsNullOrEmpty(Callback))
                    {
                        Dispatcher.Invoke(Callback, CallbackArgs);
                    }
                    return true;
                }
            }
            else
            {
                //handle frame, sequence hasnt completed, continue
                if (isObject)
                {
                    float animTime = (_CurrentFrame + Agk.GetObjectAnimationDuration((uint)Owner.ResourceNumber, "")) / Animation.Keys[Animation.CurrentKey][1];
                    Agk.SetObjectAnimationFrame((uint)Owner.ResourceNumber, "", animTime, 0.0f);
                }
                else
                {
                    Agk.SetSpriteFrame((uint)Owner.ResourceNumber, (int)_CurrentFrame);
                }

                //handle callback
                bool isLoopDone = false;
                if (!String.IsNullOrEmpty(Callback))
                {
                    isLoopDone = (bool)Dispatcher.Invoke(Callback, CallbackArgs);
                    if (isLoopDone)
                    {
                        return true;
                    }
                }
                return false;
            }
        }

    }

}

        public static void UpdateTiming()
        {
            uint oldTime = App.Timing.Timer;
            App.Timing.Timer = Agk.GetMilliseconds();
            App.Timing.Delta = App.Timing.Timer - oldTime;

using AgkSharp;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Linq;

namespace AGKCore
{
    public class EntityHandler
    {
        public static List<Entity> EntityList = new List<Entity>();

        public EntityHandler()
        {
            Dispatcher.Add(EntityHandler.UpdateEntities);
            App.UpdateList.Add(new UpdateHandler("EntityHandler.UpdateEntities", null, false));
        }

        public static void UpdateEntities(object rArgs)
        {
            foreach(var e in EntityList)
            {
                e.Update();
            }
        }
    }

    public class Entity
    {
        public uint ResourceNumber;
        public AGKVector3 Position = new AGKVector3();
        public float Facing;
        public float Heading;
        public float Speed;
        public bool IsObject;
        public List<AppliedAnimation> AnimationQ = new List<AppliedAnimation>();

        public Entity()
        {
            
        }

        public void Update()
        {
            if(AnimationQ.Count > 0)
            {
                bool isDone = AnimationQ[0].Update();
                if (isDone)
                {
                    AnimationQ.RemoveAt(0);
                }
            }
        }

    }
    
}

            /*
            tElement = new UI.Element();
            tElement.Id = "balloon";
            tElement.Style.SetProp("width", "60px");
            tElement.Style.SetProp("height", "88px");
            tElement.Style.SetProp("background-image", "media/item0.png|media/item1.png|media/item2.png|media/item3.png|media/item4.png");
            tElement.Style.SetProp("position-alignH", "center");
            tElement.Style.SetProp("position-alignV", "center");
            tElement.SetParent("sky-panel");
            tElement.EnableEvents = 1;
            tElement.HoldMouseFocus = true;
            tElement.OnPress = "App.DoStuff";
            UI.UserInterface.ElementList.Add(tElement);
            */

            var tEntity = new Entity();
            tEntity.IsObject = false;
            tEntity.Position.X = 50;
            tEntity.Position.Y = 100; ;
            ImageAsset tImg = Media.GetImageAsset("media/characters/balloon0.png", 1.0f, 1.0f);
            tEntity.ResourceNumber = Agk.CreateSprite(tImg.Number);
            Agk.AddSpriteAnimationFrame(tEntity.ResourceNumber, Media.GetImageAsset("media/characters/balloon1.png", 1.0f, 1.0f).Number);
            Agk.AddSpriteAnimationFrame(tEntity.ResourceNumber, Media.GetImageAsset("media/characters/balloon2.png", 1.0f, 1.0f).Number);
            Agk.AddSpriteAnimationFrame(tEntity.ResourceNumber, Media.GetImageAsset("media/characters/balloon3.png", 1.0f, 1.0f).Number);
            Agk.AddSpriteAnimationFrame(tEntity.ResourceNumber, Media.GetImageAsset("media/characters/balloon4.png", 1.0f, 1.0f).Number);
            var animSet = AnimationHandler.GetAnimationSet("media/characters/balloon.anim");
            var tAnim = new AppliedAnimation(tEntity, animSet, "0000L")
            {
                IsLoop = true
            };
            tEntity.AnimationQ.Add(tAnim);
            EntityHandler.EntityList.Add(tEntity);
            Agk.SetSpritePosition(tEntity.ResourceNumber, tEntity.Position.X, tEntity.Position.Y);

using AgkSharp;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Linq;

namespace AGKCore
{

    public class Entity
    {
        public List<AppliedAnimation> AnimationQ = new List<AppliedAnimation>();

        public Entity()
        {
            
        }

        public class EntityProperties
        {
            public uint ResourceNumber;
            public AGKVector3 Position = new AGKVector3();
            public float Facing;
            public float Heading;
            public float Speed;
            public bool IsObject;
        }

    }
    
}

using AgkSharp;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Linq;
using AGKCore;

namespace AGKProject
{
    public class CharacterHandler2d
    {
        public static CharacterConfig Config = new CharacterConfig();
        public static List<CharacterEntity2d> CharacterList = new List<CharacterEntity2d>();
        public static CharacterEntity2d MyCharacter;

        public CharacterHandler2d()
        {
            Dispatcher.Add(CharacterHandler2d.UpdateCharacters);
            App.UpdateList.Add(new UpdateHandler("CharacterHandler2d.UpdateCharacters", null, false));
        }

        public static void UpdateCharacters(object rArgs)
        {
            foreach(var c in CharacterList)
            {
                c.Update();
            }
        }

        public class CharacterConfig
        {
            public float NormalAcceleration = 1.0f;
            public float NormalDeceleration = 3.0f;
            public float NormalMaxSpeed = 10.0f;
        }

    }

    public class CharacterEntity2d : Entity
    {

        public CharacterProperties Properties = new CharacterProperties();
        public CharacterStatus Status = new CharacterStatus();
        public CharacterStatus OldStatus = new CharacterStatus();

        public CharacterEntity2d(string rFileBase, int rWidth, int rHeight)
        {
            Properties.IsObject = false;

            ImageAsset tSheet = Media.GetImageAsset(rFileBase + ".png", 1.0f, 1.0f);
            Agk.Swap();
            var spSheet = Agk.CreateSprite(tSheet.Number);
            Agk.SetSpritePosition(spSheet, 0.0f, 0.0f);
            Agk.Render();
            bool isFirst = true;
            for(int row = 0; row < (Agk.GetImageHeight(tSheet.Number) / rHeight); row++)
            {
                for (int col = 0; col < (Agk.GetImageWidth(tSheet.Number) / rWidth); col++)
                {
                    var tImg = Agk.GetImage(col * rWidth, row * rHeight, rWidth, rHeight);
                    if (isFirst)
                    {
                        Properties.ResourceNumber = Agk.CreateSprite(tImg);
                        isFirst = false;
                    }
                    Agk.AddSpriteAnimationFrame(Properties.ResourceNumber, tImg);
                }
            }
            Agk.DeleteSprite(spSheet);
            Agk.ClearScreen();
            Agk.Swap();

            CharacterHandler2d.CharacterList.Add(this);
        }

        public void Update()
        {
            if(AnimationQ.Count > 0)
            {
                bool isDone = AnimationQ[0].Update();
                if (isDone)
                {
                    AnimationQ.RemoveAt(0);
                }
            }
        }

        public class CharacterProperties : EntityProperties
        {
            public int ZIndex = 10;
            public float Rotation = 0.0f;
        }

        public class CharacterStatus
        {
            public bool IsLiving = true;
            public StanceStates StanceState = StanceStates.Basic;
            public ActionStates ActionState = ActionStates.Idle;
            public MotionStates MotionState = MotionStates.Normal;
            public DirectionStates DirectionState = DirectionStates.Right;
        }

        public enum StanceStates
        {
            Basic
        }
        public enum ActionStates
        {
            Idle,
            Moving,
            Falling
        }
        public enum MotionStates
        {
            Stationary,
            Normal,
            Forced
        }
        public enum DirectionStates
        {
            Up,
            Right,
            Left,
            Down
        }
    }
    
}

            var tEntity = new CharacterEntity2d("media/characters/balloon", 60, 88);
            tEntity.Properties.Position.X = 50;
            tEntity.Properties.Position.Y = 100;
            Agk.SetSpritePosition(tEntity.Properties.ResourceNumber, tEntity.Properties.Position.X, tEntity.Properties.Position.Y);
            var animSet = AnimationHandler.GetAnimationSet("media/characters/balloon.anim");
            var tAnim = new AppliedAnimation(tEntity, animSet, "0113L")
            {
                IsLoop = true
            };
            tEntity.AnimationQ.Add(tAnim);
            CharacterHandler2d.MyCharacter = tEntity;

using AgkSharp;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Linq;
using AGKCore;
using AGKCore.UI;
using System.Windows.Forms;

namespace AGKProject
{
    public class Controls2d
    {

        public Controls2d()
        {
            Dispatcher.Add(Controls2d.GetGameplayInput);
            App.UpdateList.Add(new UpdateHandler("Controls2d.GetGameplayInput", null, false));
        }

        public static void GetGameplayInput(object rArgs)
        {
            //grab old state
            CharacterHandler2d.MyCharacter.OldStatus = JsonConvert.DeserializeObject<CharacterEntity2d.CharacterStatus>(JsonConvert.SerializeObject(CharacterHandler2d.MyCharacter.Status));

            //exit early if user does not have control
            if(UserInterface.Status.KeyMode != "gameplay" || CharacterHandler2d.MyCharacter.Status.MotionState == CharacterEntity2d.MotionStates.Forced)
            {
                return;
            }

            //reset states that need to be held by user
            if(CharacterHandler2d.MyCharacter.Status.ActionState == CharacterEntity2d.ActionStates.Moving)
            {
                CharacterHandler2d.MyCharacter.Status.ActionState = CharacterEntity2d.ActionStates.Idle;
            }

            //move up
            if (Hardware.IsKeyDown((int)Keys.W))
            {
                CharacterHandler2d.MyCharacter.Status.ActionState = CharacterEntity2d.ActionStates.Moving;
                CharacterHandler2d.MyCharacter.Properties.Facing = 180.0f;
                CharacterHandler2d.MyCharacter.Properties.Heading = 180.0f;
            }

            //move right
            if (Hardware.IsKeyDown((int)Keys.D))
            {
                CharacterHandler2d.MyCharacter.Status.ActionState = CharacterEntity2d.ActionStates.Moving;
                CharacterHandler2d.MyCharacter.Properties.Facing = 90.0f;
                CharacterHandler2d.MyCharacter.Properties.Heading = 90.0f;
            }

            //move left
            if (Hardware.IsKeyDown((int)Keys.A))
            {
                CharacterHandler2d.MyCharacter.Status.ActionState = CharacterEntity2d.ActionStates.Moving;
                CharacterHandler2d.MyCharacter.Properties.Facing = 270.0f;
                CharacterHandler2d.MyCharacter.Properties.Heading = 270.0f;
            }

            //move down
            if (Hardware.IsKeyDown((int)Keys.S))
            {
                CharacterHandler2d.MyCharacter.Status.ActionState = CharacterEntity2d.ActionStates.Moving;
                CharacterHandler2d.MyCharacter.Properties.Facing = 0.0f;
                CharacterHandler2d.MyCharacter.Properties.Heading = 0.0f;
            }
        }

    }
    
}

using AgkSharp;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Linq;
using AGKCore;

namespace AGKProject
{
    public class CharacterHandler2d
    {
        public static CharacterConfig Config = new CharacterConfig();
        public static List<CharacterEntity2d> CharacterList = new List<CharacterEntity2d>();
        public static CharacterEntity2d MyCharacter;

        public CharacterHandler2d()
        {
            Dispatcher.Add(CharacterHandler2d.UpdateCharacters);
            App.UpdateList.Add(new UpdateHandler("CharacterHandler2d.UpdateCharacters", "Controls2d.GetGameplayInput", false));
        }

        public static void UpdateCharacters(object rArgs)
        {
            foreach(var c in CharacterList)
            {
                c.Update();
            }
        }

        public class CharacterConfig
        {
            public float NormalAcceleration = 1.0f;
            public float NormalDeceleration = 3.0f;
            public float NormalMaxSpeed = 0.08f;
        }

    }

    public class CharacterEntity2d : Entity
    {

        public CharacterProperties Properties = new CharacterProperties();
        public CharacterStatus Status = new CharacterStatus();
        public CharacterStatus OldStatus = new CharacterStatus();

        public CharacterEntity2d(string rFileBase, int rWidth, int rHeight)
        {
            Properties.IsObject = false;
            Properties.Filebase = rFileBase;

            ImageAsset tSheet = Media.GetImageAsset(rFileBase + ".png", 1.0f, 1.0f);
            Agk.Swap();
            var spSheet = Agk.CreateSprite(tSheet.Number);
            Agk.SetSpritePosition(spSheet, 0.0f, 0.0f);
            Agk.Render();
            bool isFirst = true;
            for(int row = 0; row < (Agk.GetImageHeight(tSheet.Number) / rHeight); row++)
            {
                for (int col = 0; col < (Agk.GetImageWidth(tSheet.Number) / rWidth); col++)
                {
                    var tImg = Agk.GetImage(col * rWidth, row * rHeight, rWidth, rHeight);
                    if (isFirst)
                    {
                        Properties.ResourceNumber = Agk.CreateSprite(tImg);
                        isFirst = false;
                    }
                    Agk.AddSpriteAnimationFrame(Properties.ResourceNumber, tImg);
                }
            }
            Agk.DeleteSprite(spSheet);
            Agk.ClearScreen();
            Agk.Swap();

            CharacterHandler2d.CharacterList.Add(this);
        }

        public void Update()
        {
            if (!Status.IsLiving)
            {
                return;
            }

            string tState;
            string tOldState;

            var animSet = AnimationHandler.GetAnimationSet(Properties.Filebase + ".anim");

            //a character should NEVER not have an animation.
            if (AnimationQ.Count == 0)
            {
                var tAnim = new AppliedAnimation(this, animSet, "0000L") //add basic idle
                {
                    IsLoop = true,
                    Speed = 1.0f
                };
                AnimationQ.Add(tAnim);
            }

            string tAnimState = AnimationQ[0].Animation.Name.Substring(0, 4); 
            string tAnimStage = AnimationQ[0].Animation.Name.Substring(4, 1); //I L O

            //get new position
            switch (Status.ActionState)
            {
                case ActionStates.Idle:
                    Properties.Speed = 0.0f;
                    break;
                case ActionStates.Moving:
                    Properties.Speed = CharacterHandler2d.Config.NormalMaxSpeed;
                    break;
            }

            Properties.Position.X = Properties.Position.X + Agk.Sin(Properties.Heading) * Properties.Speed * App.Timing.Delta;
            Properties.Position.Y = Properties.Position.Y + Agk.Cos(Properties.Heading) * Properties.Speed * App.Timing.Delta;
            Agk.SetSpritePosition(Properties.ResourceNumber, Properties.Position.X, Properties.Position.Y);
            Agk.SetSpriteDepth(Properties.ResourceNumber, Properties.ZIndex);

            //get new animation state
            //TODO:

            //update animation frame
            bool isDone = AnimationQ[0].Update();
            if (isDone)
            {
                AnimationQ.RemoveAt(0);
            }
        }

        public class CharacterProperties : EntityProperties
        {
            public int ZIndex = 8;
            public float Rotation = 0.0f;
        }

        public class CharacterStatus
        {
            public bool IsLiving = true;
            public StanceStates StanceState = StanceStates.Basic;
            public ActionStates ActionState = ActionStates.Idle;
            public MotionStates MotionState = MotionStates.Normal;
            public DirectionStates DirectionState = DirectionStates.Right;
        }

        public enum StanceStates
        {
            Basic
        }
        public enum ActionStates
        {
            Idle,
            Moving,
            Falling
        }
        public enum MotionStates
        {
            Stationary,
            Normal,
            Forced
        }
        public enum DirectionStates
        {
            Up,
            Right,
            Left,
            Down
        }
    }
    
}

using System;
using AgkSharp;
using AGKCore;
using System.Reflection;
using System.Linq;
using UI = AGKCore.UI;
using AGKProject;

namespace AgkSharp_Template
{
    static class Program
    {
        [STAThread]
        static void Main(string[] args)
        {
            var attrs = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyTitleAttribute), false).FirstOrDefault() as AssemblyTitleAttribute;

            //init Agk
            if(!App.Init(args, attrs.Title))
            {
                return;
            }

            //init modules
            new AnimationHandler();
            new CharacterHandler2d();
            new Controls2d();
            new UI.UserInterface();
                UI.UserInterface.ControllerList.Add(new UI.CommonController());
                UI.UserInterface.ControllerList.Add(new UI.GameMenuController());
                UI.UserInterface.PreloadImages();

            //clean up
            UpdateHandler.SortUpdateList();

            App.Log("Program.cs", 3, "main", "> Init Complete");

            //TEMP setups
            UI.Element tElement = new UI.Element();
            tElement.Id = "sky-panel";
            tElement.Style.SetProp("width", "320px");
            tElement.Style.SetProp("height", "480px");
            tElement.Style.SetProp("background-image", "media/background.jpg");
            tElement.Style.SetProp("position-alignH", "center");
            tElement.Style.SetProp("position-alignV", "center");
            tElement.SetParent("root");
            UI.UserInterface.ElementList.Add(tElement);

            Dispatcher.Add(App.DoStuff);

            var tEntity = new CharacterEntity2d("media/characters/balloon", 60, 88);
            tEntity.Properties.Position.X = 50;
            tEntity.Properties.Position.Y = 100;
            CharacterHandler2d.MyCharacter = tEntity;
            
            
            //App main
            while (App.LoopAGK())
            {

                App.Log("Program.cs", 1, "main", "--- Begin main loop ---");

                //Always update timing, and do it first
                App.UpdateTiming();

                App.Log("Program.cs", 1, "main", "Processing " + App.UpdateList.Count.ToString() + " updates in queue");

                foreach (var u in App.UpdateList)
                {
                    if (!App.Status.IsRunning)
                    {
                        break;
                    }
                    if(App.Timing.PauseState != 1 || u.IgnorePause)
                    {

                        App.Log("Program.cs", 1, "main", "Process from queue " + u.FunctionName);

                        Dispatcher.Invoke(u.FunctionName, null);
                    }
                }
                if (!App.Status.IsRunning)
                {
                    break;
                }

                Agk.Print(Agk.ScreenFPS());

                Agk.Sync();
            }

            App.CleanUp();
        }

    }

}

using AgkSharp;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Linq;
using AGKCore;
using AGKCore.UI;
using System.Windows.Forms;

namespace AGKProject
{
    public class Controls2d
    {

        public Controls2d()
        {
            Dispatcher.Add(Controls2d.GetGameplayInput);
            App.UpdateList.Add(new UpdateHandler("Controls2d.GetGameplayInput", null, false));
        }

        public static void GetGameplayInput(object rArgs)
        {
            /*
            //exit early if main gameplay not in progress
            if(App.Status.LoadState < 3)
            {
                return;
            }
            */

            //grab old state
            CharacterHandler2d.MyCharacter.OldStatus = JsonConvert.DeserializeObject<CharacterEntity2d.CharacterStatus>(JsonConvert.SerializeObject(CharacterHandler2d.MyCharacter.Status));

            //reset forced
            UserInterface.Status.MouseModeForced = "";
            UserInterface.Status.KeyModeForced = "";

            //exit early if user does not have control
            if (UserInterface.Status.KeyMode != "gameplay" || CharacterHandler2d.MyCharacter.Status.MotionState == CharacterEntity2d.MotionStates.Forced)
            {
                return;
            }

            if (!CharacterHandler2d.MyCharacter.Status.IsLiving)
            {
                return;
            }

            //reset states that need to be held by user
            if(CharacterHandler2d.MyCharacter.Status.ActionState == CharacterEntity2d.ActionStates.Moving)
            {
                CharacterHandler2d.MyCharacter.Status.ActionState = CharacterEntity2d.ActionStates.Idle;
            }

            if(CharacterHandler2d.MyCharacter.Status.MotionState != CharacterEntity2d.MotionStates.Forced)
            {
                CharacterHandler2d.MyCharacter.Status.MotionState = CharacterEntity2d.MotionStates.Stationary;
            }

            CharacterHandler2d.MyCharacter.Status.DirectionState = CharacterEntity2d.DirectionStates.Up;

            //move up
            if (Hardware.IsKeyDown((int)Keys.W))
            {
                CharacterHandler2d.MyCharacter.Status.ActionState = CharacterEntity2d.ActionStates.Moving;
                CharacterHandler2d.MyCharacter.Status.DirectionState = CharacterEntity2d.DirectionStates.Up;
                CharacterHandler2d.MyCharacter.Properties.Facing = 180.0f;
                CharacterHandler2d.MyCharacter.Properties.Heading = 180.0f;
            }

            //move right
            if (Hardware.IsKeyDown((int)Keys.D))
            {
                CharacterHandler2d.MyCharacter.Status.ActionState = CharacterEntity2d.ActionStates.Moving;
                CharacterHandler2d.MyCharacter.Status.DirectionState = CharacterEntity2d.DirectionStates.Right;
                CharacterHandler2d.MyCharacter.Properties.Facing = 90.0f;
                CharacterHandler2d.MyCharacter.Properties.Heading = 90.0f;
            }

            //move left
            if (Hardware.IsKeyDown((int)Keys.A))
            {
                CharacterHandler2d.MyCharacter.Status.ActionState = CharacterEntity2d.ActionStates.Moving;
                CharacterHandler2d.MyCharacter.Status.DirectionState = CharacterEntity2d.DirectionStates.Left;
                CharacterHandler2d.MyCharacter.Properties.Facing = 270.0f;
                CharacterHandler2d.MyCharacter.Properties.Heading = 270.0f;
            }

            //move down
            if (Hardware.IsKeyDown((int)Keys.S))
            {
                CharacterHandler2d.MyCharacter.Status.ActionState = CharacterEntity2d.ActionStates.Moving;
                CharacterHandler2d.MyCharacter.Status.DirectionState = CharacterEntity2d.DirectionStates.Down;
                CharacterHandler2d.MyCharacter.Properties.Facing = 0.0f;
                CharacterHandler2d.MyCharacter.Properties.Heading = 0.0f;
            }

            if(CharacterHandler2d.MyCharacter.Status.ActionState == CharacterEntity2d.ActionStates.Moving)
            {
                CharacterHandler2d.MyCharacter.Status.MotionState = CharacterEntity2d.MotionStates.Normal;
            }
        }

    }
    
}

using AgkSharp;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Linq;
using AGKCore;

namespace AGKProject
{
    public class CharacterHandler2d
    {
        public static CharacterConfig Config = new CharacterConfig();
        public static List<CharacterEntity2d> CharacterList = new List<CharacterEntity2d>();
        public static CharacterEntity2d MyCharacter;

        public CharacterHandler2d()
        {
            Dispatcher.Add(CharacterHandler2d.UpdateCharacters);
            App.UpdateList.Add(new UpdateHandler("CharacterHandler2d.UpdateCharacters", "Controls2d.GetGameplayInput", false));
        }

        public static void UpdateCharacters(object rArgs)
        {
            foreach(var c in CharacterList)
            {
                c.Update();
            }
        }

        public class CharacterConfig
        {
            public float NormalAcceleration = 1.0f;
            public float NormalDeceleration = 3.0f;
            public float NormalMaxSpeed = 0.08f;
        }

    }

    public class CharacterEntity2d : Entity
    {

        public CharacterProperties Properties = new CharacterProperties();
        public CharacterStatus Status = new CharacterStatus();
        public CharacterStatus OldStatus = new CharacterStatus();

        public CharacterEntity2d(string rFileBase, int rWidth, int rHeight)
        {
            Properties.IsObject = false;
            Properties.Filebase = rFileBase;

            ImageAsset tSheet = Media.GetImageAsset(rFileBase + ".png", 1.0f, 1.0f);
            Agk.Swap();
            var spSheet = Agk.CreateSprite(tSheet.Number);
            Agk.SetSpritePosition(spSheet, 0.0f, 0.0f);
            Agk.Render();
            bool isFirst = true;
            for(int row = 0; row < (Agk.GetImageHeight(tSheet.Number) / rHeight); row++)
            {
                for (int col = 0; col < (Agk.GetImageWidth(tSheet.Number) / rWidth); col++)
                {
                    var tImg = Agk.GetImage(col * rWidth, row * rHeight, rWidth, rHeight);
                    if (isFirst)
                    {
                        Properties.ResourceNumber = Agk.CreateSprite(tImg);
                        isFirst = false;
                    }
                    Agk.AddSpriteAnimationFrame(Properties.ResourceNumber, tImg);
                }
            }
            Agk.DeleteSprite(spSheet);
            Agk.ClearScreen();
            Agk.Swap();

            CharacterHandler2d.CharacterList.Add(this);
        }

        public void Update()
        {
            if (!Status.IsLiving)
            {
                return;
            }

            //gather current data
            float oldPosX = Properties.Position.X;
            float oldPosY = Properties.Position.Y;
            float oldPosZ = Properties.Position.Z;
            float oldFacing = Properties.Facing;

            var animSet = AnimationHandler.GetAnimationSet(Properties.Filebase + ".anim");

            //a character should NEVER not have an animation.
            if (AnimationQ.Count == 0)
            {
                var tAnim = new AppliedAnimation(this, animSet, "0000L") //add basic idle
                {
                    IsLoop = true,
                    Speed = 1.0f
                };
                AnimationQ.Add(tAnim);
            }

            string tAnimState = AnimationQ[0].Animation.Name.Substring(0, 4); 
            string tAnimStage = AnimationQ[0].Animation.Name.Substring(4, 1); //I L O

            //get new position
            switch (Status.ActionState)
            {
                case ActionStates.Idle:
                    
                    //TODO momentum overrides

                    Properties.Speed = 0.0f;
                    Status.MotionState = MotionStates.Stationary;
                    break;
                case ActionStates.Moving:
                    Properties.Speed = CharacterHandler2d.Config.NormalMaxSpeed;
                    break;
            }

            Properties.Position.X = Properties.Position.X + Agk.Sin(Properties.Heading) * Properties.Speed * App.Timing.Delta;
            Properties.Position.Y = Properties.Position.Y + Agk.Cos(Properties.Heading) * Properties.Speed * App.Timing.Delta;
            Agk.SetSpritePosition(Properties.ResourceNumber, Properties.Position.X, Properties.Position.Y);
            Agk.SetSpriteDepth(Properties.ResourceNumber, Properties.ZIndex);

            //get new animation state
            string tState = ((int)Status.StanceState).ToString() + ((int)Status.ActionState).ToString() + ((int)Status.MotionState).ToString() + ((int)Status.DirectionState).ToString();
            string tOldState = ((int)OldStatus.StanceState).ToString() + ((int)OldStatus.ActionState).ToString() + ((int)OldStatus.MotionState).ToString() + ((int)OldStatus.DirectionState).ToString();
            string tBaseStance = ((int)Status.StanceState).ToString();
            string oldBaseStance = ((int)OldStatus.StanceState).ToString();
            string tBaseState = tBaseStance + "000";
            string keyBaseIdleStationaryUp = ((int)ActionStates.Idle).ToString() + ((int)MotionStates.Stationary).ToString() + ((int)DirectionStates.Up).ToString(); //for convenience

            if(tState != tAnimState && tAnimState + "O" != AnimationQ[0].Animation.Name && tAnimState + "I" != AnimationQ[0].Animation.Name)
            {
                //animation state has changed, clear the current animation stack and rebuild under the new state
                AnimationQ.Clear();

                if (tState == tBaseState && tBaseStance == oldBaseStance)
                {
                    //transition old state out
                    var tAnimO = new AppliedAnimation(this, animSet, tAnimState + "O")
                    {
                        IsLoop = false,
                    };
                    AnimationQ.Add(tAnimO);

                    //transition new state in
                    if (Status.StanceState != OldStatus.StanceState)
                    {
                        var tAnimI = new AppliedAnimation(this, animSet, tState + "I")
                        {
                            IsLoop = false,
                        };
                        AnimationQ.Add(tAnimI);
                    }
                }
                else
                {
                    //dont need to transition old state out, just transition new state in

                    if (false) //TODO: handle jumping and other complex states, may not always proceed to state In
                    {

                    }
                    else
                    {
                        if (Status.StanceState != OldStatus.StanceState)
                        {
                            var tAnimII = new AppliedAnimation(this, animSet, tState + "I")
                            {
                                IsLoop = false,
                            };
                            AnimationQ.Add(tAnimII);
                        }
                    }
                }

                //always proceed into state Loop -> characters should never be static!
                var tAnimL = new AppliedAnimation(this, animSet, tState + "L")
                {
                    IsLoop = true,
                };
                AnimationQ.Add(tAnimL);
            }

            //update animation frame
            bool isDone = AnimationQ[0].Update();
            if (isDone)
            {
                AnimationQ.RemoveAt(0);
            }
        }

        public class CharacterProperties : EntityProperties
        {
            public int ZIndex = 8;
            public float Rotation = 0.0f;
        }

        public class CharacterStatus
        {
            public bool IsLiving = true;
            public StanceStates StanceState = StanceStates.Basic;
            public ActionStates ActionState = ActionStates.Idle;
            public MotionStates MotionState = MotionStates.Normal;
            public DirectionStates DirectionState = DirectionStates.Up;
        }

        public enum StanceStates
        {
            Basic
        }
        public enum ActionStates
        {
            Idle,
            Moving,
            Falling
        }
        public enum MotionStates
        {
            Stationary,
            Normal,
            Forced
        }
        public enum DirectionStates
        {
            Up,
            Right,
            Left,
            Down
        }
    }
    
}

using AgkSharp;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Linq;

namespace AGKCore
{
    public class Camera3dHandler
    {
        public static List<Camera3d> CameraList = new List<Camera3d>();

        public Camera3dHandler()
        {
            Dispatcher.Add(Camera3dHandler.UpdateCameras);
            App.UpdateList.Add(new UpdateHandler("Camera3dHandler.UpdateCameras", "World3d.UpdateEntities,Controls3d.GetGameplayInput", false));
        }

        public static void UpdateCameras(object rArgs)
        {
            foreach (var c in CameraList)
            {
                if (c.IsAutoUpdate)
                {
                    c.Update();
                }
            }
        }
    }

    public class Camera3d
    {
        
        private static AGKVector3 _up = new AGKVector3(0, 1, 0);

        public string Name;
        public bool IsAutoUpdate = true;

        public float Near = 0.1f;
        public float Far = 1000.0f;
        public float FOV = 70.0f;
        public float Phi;
        public float Theta;
        public AGKVector3 Position = new AGKVector3();
        public AGKVector3 Rotation = new AGKVector3();

        public AGKMatrix4 ViewMatrix = AGKMatrix4.Identity;
        public AGKMatrix4 ProjectionMatrix = AGKMatrix4.Identity;

        public dynamic Anchor;
        public float OrbitDistance = 100.0f;
        public float OrbitSpeed = 0.25f;

        public dynamic Target;
        public AGKVector3 TargetPosition = new AGKVector3();

        public Camera3d(string rName)
        {
            if (String.IsNullOrEmpty(rName))
            {
                rName = "camera" + Camera3dHandler.CameraList.Count().ToString();
            }

            Name = rName;

            Camera3dHandler.CameraList.Add(this);
        }

        public void UpdateFromAgk()
        {
            FOV = Agk.GetCameraFOV(1);
            Position.X = Agk.GetCameraX(1);
            Position.Y = Agk.GetCameraY(1);
            Position.Z = Agk.GetCameraZ(1);
            Rotation.X = Agk.GetCameraAngleX(1);
            Rotation.Y = Agk.GetCameraAngleY(1);
            Rotation.Z = Agk.GetCameraAngleZ(1);

            //TODO: reverse calc orbit/target values if bound

            //ProjectionMatrix = AGKMatrix4.Perspective(0.25f * (float)Math.PI, AspectRatio, 1.0f, 1000.0f);
            ProjectionMatrix = AGKMatrix4.Perspective(FOV, App.Config.Screen.AspectRatio, Near, Far);
        }

        public void ApplyToAgk()
        {
            Agk.SetCameraFOV(1, FOV);
            Agk.SetCameraPosition(1, Position.X, Position.Y, Position.Z);
            Agk.SetCameraRange(1, Near, Far);
            Agk.SetCameraRotation(1, Rotation.X, Rotation.Y, Rotation.Z);
            if (Target != null)
            {
                Agk.SetCameraLookAt(1, TargetPosition.X, TargetPosition.Y, TargetPosition.Z, Rotation.Z);
            }
        }

        public void Update()
        {
            if (Anchor != null)
            {
                var p = MathF.ToDegrees(Phi);
                var t = MathF.ToDegrees(Theta);
                Position.X = Anchor.Properties.Position.X + (OrbitDistance * Agk.Sin(p) * Agk.Cos(t));
                Position.Z = Anchor.Properties.Position.Z + (OrbitDistance * Agk.Sin(p) * Agk.Sin(t));
                Position.Y = Anchor.Properties.Position.Y + (OrbitDistance * Agk.Cos(p));
                /*
                var rx = Anchor.Properties.Position.X + (OrbitDistance * Agk.Sin(Phi) * Agk.Cos(Theta));
                var rz = Anchor.Properties.Position.Z + (OrbitDistance * Agk.Sin(Phi) * Agk.Sin(Theta));
                var ry = Anchor.Properties.Position.Y + (OrbitDistance * Agk.Cos(Phi));
                ViewMatrix = AGKMatrix4.LookAt(new AGKVector3(rx, ry, rz), TargetPosition, _up);
                */
            }
            else
            {
                //LocalRotation.X += Phi;
                //LocalRotation.Y += Theta;
            }

            if (Target != null)
            {
                TargetPosition = Target.Properties.Position;
            }
            
            
        }

    }
    
}

using AgkSharp;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Linq;
using AGKCore;
using AGKCore.UI;
using System.Windows.Forms;

namespace AGKProject
{
    public class Controls3d
    {
        public static Camera3d ActiveCamera;

        public Controls3d()
        {
            Dispatcher.Add(Controls3d.GetGameplayInput);
            App.UpdateList.Add(new UpdateHandler("Controls3d.GetGameplayInput", null, false));
        }

        public static void GetGameplayInput(object rArgs)
        {

            //reset forced
            UserInterface.Status.MouseModeForced = "";
            UserInterface.Status.KeyModeForced = "";

            if (Controls3d.ActiveCamera.Name == "main")
            {
                var ox = MathF.ToRadians(Controls3d.ActiveCamera.OrbitSpeed * Hardware.Mouse.MoveX) * -1.0f; //remove * -1.0f to invert direction
                var oy = MathF.ToRadians(Controls3d.ActiveCamera.OrbitSpeed * Hardware.Mouse.MoveY) * -1.0f;
                var oz = Controls3d.ActiveCamera.OrbitSpeed * 0.1f * Hardware.Mouse.MoveZ;
                Controls3d.ActiveCamera.Theta += ox;
                Controls3d.ActiveCamera.Phi += oy;
                Controls3d.ActiveCamera.Phi = MathF.Clamp(Controls3d.ActiveCamera.Phi, 0.1f, (float)Math.PI - 0.1f);
                Controls3d.ActiveCamera.OrbitDistance += oz;
                Controls3d.ActiveCamera.OrbitDistance = MathF.Clamp(Controls3d.ActiveCamera.OrbitDistance, 10.0f, 150.0f);
                Controls3d.ActiveCamera.ApplyToAgk();
            }

            //TEMP: toggle active
            if (Hardware.IsKeyDown((int)Keys.C) && UserInterface.Status.InputReady)
            {
                UserInterface.Status.InputMark = App.Timing.Timer;
                Controls3d.ActiveCamera = Camera3dHandler.CameraList.FirstOrDefault(c => c.Name != Controls3d.ActiveCamera.Name);
                Controls3d.ActiveCamera.ApplyToAgk();
            }
        }

    }
    
}

        static void Main(string[] args)
        {
            #region boilerplate init region

            var attrs = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyTitleAttribute), false).FirstOrDefault() as AssemblyTitleAttribute;

            //init Agk
            if(!App.Init(args, attrs.Title))
            {
                return;
            }

            //init modules
            new Hardware();
            new Media();
            new AnimationHandler();

            //new CharacterHandler2d();
            //new Controls2d();

            new World3d();
            new Controls3d();
            new Camera3dHandler();

            new UI.UserInterface();
                UI.UserInterface.ControllerList.Add(new UI.CommonController());
                UI.UserInterface.ControllerList.Add(new UI.GameMenuController());
                UI.UserInterface.PreloadImages();

            //clean up
            UpdateHandler.SortUpdateList();

            App.Log("Program.cs", 3, "main", "> Init Complete");

            #endregion

            //TEMP setups

            var boxNum = Agk.CreateObjectBox(5.0f, 5.0f, 5.0f);
            var boxEnt = new WorldEntity3d();
            boxEnt.Properties.ResourceNumber = boxNum;
            boxEnt.Properties.IsObject = true;
            
            var cam0 = new Camera3d("main");
            cam0.UpdateFromAgk();
            cam0.Anchor = boxEnt;
            cam0.Target = boxEnt;

            var cam1 = new Camera3d("myOtherCam");
            cam1.UpdateFromAgk();
            cam1.Position.X = 10.0f;
            cam1.Position.Y = 10.0f;
            cam1.Position.Z = -40.0f;
            cam1.ApplyToAgk();
            Controls3d.ActiveCamera = cam1;

            //ENDTEMP

            //App main
            while (App.LoopAGK())
            {

                App.Log("Program.cs", 1, "main", "--- Begin main loop ---");

           ....