/// <summary> /// The constructor is private: loading screens should /// be activated via the static Load method instead. /// </summary> private LoadingScreen (ScreenManager screenManager,bool loadingIsSlow, GameScreen[] screensToLoad) { this.loadingIsSlow = loadingIsSlow; this.screensToLoad = screensToLoad; TransitionOnTime = TimeSpan.FromSeconds (0.5); // If this is going to be a slow load operation, create a background // thread that will update the network session and draw the load screen // animation while the load is taking place. if (loadingIsSlow) { backgroundThread = new Thread (BackgroundWorkerThread); backgroundThreadExit = new ManualResetEvent (false); graphicsDevice = screenManager.GraphicsDevice; // Look up some services that will be used by the background thread. IServiceProvider services = screenManager.Game.Services; networkSession = (NetworkSession)services.GetService ( typeof(NetworkSession)); messageDisplay = (IMessageDisplay)services.GetService ( typeof(IMessageDisplay)); } }
public SongSelectionBox(GameScreen screen, Vector2 position, Vector2 size) : base(screen.ScreenManager.Game) { this.screen = screen; this.position = position; this.size = size; }
public Widget(GameScreen screen, ContentManager content) { Screen = screen; spriteBatch = screen.ScreenManager.SpriteBatch; contentManager = content; LoadContent(); }
// this is not a permanent solution! public static void LoadModScripts(GameScreen gameScreen, string dir) { foreach (string filename in Directory.GetFiles(dir)) { if (filename.EndsWith(".fazemod")) { bool add = false; // add this script to screen or not? Script scriptToAdd = GetScriptFromAssembly(filename); // we have got the script and it's initialized, but is it the one we want? if (scriptToAdd.SupportedScreenTypes != null) { foreach (Type type in scriptToAdd.SupportedScreenTypes) if (type == gameScreen.GetType()) add = true; } else add = true; if (add) { scriptToAdd.GameScreen = gameScreen; scriptToAdd.FileName = Path.GetFileName(filename); gameScreen.Scripts.Add(scriptToAdd); scriptToAdd.Init(); // dont forget to init them } } } }
public PauseScreen(GameScreen backgroundScreen, Player human, Player computer) : base(String.Empty) { IsPopup = true; this.backgroundScreen = backgroundScreen; // Create our menu entries. MenuEntry startGameMenuEntry = new MenuEntry("Return"); MenuEntry exitMenuEntry = new MenuEntry("Quit Game"); // Hook up menu event handlers. startGameMenuEntry.Selected += StartGameMenuEntrySelected; exitMenuEntry.Selected += OnCancel; // Add entries to the menu. MenuEntries.Add(startGameMenuEntry); MenuEntries.Add(exitMenuEntry); this.human = human; this.computer = computer; // Preserve the old state of the game prevHumanIsActive = this.human.Catapult.IsActive; prevCompuerIsActive = this.computer.Catapult.IsActive; // Pause the game logic progress this.human.Catapult.IsActive = false; this.computer.Catapult.IsActive = false; AudioManager.PauseResumeSounds(false); }
/// <summary> /// Constructor. /// </summary> public StoryScreen( List<String> storytext, List<String> titletext, GameScreen DestScreen, GameData saveData) : base(titletext[0]) { saveGameData = saveData; this.DestScreen = DestScreen; //SpriteFont font = ScreenManager.Font; //Get font of the ScreenManager // Create our menu entries. Storyline = storytext; StoryTitles = titletext; StorylineEntry = new VarSizeMenuEntry ( Storyline[0] , 0.7f); BlankEntry = new VarSizeMenuEntry ( " ", 0.7f); MenuEntry ContinueEntry = new VarSizeMenuEntry ( "Continue", 1f); // Hook up menu event handlers. ContinueEntry.Selected += continueSelected; // Add entries to the menu. MenuEntries.Add ( StorylineEntry ); MenuEntries.Add ( BlankEntry ); MenuEntries.Add ( ContinueEntry ); //Select the first selectable entry while (menuEntries[selectedEntry].HasNoHandle) { selectedEntry++; } }
// System.Drawing is NOT avaiable on WP7 or Xbox /* * http://stackoverflow.com/a/7394185/195722 * * * */ public static Texture2D GetTexture(this System.Drawing.Bitmap bitmap, GameScreen gameScreen) { BlendState oldstate = gameScreen.ScreenManager.GraphicsDevice.BlendState; gameScreen.ScreenManager.GraphicsDevice.BlendState = BlendState.AlphaBlend; Texture2D tex = new Texture2D(gameScreen.ScreenManager.GraphicsDevice, bitmap.Width, bitmap.Height, true, SurfaceFormat.Color); System.Drawing.Imaging.BitmapData data = bitmap.LockBits(new System.Drawing.Rectangle(0, 0, bitmap.Width, bitmap.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, bitmap.PixelFormat); int bufferSize = data.Height * data.Stride; //create data buffer byte[] bytes = new byte[bufferSize]; // copy bitmap data into buffer System.Runtime.InteropServices.Marshal.Copy(data.Scan0, bytes, 0, bytes.Length); // copy our buffer to the texture tex.SetData(bytes); // unlock the bitmap data bitmap.UnlockBits(data); gameScreen.ScreenManager.GraphicsDevice.BlendState = oldstate; return tex; }
public Scenario(GameScreen gameScreen, GameWorld world, Camera2D camera) : base(gameScreen, world, camera) { levelNumber = 0; physics.bodys = new Body[1]{ new Body(world) }; images = new List<SpriteSheet>(); }
/// <summary> /// The constructor is private: loading screens should /// be activated via the static Load method instead. /// </summary> private LoadingScreen(ScreenManager screenManager, bool loadingIsSlow, GameScreen[] screensToLoad) { this.loadingIsSlow = loadingIsSlow; this.screensToLoad = screensToLoad; TransitionOnTime = TimeSpan.FromSeconds(0.5); }
public void Draw(GameScreen screen) { // Grab some common items from the ScreenManager SpriteBatch spriteBatch = screen.ScreenManager.SpriteBatch; SpriteFont font = screen.ScreenManager.Font; spriteBatch.DrawString(font, Text, Position, Microsoft.Xna.Framework.Color.Yellow); }
public void AddScreen(GameScreen screen) { screen.ScreenManager = this; screen.IsExiting = false; if (isInitialized) screen.Activate(false); screens.Add(screen); }
/// <summary> /// The constructor is private: loading screens should /// be activated via the static Load method instead. /// </summary> private LoadingScreen(ScreenManager screenManager, bool loadingIsSlow, GameScreen[] screensToLoad) : base(false) { this.loadingIsSlow = loadingIsSlow; this.screensToLoad = screensToLoad; EnabledGestures = GestureType.Tap; // Monogame goes on an infinite loop if I don't do this.. }
public PhysicObject(GameScreen gameScreen, GameWorld world, Camera2D camera) : base(gameScreen.ScreenManager.Game) { this.gameScreen = gameScreen; physics.world = world; physics.bodys = null; this.camera = camera; }
/// <summary> /// Constructs a new menu entry with the specified text. /// </summary> public MenuButton(Texture2D sprite, bool flip, Vector2 position, GameScreen screen) { _screen = screen; _scale = 1f; _sprite = sprite; _baseOrigin = new Vector2(_sprite.Width / 2f, _sprite.Height / 2f); _hover = false; _flip = flip; Position = position; }
/// <summary> /// The constructor is private: loading screens should /// be activated via the static Load method instead. /// </summary> private LoadingScreen(ScreenManager screenManager, bool loadingIsSlow, GameScreen[] screensToLoad) { this.loadingIsSlow = loadingIsSlow; this.screensToLoad = screensToLoad; rnd = new Random(); randInt = rnd.Next(3); // 0 to 2 TransitionOnTime = TimeSpan.FromSeconds(0.5); }
public override void Draw(GameScreen screen, bool isSelected, GameTime gameTime) { ScreenManager screenManager = screen.ScreenManager; SpriteBatch spriteBatch = screenManager.SpriteBatch; GraphicsDevice graphics = screenManager.GraphicsDevice; outline.Location = position; outline.Width = (graphics.Viewport.Width / 45); outline.Height = (graphics.Viewport.Width / 10); spriteBatch.Draw(icon, outline, Color.White); }
public override void Draw(GameScreen screen, bool isSelected, Microsoft.Xna.Framework.GameTime gameTime) { ScreenManager screenManager = screen.ScreenManager; SpriteBatch spriteBatch = screenManager.SpriteBatch; GraphicsDevice graphics = screenManager.GraphicsDevice; outline.Location = position; outline.Width = ((graphics.PresentationParameters.BackBufferWidth / 45) * 14); outline.Height = (graphics.Viewport.Width / 30); spriteBatch.Draw(icon, outline, Color.SkyBlue); }
public Player(GameScreen gameScreen, GameWorld world, Camera2D camera) : base(gameScreen, world, camera) { rightwheelContacts = 0; leftwheelContacts = 0; jumpedTime = 0f; lookingLeft = false; timeOnAir = 0f; moving = false; resetNTImpulses(); }
/// <summary> /// The constructor is private: loading screens should /// be activated via the static Load method instead. /// </summary> private LoadingScreen(ScreenManager screenManager, bool loadingIsSlow, GameScreen[] screensToLoad) { this.loadingIsSlow = loadingIsSlow; this.screensToLoad = screensToLoad; // we don't serialize loading screens. if the user exits while the // game is at a loading screen, the game will resume at the screen // before the loading screen. IsSerializable = false; TransitionOnTime = TimeSpan.FromSeconds(0.5); }
/// <summary> /// Adds a new screen to the screen manager. /// </summary> public void AddScreen(GameScreen screen, PlayerIndex? controllingPlayer) { screen.ControllingPlayer = controllingPlayer; screen.ScreenManager = this; screen.IsExiting = false; // If we have a graphics device, tell the screen to load content. if (_isInitialized) { screen.LoadContent(); } screens.Add(screen); // update the TouchPanel to respond to gestures this screen is interested in TouchPanel.EnabledGestures = screen.EnabledGestures; }
public Collectible(GameScreen gameScreen, Shape shape, World world, Camera2D camera) : base(gameScreen.ScreenManager.Game) { this.gameScreen = gameScreen; this.world = world; body = new Body(world); body.CreateFixture(shape); body.CollisionCategories = Category.Cat3; body.CollidesWith = Category.Cat2; body.BodyType = BodyType.Kinematic; body.OnCollision += body_OnCollision; shootParticles = false; collected = false; this.camera = camera; }
public MusicSelectionScreen(GameScreen backgroundScreen) : base("Main") { IsPopup = true; this.backgroundScreen = backgroundScreen; // Get the default media source mediaSourcesList = MediaSource.GetAvailableMediaSources(); // Use only first one mediaLibrary = new MediaLibrary(mediaSourcesList[0]); // Create maximum 5 entries with music from music collection for (int i = 0; i < mediaLibrary.Songs.Count; i++) { if (i == 5) break; Song song = mediaLibrary.Songs[i]; // Create menu entry for the song. MenuEntry songMenuEntry = new MenuEntry(song.Name); // Hook up menu event handler songMenuEntry.Selected += OnSongSelected; // Add song to the menu MenuEntries.Add(songMenuEntry); } // Create our menu entries. MenuEntry cancelMenuEntry = new MenuEntry("Cancel"); // Hook up menu event handlers. cancelMenuEntry.Selected += OnCancel; // Add entries to the menu. MenuEntries.Add(cancelMenuEntry); }
/// <summary> /// Constructor. /// </summary> public PauseMenuScreen(GameScreen g) : base("Paused") { // Flag that there is no need for the game to transition // off when the pause menu is on top of it. IsPopup = true; source = g; // Create our menu entries. MenuEntry resumeGameMenuEntry = new MenuEntry("Resume Game"); MenuEntry switchAirplaneMenuEntry = new MenuEntry("Switch airplanes"); MenuEntry quitGameMenuEntry = new MenuEntry("Quit Game"); // Hook up menu event handlers. resumeGameMenuEntry.Selected += OnCancel; quitGameMenuEntry.Selected += QuitGameMenuEntrySelected; switchAirplaneMenuEntry.Selected += SwitchAirplaneMenuEntrySelected; // Add entries to the menu. MenuEntries.Add(resumeGameMenuEntry); MenuEntries.Add(switchAirplaneMenuEntry); MenuEntries.Add(quitGameMenuEntry); }
/// <summary> /// Removes a screen from the screen manager. You should normally /// use GameScreen.ExitScreen instead of calling this directly, so /// the screen can gradually transition off rather than just being /// instantly removed. /// </summary> public void RemoveScreen(GameScreen screen) { // If we have a graphics device, tell the screen to unload content. if (isInitialized) { screen.UnloadContent(); } screens.Remove(screen); screensToUpdate.Remove(screen); // if there is a screen still in the manager, update TouchPanel // to respond to gestures that screen is interested in. if (screens.Count > 0) { TouchPanel.EnabledGestures = screens[screens.Count - 1].EnabledGestures; } }
/// <summary> /// Allows each screen to run logic. /// </summary> public override void Update(GameTime gameTime) { UpdateTouchPanelSize(); // Read the keyboard and gamepad. if (!SuppressInputUpdate) { _input.Update(gameTime); } SuppressInputUpdate = false; // Make a copy of the master screen list, to avoid confusion if // the process of updating one screen adds or removes others. _tempScreensList.Clear(); foreach (GameScreen screen in _screens) { _tempScreensList.Add(screen); } bool otherScreenHasFocus = !Game.IsActive; bool coveredByOtherScreen = false; // Loop as long as there are screens waiting to be updated. while (_tempScreensList.Count > 0) { // Pop the topmost screen off the waiting list. GameScreen screen = _tempScreensList[_tempScreensList.Count - 1]; _tempScreensList.RemoveAt(_tempScreensList.Count - 1); // Update the screen. screen.Update(gameTime, otherScreenHasFocus, coveredByOtherScreen); if (screen.ScreenState == ScreenState.TransitionOn || screen.ScreenState == ScreenState.Active) { // If this is the first active screen we came across, // give it a chance to handle input. if (!otherScreenHasFocus) { screen.HandleInput(gameTime, _input); otherScreenHasFocus = true; } // If this is an active non-popup, inform any subsequent // screens that they are covered by it. if (!screen.IsPopup) { coveredByOtherScreen = true; } } } ScrollableGame.End(); // Print debug trace? if (_traceEnabled) { TraceScreens(); } }
/// <summary> /// Adds a new screen to the screen manager. /// </summary> public void AddScreen(GameScreen screen, PlayerIndex? controllingPlayer) { screen.ControllingPlayer = controllingPlayer; screen.ScreenManager = this; screen.IsExiting = false; // If we have a graphics device, tell the screen to load content. if (isInitialized) { screen.Activate(false); } screens.Add(screen); }
public bool Activate(bool instancePreserved) #endif { #if !WINDOWS_PHONE && !WINDOWS && !ANDROID return(false); #else // If the game instance was preserved, the game wasn't dehydrated so our screens still exist. // We just need to activate them and we're ready to go. if (instancePreserved) { // Make a copy of the master screen list, to avoid confusion if // the process of activating one screen adds or removes others. _tempScreensList.Clear(); foreach (GameScreen screen in _screens) { _tempScreensList.Add(screen); } foreach (GameScreen screen in _tempScreensList) { screen.Activate(true); } } // Otherwise we need to refer to our saved file and reconstruct the screens that were present // when the game was deactivated. else { // Try to get the screen factory from the services, which is required to recreate the screens var screenFactory = Game.Services.GetService(typeof(IScreenFactory)) as IScreenFactory; if (screenFactory == null) { throw new InvalidOperationException( "Game.Services must contain an IScreenFactory in order to activate the ScreenManager."); } #if WINDOWS8 StorageFolder folder = ApplicationData.Current.LocalFolder; try { using (Stream file = await folder.OpenStreamForReadAsync(StateFilename)) { #else // Open up isolated storage using (IsolatedStorageFile storage = IsolatedStorageFile.GetUserStoreForApplication()) { // Check for the file; if it doesn't exist we can't restore state if (!storage.FileExists(StateFilename)) { return(false); } // Read the state file so we can build up our screens using (IsolatedStorageFileStream file = storage.OpenFile(StateFilename, FileMode.Open)) { #endif XDocument doc = XDocument.Load(file); // Iterate the document to recreate the screen stack foreach (XElement screenElem in doc.Root.Elements("GameScreen")) { // Use the factory to create the screen Type screenType = Type.GetType(screenElem.Attribute("Type").Value); GameScreen screen = screenFactory.CreateScreen(screenType); if (screen != null) { // Add the screen to the screens list and activate the screen screen.ScreenManager = this; _screens.Add(screen); if (screen.content == null) { screen.content = new ContentManager(Game.Services, Game.Content.RootDirectory); } screen.Activate(false); // update the TouchPanel to respond to gestures this screen is interested in TouchPanel.EnabledGestures = screen.EnabledGestures; } } } } #if WINDOWS8 catch (FileNotFoundException) { return(false); } #endif } return(true); #endif }
public static void Load(GameScreen gameScreen, PrefabType prefabType) { if(textures.ContainsKey(prefabType)) return; textures.Add(prefabType, gameScreen.Load<Texture2D>(GetTextureName(prefabType))); }
/// <summary> /// Removes a screen from the screen manager. You should normally /// use GameScreen.ExitScreen instead of calling this directly, so /// the screen can gradually transition off rather than just being /// instantly removed. /// </summary> public void RemoveScreen(GameScreen screen) { // If we have a graphics device, tell the screen to unload content. if (isInitialized) { screen.Unload(); } screens.Remove(screen); tempScreensList.Remove(screen); }
/// <summary> /// Removes a screen from the screen manager. You should normally /// use GameScreen.ExitScreen instead of calling this directly, so /// the screen can gradually transition off rather than just being /// instantly removed. /// </summary> public void RemoveScreen(GameScreen screen) { // If we have a graphics device, tell the screen to unload content. if (isInitialized) { screen.UnloadContent(); } screens.Remove(screen); screensToUpdate.Remove(screen); }
/// <summary> /// Draws the UIElement. This should be called by other elements and not overriden /// </summary> /// <param name="screen">The screen drawing the button</param> public void Draw(GameScreen screen, GameTime gameTime, SpriteBatch spriteBatch, SpriteDrawer spriteDrawer) { if (!Visible) { // element is not visible. don't draw it return; } MyScreen = screen; MyScreenManager = screen.ScreenManager; MyGameTime = gameTime; MySpriteBatch = spriteBatch; MySpriteDrawer = spriteDrawer; // can set more properties to the screen like opacity/overlay here // also can set boundries to not allow drawthis to drow outside the given size and position DrawThis(); }
/// <summary> /// Draws the button /// </summary> /// <param name="screen">The screen drawing the button</param> public void Draw(GameScreen screen) { // Grab some common items from the ScreenManager SpriteBatch spriteBatch = screen.ScreenManager.SpriteBatch; SpriteFont font = screen.ScreenManager.Font; Texture2D blank = screen.ScreenManager.BlankTexture; // Compute the button's rectangle Rectangle r = new Rectangle( (int)Position.X, (int)Position.Y, (int)Size.X, (int)Size.Y); // Fill the button spriteBatch.Draw(blank, r, FillColor * Alpha); // Draw the border spriteBatch.Draw( blank, new Rectangle(r.Left, r.Top, r.Width, BorderThickness), BorderColor * Alpha); spriteBatch.Draw( blank, new Rectangle(r.Left, r.Top, BorderThickness, r.Height), BorderColor * Alpha); spriteBatch.Draw( blank, new Rectangle(r.Right - BorderThickness, r.Top, BorderThickness, r.Height), BorderColor * Alpha); spriteBatch.Draw( blank, new Rectangle(r.Left, r.Bottom - BorderThickness, r.Width, BorderThickness), BorderColor * Alpha); // Draw the text centered in the button Vector2 textSize = font.MeasureString(Text); Vector2 textPosition = new Vector2(r.Center.X, r.Center.Y) - textSize / 2f; textPosition.X = (int)textPosition.X; textPosition.Y = (int)textPosition.Y; spriteBatch.DrawString(font, Text, textPosition, TextColor * Alpha); }
public bool DeserializeState() { // open up isolated storage using (IsolatedStorageFile storage = IsolatedStorageFile.GetUserStoreForApplication()) { // see if our saved state directory exists if (storage.DirectoryExists("ScreenManager")) { try { // see if we have a screen list if (storage.FileExists("ScreenManager\\ScreenList.dat")) { // load the list of screen types using (IsolatedStorageFileStream stream = storage.OpenFile("ScreenManager\\ScreenList.dat", FileMode.Open, FileAccess.Read)) { using (BinaryReader reader = new BinaryReader(stream)) { while (reader.BaseStream.Position < reader.BaseStream.Length) { // read a line from our file string line = reader.ReadString(); // if it isn't blank, we can create a screen from it if (!string.IsNullOrEmpty(line)) { Type screenType = Type.GetType(line); GameScreen screen = Activator.CreateInstance(screenType) as GameScreen; AddScreen(screen, PlayerIndex.One); } } } } } // next we give each screen a chance to deserialize from the disk for (int i = 0; i < screens.Count; i++) { string filename = string.Format("ScreenManager\\Screen{0}.dat", i); using (IsolatedStorageFileStream stream = storage.OpenFile(filename, FileMode.Open, FileAccess.Read)) { screens[i].Deserialize(stream); } } return(true); } catch (Exception) { // if an exception was thrown while reading, odds are we cannot recover // from the saved state, so we will delete it so the game can correctly // launch. DeleteState(storage); } } } return(false); }
public bool Activate(bool instancePreserved) { #if !WINDOWS_PHONE return(false); #else // If the game instance was preserved, the game wasn't dehydrated so our screens still exist. // We just need to activate them and we're ready to go. if (instancePreserved) { // Make a copy of the master screen list, to avoid confusion if // the process of activating one screen adds or removes others. tempScreensList.Clear(); foreach (GameScreen screen in screens) { tempScreensList.Add(screen); } foreach (GameScreen screen in tempScreensList) { screen.Activate(true); } } // Otherwise we need to refer to our saved file and reconstruct the screens that were present // when the game was deactivated. else { // Try to get the screen factory from the services, which is required to recreate the screens IScreenFactory screenFactory = Game.Services.GetService(typeof(IScreenFactory)) as IScreenFactory; if (screenFactory == null) { throw new InvalidOperationException( "Game.Services must contain an IScreenFactory in order to activate the ScreenManager."); } // Open up isolated storage using (IsolatedStorageFile storage = IsolatedStorageFile.GetUserStoreForApplication()) { // Check for the file; if it doesn't exist we can't restore state if (!storage.FileExists(StateFilename)) { return(false); } // Read the state file so we can build up our screens using (IsolatedStorageFileStream stream = storage.OpenFile(StateFilename, FileMode.Open)) { XDocument doc = XDocument.Load(stream); // Iterate the document to recreate the screen stack foreach (XElement screenElem in doc.Root.Elements("GameScreen")) { // Use the factory to create the screen Type screenType = Type.GetType(screenElem.Attribute("Type").Value); GameScreen screen = screenFactory.CreateScreen(screenType); // Rehydrate the controlling player for the screen PlayerIndex?controllingPlayer = screenElem.Attribute("ControllingPlayer").Value != "" ? (PlayerIndex)Enum.Parse(typeof(PlayerIndex), screenElem.Attribute("ControllingPlayer").Value, true) : (PlayerIndex?)null; screen.ControllingPlayer = controllingPlayer; // Add the screen to the screens list and activate the screen screen.ScreenManager = this; screens.Add(screen); screen.Activate(false); // update the TouchPanel to respond to gestures this screen is interested in TouchPanel.EnabledGestures = screen.EnabledGestures; } } } } return(true); #endif }