MonoGame.Samples/NetRumble/Core/NetRumbleGame.cs

//-----------------------------------------------------------------------------
// NetRumbleGame.cs
//
// Microsoft XNA Community Game Platform
// Copyright (C) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------

using System;
using System.IO;
using System.Collections.Generic;
using System.Reflection;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Net;
using Microsoft.Xna.Framework.GamerServices;

namespace NetRumble
{
    /// <summary>
    /// While this used to be an enum in the XNA Framework API, it was removed in version 4.0.
    /// However, it is still useful as a parameter to specify what kind of particles to draw,
    /// so it is revitalized here as a global enum.
    /// </summary>
    public enum SpriteBlendMode
    {
        Additive,
        AlphaBlend
    }

    /// <summary>
    /// The main type for this game.
    /// </summary>
    public class NetRumbleGame : Microsoft.Xna.Framework.Game
    {


        /// <summary>
        /// The graphics device manager used to render the game.
        /// </summary>
        GraphicsDeviceManager graphicsDeviceManager;






        /// <summary>
        /// The manager for all of the user-interface data.
        /// </summary>
        ScreenManager screenManager;






        /// <summary>
        /// Constructs a new NetRumbleGame object.
        /// </summary>
        public NetRumbleGame()
        {
            // initialize the graphics device manager
            graphicsDeviceManager = new GraphicsDeviceManager(this);

            graphicsDeviceManager.PreferredBackBufferWidth = ScreenManager.BASE_BUFFER_WIDTH;
            graphicsDeviceManager.PreferredBackBufferHeight = ScreenManager.BASE_BUFFER_HEIGHT;

            if (UIUtility.IsMobile)
            {
                graphicsDeviceManager.IsFullScreen = true;
                IsMouseVisible = false;
            }
            else if (UIUtility.IsDesktop)
            {
                graphicsDeviceManager.IsFullScreen = false;
                IsMouseVisible = true;
            }
            else
            {
                throw new PlatformNotSupportedException();
            }

            // initialize the content manager
            Content.RootDirectory = "Content";

            // initialize the gamer-services component
            //   this component enables Live sign-in functionality
            //   and updates the Gamer.SignedInGamers collection.
            Components.Add(new GamerServicesComponent(this));

            // initialize the screen manager
            screenManager = new ScreenManager(this);
            Components.Add(screenManager);

            // initialize the audio system
            var audioPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, Content.RootDirectory, "Audio", "wav");
            AudioManager.Initialize(this, new DirectoryInfo(audioPath));
        }


        /// <summary>
        /// Allows the game to perform any initialization it needs to before starting.
        /// This is where it can query for any required services and load any
        /// non-graphic related content.  Calling base.Initialize will enumerate through
        /// any components and initialize them as well.
        /// </summary>
        protected override void Initialize()
        {
            base.Initialize();

            // Useful to turn on SimulateTrialMode here if you want to test launching the game
            // from an invite and have it start in trial mode.
            //#if DEBUG
            //            Guide.SimulateTrialMode = true;
            //#endif

            // load the initial screens
            screenManager.AddScreen(new BackgroundScreen());
            screenManager.AddScreen(new MainMenuScreen());

            // hookup the invite event-processing function
            NetworkSession.InviteAccepted += new EventHandler<InviteAcceptedEventArgs>(NetworkSession_InviteAccepted);
        }

        /// <summary>
        /// Begins the asynchronous process of joining a game from an invitation.
        /// </summary>
        void NetworkSession_InviteAccepted(object sender, InviteAcceptedEventArgs e)
        {
            if (Guide.IsTrialMode)
            {
                screenManager.invited = e.Gamer as SignedInGamer;

                string message = "Need to unlock full version before you can accept this invite.";
                MessageBoxScreen messageBox = new MessageBoxScreen(message);
                screenManager.AddScreen(messageBox);

                System.Console.WriteLine("Cannot accept invite yet because we're in trial mode");

                return;
            }

            // We will join the game from a method in this screen.
            MainMenuScreen mainMenu = null;

            // Keep the background screen and main menu screen but remove all others
            // to prepare for joining the game we were invited to.
            foreach (GameScreen screen in screenManager.GetScreens())
            {
                if (screen is BackgroundScreen)
                {
                    continue;
                }
                else if (screen is MainMenuScreen)
                {
                    mainMenu = screen as MainMenuScreen;
                }
                else
                {
                    // If there's an active network session, we'll need to end it
                    // before attempting to join a new one.
                    MethodInfo method = screen.GetType().GetMethod("EndSession");
                    if (method != null)
                    {
                        method.Invoke(screen, null);
                    }

                    // Now exit and remove this screen.
                    screen.ExitScreen();
                    screenManager.RemoveScreen(screen);
                }
            }

            // Now attempt to join the game to which we were invited!
            if (mainMenu != null)
                mainMenu.JoinInvitedGame();
        }
        
        /// <summary>
        /// This is called when the game should draw itself.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Draw(GameTime gameTime)
        {
            graphicsDeviceManager.GraphicsDevice.Clear(Color.MonoGameOrange);

            base.Draw(gameTime);
        }
    }
}