root/Code/oMaE/oMaE/GameDriver.cs @ 119

Revision 119, 12.8 KB (checked in by acarter, 2 years ago)

Committed in semi-stable state

Line 
1using System;
2using System.Collections.Generic;
3using System.Linq;
4using Microsoft.Xna.Framework;
5using Microsoft.Xna.Framework.Audio;
6using Microsoft.Xna.Framework.Content;
7using Microsoft.Xna.Framework.GamerServices;
8using Microsoft.Xna.Framework.Graphics;
9using Microsoft.Xna.Framework.Input;
10using Microsoft.Xna.Framework.Media;
11
12namespace oMaE
13{
14    using MiniGames;
15    using Widgets;
16    using Screens;
17    using Overworld;
18    using Sequence;
19    /// <summary>
20    /// This is the main driver for the game
21    /// </summary>
22    public class GameDriver : Game
23    {
24        /// <summary>
25        ///  The device manager for the 3D graphics.
26        /// </summary>
27        private GraphicsDeviceManager graphics;
28        /// <summary>
29        ///  The sprite manager for the 2D graphics.
30        /// </summary>
31        private SpriteBatch spriteBatch;
32        /// <summary>
33        /// Holds the current gamestate with respect to User Input.
34        /// </summary>
35        private GameState gamestate = new GameState();
36        /// <summary>
37        /// The map of the world.
38        /// </summary>
39        public Map Map = new Map(0);
40        /// <summary>
41        /// The display for the 3D game.
42        /// </summary>
43        public Display3D World3D;
44        /// <summary>
45        /// All of the 2D world components.
46        /// </summary>
47        public GameObject World2D = new GameObject();
48        /// <summary>
49        /// The Minigame factory for making minigames.
50        /// </summary>
51        public MinigameFactory Minigames = new MinigameFactory();
52        /// <summary>
53        /// The screen factory for the screens of the game.
54        /// </summary>
55        public ScreenFactory Screens = new ScreenFactory();
56        /// <summary>
57        /// Projection matrix for the game.
58        /// </summary>
59        public static Matrix ProjectionMatrix;
60        /// <summary>
61        /// The display for the game.
62        /// </summary>
63        private Screen2D display = new Screen2D(1000, 500);
64        /// <summary>
65        /// The main screen when the game is loaded.
66        /// </summary>
67        private MainScreen mainScreen = new MainScreen();
68        /// <summary>
69        /// The menu for the game.
70        /// </summary>
71        private GameObject gameMenu = new GameMenu();
72        /// <summary>
73        /// The current screen that is displayed.
74        /// </summary>
75        private GameObject currentScreen = null;
76        /// <summary>
77        /// The current screen that is displayed.
78        /// </summary>
79        private GameObject currentMinigame = null;
80        private GameObject openingSequence = new Opening();
81        /// <summary>
82        /// Creates a new default game driver.
83        /// </summary>
84        public GameDriver()
85        {
86            graphics = new GraphicsDeviceManager(this);
87            graphics.PreferredBackBufferWidth = 1000;
88            graphics.PreferredBackBufferHeight = 500;
89            Content.RootDirectory = "Content";
90        }
91
92        /// <summary>
93        /// Allows the game to perform any initialization it needs to before starting to run.
94        /// This is where it can query for any required services and load any non-graphic
95        /// related content.  Calling base.Initialize will enumerate through any components
96        /// and initialize them as well.
97        /// </summary>
98        protected override void Initialize()
99        {
100            // TODO: Add your initialization logic here
101            ProjectionMatrix = Matrix.CreatePerspectiveFieldOfView(MathHelper.ToRadians(45.0f), GraphicsDevice.DisplayMode.AspectRatio, 1.0f, 10000.0f);
102            World2D.Add(Minigames);
103            World2D.Add(Screens);
104            World2D.Add(gameMenu);
105            World2D.Add(Map);
106            World2D.Add(Play2DGame(mainScreen, new Vector2(0,0), Map.mStart));
107            World2D.Add(openingSequence);
108
109            this.IsMouseVisible = true;
110            World2D.InitializeAll(this);
111            base.Initialize();
112        }
113
114        /// <summary>
115        /// LoadContent will be called once per game and is the place to load
116        /// all of your content.
117        /// </summary>
118        protected override void LoadContent()
119        {
120            // Create a new SpriteBatch, which can be used to draw textures.
121            spriteBatch = new SpriteBatch(GraphicsDevice);
122            display.LoadContent(spriteBatch, Content);
123            World2D.LoadAllContent(Content);
124            if (MainScreen.speech != null)
125            {
126                MainScreen.speech.IsLooped = true;
127                MainScreen.speech.Play();
128            }
129        }
130
131        /// <summary>
132        /// UnloadContent will be called once per game and is the place to unload
133        /// all content.
134        /// </summary>
135        protected override void UnloadContent()
136        {
137            // TODO: Unload any non ContentManager content here
138        }
139
140        /// <summary>
141        /// Allows the game to run logic such as updating the world,
142        /// checking for collisions, gathering input, and playing audio.
143        /// </summary>
144        /// <param name="gameTime">Provides a snapshot of timing values.</param>
145        protected override void Update(GameTime gameTime)
146        {
147            // Allows the game to exit
148            gamestate.Update(gameTime, Keyboard.GetState(), Mouse.GetState());
149            // TODO move this into Display3D
150            if (gamestate.CurrentKeyboardState.IsKeyDown(Keys.Escape))
151                this.Exit();
152            // updates world
153            World2D.UpdateAll(gamestate);
154            if(World3D != null)
155                World3D.UpdateAll(gamestate);
156            if(test != null)
157                test.UpdateAll(gamestate);
158            base.Update(gameTime);
159        }
160
161        /// <summary>
162        /// This is called when the game should draw itself.
163        /// </summary>
164        /// <param name="gameTime">Provides a snapshot of timing values.</param>
165        protected override void Draw(GameTime gameTime)
166        {
167            GraphicsDevice.Clear(Color.MediumPurple);
168            GraphicsDevice.DepthStencilState = DepthStencilState.Default;
169            if(World3D != null)
170                World3D.DrawAll(display, gamestate);
171            World2D.DrawAll(display, gamestate);
172            base.Draw(gameTime);
173        }
174
175        /// <summary>
176        /// A wrapper function for Minigame Minigames's getMinigame.
177        /// </summary>
178        /// <returns>Returns a new minigame.</returns>
179        public MiniGame GetMinigame()
180        {
181            return Minigames.getMiniGame();
182        }
183        LoadSave test;
184        /// <summary>
185        /// Starts the game.
186        /// </summary>
187        /// <param name="mainMenu">The main menu.</param>
188        /// <returns>The input game object.</returns>
189        ///
190        public GameObject PlayGame(GameObject mainMenu)
191        {
192            mainMenu.Visible = false;
193            if (MainScreen.speech != null)
194                MainScreen.speech.Stop();
195
196            Map.Reset();
197            Minigames.Reset(Content);
198           
199            // FIXME
200            test = new LoadSave();
201            test.InitializeAll(this);
202            test.NewGame(Minigames.sequence);
203
204            World3D = new Display3D();
205            World3D.Completed = new bool[11];
206            for (int i = 0; i < 11; ++i)
207                World3D.Completed[i] = false;
208
209            World3D.InitializeAll(this);
210            World3D.LoadAllContent(Content);
211            World3D.reset();
212
213            openingSequence.Visible = true;
214            // EndSequence(); // Remove this when playing opening sequence
215            return mainMenu;
216        }
217        /// <summary>
218        /// Ends the sequence.
219        /// </summary>
220        public void EndSequence()
221        {
222            World3D.Visible = true;
223            Play2DGame(Map.Entrance.DoorLock, new Vector2(0, 0), Map.mStart);
224            // FIXME
225            Map.Entrance.DoorLock.Back.Visible = false;
226        }
227
228        private Point mLoc;
229        private Vector2 otherSide = Vector2.Zero;
230        /// <summary>
231        /// Starts a minigame.
232        /// </summary>
233        /// <param name="game">The minigame that was started.</param>
234        /// <param name="otherSide">The location to move to if successful.</param>
235        /// <param name="mLoc">The location of the door on the minimap.</param>
236        /// <returns>The input game object.</returns>
237        public GameObject Play2DGame(GameObject game, Vector2 otherSide, Point mLoc)
238        {
239            game.Visible = true;
240            this.otherSide = otherSide;
241            this.mLoc = mLoc;
242            if(World3D != null)
243                World3D.Visible = false;
244            try
245            {
246                MiniGame temp = (MiniGame)game;
247                if (temp.Completed)
248                    CompleteMinigame(game);
249            }
250            catch (Exception)
251            {
252            }
253            return game;
254        }
255
256        /// <summary>
257        /// Displays the game menu.
258        /// </summary>
259        public void DisplayGameMenu()
260        {
261            World3D.Updating = false;
262            gameMenu.Visible = true;
263        }
264        /// <summary>
265        /// Displays the map.
266        /// </summary>
267        public void DisplayMap()
268        {
269            World3D.Updating = false;
270            Map.Visible = true;
271        }
272        /// <summary>
273        /// Closes the map.
274        /// </summary>
275        public void CloseMap()
276        {
277            World3D.Visible = true;
278            Map.Visible = false;
279        }
280        /// <summary>
281        /// Closes the game menu.
282        /// </summary>
283        public void CloseGameMenu()
284        {
285            World3D.Visible = true;
286            gameMenu.Visible = false;
287        }
288        /// <summary>
289        /// Displays the main menu.
290        /// </summary>
291        public void DisplayMainMenu()
292        {
293            World3D.reset();
294            World3D.Visible = false;
295            if (currentMinigame != null)
296                currentMinigame.Visible = false;
297            if (currentScreen != null)
298                currentScreen.Visible = false;
299            gameMenu.Visible = false;
300
301            if(MainScreen.speech != null)
302                MainScreen.speech.Play();
303            mainScreen.Visible = true;
304        }
305        /// <summary>
306        /// Grab a new item.
307        /// </summary>
308        public void GetNewItem()
309        {
310            if (World3D.UI.MapVisible)
311            {
312                Screens.Inventory.FindPart();
313                DisplayScreen(Screens.Inventory);
314
315            }
316            else
317            {
318                World3D.UI.MapVisible = true;
319                DisplayMap();
320            }
321        }
322        /// <summary>
323        /// Displays a screen such as the inventory, or encyclophant.
324        /// </summary>
325        /// <param name="screen">The screen to be displayed.</param>
326        /// <returns>The screen that is now displayed.</returns>
327        public GameObject DisplayScreen(GameObject screen)
328        {
329            if (currentScreen != null)
330                CloseScreen();
331            currentScreen = screen;
332            screen.Visible = true;
333            World3D.Visible = false;
334            return screen;
335        }
336
337        /// <summary>
338        /// Ends a minigame without solving it.
339        /// </summary>
340        /// <param name="game">The minigame that was ended.</param>
341        /// <returns>The input game object.</returns>
342        public GameObject QuitMinigame(GameObject game)
343        {
344            game.Visible = false;
345            World3D.Visible = true;
346            return game;
347        }
348
349        /// <summary>
350        /// Succesfully completed a minigame.
351        /// </summary>
352        /// <param name="game">The minigame that was completed.</param>
353        /// <returns>The input game object.</returns>
354        public GameObject CompleteMinigame(GameObject game)
355        {
356            // FIXME
357            Map.Entrance.DoorLock.Back.Visible = true;
358            game.Visible = false;
359            World3D.Visible = true;
360            World3D.SetLocation(otherSide);
361            Map.EnterRoom(this.mLoc);
362            return game;
363        }
364        /// <summary>
365        /// Closes the current screen.
366        /// </summary>
367        ///
368        /// <returns>The screen that was closed.</returns>
369        public GameObject CloseScreen()
370        {
371            GameObject screen = currentScreen;
372            currentScreen = null;
373            if (screen != null)
374            {
375                screen.Visible = false;
376                World3D.Visible = true;
377            }
378            return screen;
379        }
380    }
381}
Note: See TracBrowser for help on using the browser.