Question

I’m working on writing a splash screen that returns a game mode (int) and an IP address (string). The idea is the splash screen runs, takes user input and then runs the main game with these options. I’m using a thread to achieve this – the thread polls for an exit request from the splash screen, then pulls the values out to program.cs and calls exit() on splash.

The main game runs on it’s own with no issues but with the splash screen enabled the game runs just 1 frame and seems to be disposed of by garbage collection after running the update method. (returns a DisposedObjectException or something of the sort if trying to reference it) After a bit of debugging I’ve found the issue is with the exit command. Code is as follows:

using System;
using System.Threading;

namespace SplashScreen
{
    static class Program
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        static void Main(string[] args)
        {
            int choice = 0;
            string ip = "";
            bool runSplash = true;
            bool useThreading = true;
            bool ignoreThreadResponse = false;
            // Debug option, toggle running splash screen
            if (runSplash == true)
            {
                bool splashrunning = true;
                using (Splash1 splash = new Splash1())
                {
                    if (useThreading)
                    {
                        // Run a thread to poll whether the splash screen has requested an exit every 0.5 seconds
                        Thread t = new Thread(() =>
                        {
                            while (splashrunning)
                            {
                                // If splash requests exit pull gameMode choice and IP Address before killing it, then quit this thread
                                if (splash.requestingExit)
                                {
                                    choice = splash.choice;
                                    ip = splash.ip;
                                    // The offending piece of code, without this you can simply select an option, force close and second part runs fine
                                    //splash.Exit();
                                    splashrunning = false;
                                }
                                Thread.Sleep(500);
                            }
                        });
                        t.Start();
                    }
                    splash.Run();
                }
            }
            // If splash screen is not running, assign default values
            if(!useThreading || !runSplash || ignoreThreadResponse)
            {
                choice = 2;
                ip = "127.0.0.1";
            }
            if (choice != 0)
            {
                // This game is picked up by garbage collection after running Update once
                using (Game1 game = new Game1(choice, ip))
                {
                    game.Run();
                }
            }
        }
    }
}

When splash.Exit() is called, it causes game1 to be collected after the first update. If I disable threading it works fine. If I exit using the X at the top right it works fine. Whether or not I ignore the thread response the game fails to run if threading is enabled and I call splash.Exit().

What I’m looking for is any of the following:

• A reason why the second game is being collected.

• An alternative way to exit a game or call the ‘close window’ (big red x) function.

• A better way of implementing this.

I’ve used console input to do this in the past, but I want to move on to using a graphical interface instead of an ugly command prompt for the user.

Edit:
Turns out I was almost there. While GSM is probably the correct way of doing things, for anyone who just wants to grab the code from the question and throw caution to the wind you simply need to add a thread to run the second game.
I’m pretty sure this isn’t ideal, but it’s a lot less tweaking in my case.

Thread gt = new Thread(() =>
{
    using (Game1 game = new Game1(choice, ip))
    {
        game.Run();
    }
});
gt.Start();

So while I’d recommend anyone starting from scratch to use GSM, this might be a quick solution for someone else just trying to get it running.

Answer 1

What does your Splash class look like? Exit is a method of the Game class, and exits the game. Is your Splash class inheriting Game? If so, it shouldn’t.

Edit:

After reading the bottom half of your post a bit more clearly – you should only have a single class that inherits from Game, and it should run your game. If you want to display a splash screen it should be a custom class, or look into the Game State Management sample.