static int Main(string[] args)
        {
            // The Screen or Window
            VideoMode videoMode = new VideoMode(1024, 768);
            RenderWindow window = new RenderWindow(videoMode,
                "Learn SFML");
            window.Closed += new EventHandler(window_Closed);
            window.MouseButtonPressed += new EventHandler<MouseButtonEventArgs>(window_MouseButtonPressed);
            window.MouseMoved += new EventHandler<MouseMoveEventArgs>(window_MouseMoved);
            window.KeyPressed += new EventHandler<KeyEventArgs>(window_KeyPressed);

            Start();

            Console.Out.WriteLine("Engine Started Successfully!");

            while (window.IsOpen()
                && !quit)
            {
                window.DispatchEvents();

                // Draw
                currentScreen.Draw(window);
                window.Display();
            }
            window.Close();

            return 0;
        }

        public Game(uint width, uint height, string title)
        {
            videoMode = new VideoMode(width, height);
            this.title = title;

            Focused = true;
        }

        public VideoSettings()
        {
            WindowStyle    = Styles.Default; // Titlebar + Resize + Close
            WindowSettings = VideoMode.DesktopMode;

            OpenGLSettings = new ContextSettings();
            RefreshRate    = 30;
        }

        public Game()
        {
            videoMode = new VideoMode(960, 540);
            title = "SFML Game Window";
            style = Styles.Close;
            context = new ContextSettings();

            ScreenManager = new ScreenManager();
        }

            ////////////////////////////////////////////////////////////
            /// <summary>
            /// Create the window
            /// </summary>
            /// <param name="mode">Video mode to use</param>
            /// <param name="title">Title of the window</param>
            /// <param name="style">Window style (Resize | Close by default)</param>
            /// <param name="settings">Creation parameters</param>
            ////////////////////////////////////////////////////////////
            public Window(VideoMode mode, string title, Styles style, ContextSettings settings) :
                base(IntPtr.Zero)
            {
                 // Copy the title to a null-terminated UTF-32 byte array
                byte[] titleAsUtf32 = System.Text.Encoding.UTF32.GetBytes(title + '\0');

                unsafe
                {
                    fixed (byte* titlePtr = titleAsUtf32)
                    {
                        SetThis(sfWindow_createUnicode(mode, (IntPtr)titlePtr, style, ref settings));
                    }
                }
           }

            ////////////////////////////////////////////////////////////
            /// <summary>
            /// Create the window
            /// </summary>
            /// <param name="mode">Video mode to use</param>
            /// <param name="title">Title of the window</param>
            /// <param name="style">Window style (Resize | Close by default)</param>
            /// <param name="settings">Creation parameters</param>
            ////////////////////////////////////////////////////////////
            public RenderWindow(VideoMode mode, string title, Styles style, ContextSettings settings) :
                base(IntPtr.Zero, 0)
            {
                 // Copy the string to a null-terminated UTF-32 byte array
                byte[] titleAsUtf32 = Encoding.UTF32.GetBytes(title + '\0');

                unsafe
                {
                    fixed (byte* titlePtr = titleAsUtf32)
                    {
                        CPointer = sfRenderWindow_createUnicode(mode, (IntPtr)titlePtr, style, ref settings);
                    }
                }
                Initialize();
           }

 public override void createWindow(SFML.Window.VideoMode mode, string title, SFML.Window.Styles styles, SFML.Window.ContextSettings context)
 {
     if (fullScreen)
     {
         screenResolution = new Vector2u(VideoMode.DesktopMode.Width, VideoMode.DesktopMode.Height);
         styles = Styles.None;
     }
     else
     {
         styles = Styles.Close;
     }
     //context.AntialiasingLevel = 4;
     title = "Platformer";
     mode = new VideoMode(Game1.screenResolution.X, Game1.screenResolution.Y);
     base.createWindow(mode, title, styles, context);
 }

        static void Main(string[] args)
        {
            var videoMode = new VideoMode(1000, 700);
            var contextSettings = new ContextSettings(0, 0, 4);
            RenderWindow window = new RenderWindow(videoMode, "Luda Diaria", Styles.Default, contextSettings);
            window.SetActive(true);
            window.Closed += (sender, e) => window.Close();
            Global.Window = window;

            Randomizer.Generator = new Random(42);

            var input = InputManager.Instance;
            input.Init();

            StateManager.Instance.CurrentState = new LoadingState();

            var lastTick = DateTime.Now;
            const float maxTimeStep = 0.5f;

            while (window.IsOpen())
            {
                float dt = (float)((DateTime.Now - lastTick).TotalSeconds);
                lastTick = DateTime.Now;

                window.DispatchEvents();
                window.Clear(Color.Black);

                if (input.IsKeyPressed(Keyboard.Key.Escape))
                {
                    window.Close();
                }

                while (dt > 0)
                {
                    //---UPDATE
                    var deltatTime = dt < maxTimeStep ? dt : maxTimeStep;
                    StateManager.Instance.CurrentState.Update(deltatTime);
                    dt -= maxTimeStep;
                }
                //---DRAW

                StateManager.Instance.CurrentState.Draw(window, RenderStates.Default);
                window.Display();
            }
        }

        public Game()
        {
            _mode = new VideoMode(768, 540);
            _title = "Bubble Buster";
            _style = Styles.Close;
            _window = new RenderWindow(_mode, _title, _style);

            System.Drawing.Icon icon = ResourceUtility.GetIconResource("ProjectBubbles.Resources.gamepad.ico");
            if (icon != null) {
                _window.SetIcon((uint) icon.Width, (uint) icon.Height, ResourceUtility.GetPixelBytes(icon.ToBitmap()));
            }

            SetupContent();
            Setup();

            _window.Closed += new EventHandler(OnClose);
            _window.MouseButtonPressed += new EventHandler<MouseButtonEventArgs>(MousePressed);
        }

        public static void Main()
        {
            var resolution = new VideoMode(WIDTH, HEIGHT, 32);
            var windowSettings = new ContextSettings(32, 0, 4);
            var window = new RenderWindow(resolution, "Lockheed the Game", Styles.Close, windowSettings);

            window.Closed += Events.OnClose;
            window.KeyPressed += Events.OnKeyPressed;
            window.KeyReleased += Events.OnKeyReleased;
            window.MouseButtonPressed += Events.OnMouseButtonPressed;
            window.SetActive();

            Level.Level newLevel = Level.Level.GenerateSingleLevel();
            Character.Character glava = new Rogue("glava");

            glava.CurrentSkill = new ProjectileSkill(
                "fireball", 10, 10, 10, Tier.Beginner, 5, "weapons/projectiles/fireBall.png", 5);

            EntityManager.CurrentLevel = newLevel;
            EntityManager.Character = glava;

            DateTime lastTick = DateTime.Now;
            while (window.IsOpen())
            {
                float dt = (float)(DateTime.Now - lastTick).TotalMilliseconds;
                lastTick = DateTime.Now;
                window.DispatchEvents();

                while (dt > 0)
                {
                    EntityManager.Update();
                    dt -= MAX_TIMESTEP;
                }

                window.Clear(Color.Black);
                EntityManager.Draw(window);
                window.Display();
            }
        }

 public CluwneWindow(VideoMode mode, string title, Styles style) : base(mode, title, style)
 {
 }

 private static extern bool sfVideoMode_isValid(VideoMode Mode);

        private void LoadWindow()
        {
            // Determine settings
            var vmode = new VideoMode(
                (uint)Settings.ReadInt("Video", "ResX", 1024),
                (uint)Settings.ReadInt("Video", "ResY", 600),
                24);
            bool fscreen = Settings.ReadInt("Video", "Fullscreen", 0) == 1;
            bool vsync = Settings.ReadInt("Video", "VSync", 1) == 1;

            // Setup the new window
            window = new RenderWindow(vmode, "FTL: Overdrive", fscreen ? Styles.Fullscreen : Styles.Close, new ContextSettings(24, 8, 8));
            window.SetVisible(true);
            window.SetVerticalSyncEnabled(vsync);
            window.MouseMoved += new EventHandler<MouseMoveEventArgs>(window_MouseMoved);
            window.Closed += new EventHandler(window_Closed);
            window.MouseButtonPressed += new EventHandler<MouseButtonEventArgs>(window_MouseButtonPressed);
            window.MouseButtonReleased += new EventHandler<MouseButtonEventArgs>(window_MouseButtonReleased);
            window.KeyPressed += new EventHandler<KeyEventArgs>(window_KeyPressed);
            window.KeyReleased += new EventHandler<KeyEventArgs>(window_KeyReleased);
            window.TextEntered += new EventHandler<TextEventArgs>(window_TextEntered);

            // Init UI
            Canvas = new UI.Canvas();
            var screenrect = Util.ScreenRect(window.Size.X, window.Size.Y, 1.77778f);
            Canvas.X = screenrect.Left;
            Canvas.Y = screenrect.Top;
            Canvas.Width = screenrect.Width;
            Canvas.Height = screenrect.Height;

            // Load icon
            using (var bmp = new System.Drawing.Bitmap(Resource("img/exe_icon.bmp")))
            {
                byte[] data = new byte[bmp.Width * bmp.Height * 4];
                int i = 0;
                for (int y = 0; y < bmp.Height; y++)
                    for (int x = 0; x < bmp.Width; x++)
                    {
                        var c = bmp.GetPixel(x, y);
                        data[i++] = c.R;
                        data[i++] = c.G;
                        data[i++] = c.B;
                        data[i++] = c.A;
                    }
                window.SetIcon((uint)bmp.Width, (uint)bmp.Height, data);
            }
        }

 static extern IntPtr sfRenderWindow_Create(VideoMode Mode, string Title, Styles Style, ref ContextSettings Params);

        private static void Main(string[] args)
        {
            var form = new SettingsDialog();
            Application.EnableVisualStyles();
            Application.Run(form);
            videoMode = VideoMode.DesktopMode;
            RenderWindow window = new RenderWindow(videoMode, "Maze Crap", Styles.Fullscreen);
            window.EnableVerticalSync(Settings.Default.VerticalSync);
            window.ShowMouseCursor(false);
            window.Closed += (sender, e) => Application.Exit();
            window.KeyPressed += (sender, e) => ((RenderWindow) sender).Close();
            SetUpMaze();
            target = new Image(VideoMode.DesktopMode.Width/10, VideoMode.DesktopMode.Height/10) {Smooth = false};
            float accumulator = 0;
            float WaitTime = 0;
            var fps = (float) Settings.Default.Framerate;
            window.Show(true);
            bool hasrun = false;
            while (window.IsOpened())
            {
                accumulator += window.GetFrameTime();
                while (accumulator > fps)
                {
                    if (FinishedGenerating && !Solving)
                    {
                        if (WaitTime < Settings.Default.WaitTime && hasrun)
                        {
                            WaitTime += window.GetFrameTime();
                        }
                        else
                        {
                            WaitTime = 0;
                            CurrentCell = StartCell*2;
                            VisitedWalls[CurrentCell.X, CurrentCell.Y] = true;
                            CellStack.Clear();
                            Solving = true;
                            hasrun = true;
                        }
                        accumulator -= fps;
                        continue;
                    }
                    if (Solving && FinishedSolving)
                    {
                        if (WaitTime < Settings.Default.WaitTime)
                            WaitTime += window.GetFrameTime();
                        else
                        {
                            Solving = false;
                            FinishedGenerating = false;
                            FinishedSolving = false;
                            SetUpMaze();
                            continue;
                        }
                        continue;
                    }
                    if (Solving && !FinishedSolving)
                    {
                        if (Settings.Default.ShowSolving)
                            FinishedSolving = !SolveIterate(CellStack, Cells, Walls, StartCell, EndCell);
                        else
                        {
                            while (SolveIterate(CellStack, Cells, Walls, StartCell, EndCell)) ;
                            FinishedSolving = true;
                        }
                        accumulator -= fps;
                        continue;
                    }

                    if (Settings.Default.ShowGeneration)
                    {
                        FinishedGenerating = !GenerateIterate(CellStack, Cells, Walls);
                        hasrun = true;
                    }
                    else
                    {
                        while (GenerateIterate(CellStack, Cells, Walls)) ;
                        FinishedGenerating = true;
                    }
                    accumulator -= fps;
                    NeedsRedraw = true;
                }
                Render(window);
                window.Display();
                window.DispatchEvents();
            }
        }

        /// <summary>
        /// Switches to fullscreen mode.
        /// </summary>
        /// <param name="force">If true, the <see cref="RenderWindow"/> will be recreated even if already in fullscreen mode.</param>
        void SwitchToFullscreen(bool force = false)
        {
            if (!force && _isFullscreen)
                return;

            if (log.IsInfoEnabled)
                log.Info("Changing to fullscreen mode.");

            RenderWindow = null;

            var videoMode = new VideoMode((uint)FullscreenResolution.X, (uint)FullscreenResolution.Y);
            var newRW = new RenderWindow(videoMode, Title, Styles.Fullscreen);

            _isFullscreen = true;
            _usingCustomDisplayContainer = false;
            _displayContainer = null;

            RenderWindow = newRW;
        }

 ////////////////////////////////////////////////////////////
 /// <summary>
 /// Create the window with default creation settings
 /// </summary>
 /// <param name="mode">Video mode to use</param>
 /// <param name="title">Title of the window</param>
 /// <param name="style">Window style (Resize | Close by default)</param>
 ////////////////////////////////////////////////////////////
 public RenderWindow(VideoMode mode, string title, Styles style) :
     this(mode, title, style, new ContextSettings(24, 8))
 {
 }

        private void Init()
        {
            Music = new MusicPlayer();
            Sounds = new SoundManager();
            Assets = new Assets();
            Assets.Load();

            var vm = new SFML.Window.VideoMode(1000, 750, 32);
            var style = Styles.Close;
            var settings = new ContextSettings(0, 0, 8);

            Window = new SFML.Graphics.RenderWindow(vm, "", style, settings);
            Window.SetView(View);
            Window.SetVerticalSyncEnabled(true);
            Window.Closed += (sender, e) => { IsAppExited = true; };
            Window.LostFocus += (sender, e) => { IsPaused = true; };
            Window.GainedFocus += (sender, e) => { IsPaused = false; };
            Window.SetMouseCursorVisible(true);

            var splash = new Space("Splash", true);
            var menu = new Space("Menu");
            var inGame = new Space("InGame");
            var gameOver = new Space("GameOver");

            //  ----- ----- ----- Splash ----- ----- -----

            var images = new SplashImage[]
            {
                new SplashImage(Assets.Textures["sfml"], 3, 1, 1),
                new SplashImage(Assets.Textures["rsas"], 5, 1, 1)
            };

            SplashImage.Prepare(images, e =>
            {
                splash.IsActive = false;
                menu.IsActive = true;
            });

            foreach(var image in images)
                splash.Add(image);

            //  ----- ----- ----- Menu ----- ----- -----
            var btnStart = new MenuButton("Play", 40, new Vector(100, 100));
            var btnQuit = new MenuButton("Quit", 40, new Vector(100, 200));

            var btnDiffEasy = new MenuButton("Easy", 30, new Vector(250, 100));
            var btnDiffMedium = new MenuButton("Medium", 30, new Vector(250, 150));
            var btnDiffHard = new MenuButton("Hard", 30, new Vector(250, 200));

            var infoText =
                "- Instructions -\n" +
                "- Run, shoot and survive as long as possible.\n" +
                "- Collect white powersups to recover health.\n" +
                "- New weapons are unlocked after each 1000 kills.\n" +
                "\n" +
                "- Use WASD keys to move, and mouse to aim and shoot.\n" +
                "- Use the numbers keys to change weapons.\n" +
                "- During gameplay, press ESC to pause or F1 to give up.";
            var btnInfoText = new MenuButton(infoText, 20, new Vector(450, 125));

            var highscoreList = new HighscoreList(new Vector2f(50, 300));

            Difficulty = RSaS.Difficulty.Medium;
            btnDiffMedium.Text.Color = Color.Red;

            btnStart.Click += e =>
            {
                if (IsGameOver)
                {
                    IsGameOver = false;
                    InitInGame(inGame);
                }

                Music.Play("music");
                menu.IsActive = false;
                inGame.IsActive = true;
                IsOSCursorVisible = false;
            };

            btnQuit.Click += e =>
            {
                IsAppExited = true;
            };

            btnDiffEasy.Click += e =>
            {
                if (!IsGameOver)
                    return;

                Difficulty = RSaS.Difficulty.Easy;
                btnDiffEasy.Text.Color = Color.Red;
                btnDiffMedium.Text.Color = Color.White;
                btnDiffHard.Text.Color = Color.White;
            };

            btnDiffMedium.Click += e =>
            {
                if (!IsGameOver)
                    return;

//.........这里部分代码省略.........

 public Game(string title, uint width, uint height)
 {
     this.title = title;
     mode = new VideoMode(width, height);
     windowBounds = new FloatRect(new Vector2f(0, 0), new Vector2f(width, height));
 }

 private string GetVmString(VideoMode vm)
 {
     return vm.Width.ToString() + "x" + vm.Height.ToString() + " @ " + vm.BitsPerPixel+ " hz";
 }