2d xna game project

Sort options. Star Gideros Release version. Updated Jan 12, C. In the Wake of Gods 3. Updated May 18, C. A simple 2D Fighting Game. Updated Jul 10, C. Updated Feb 26, C. Updated Feb 23, C. Updated Aug 21, C. Updated Apr 24, C. Updated Jun 28, C. Star 8. Updated May 4, C. Updated Mar 19, C. Star 6. This is part four of a four part series covering sprite movement. Part four covers adding the code to the project to make the Wizard sprite shoot fireballs.

This tutorial covers the basics of creating and maintaing projectiles. A tutorial developed to show how to achieve a fade in, fade out effect with a a 2D image.

This tutorial walks you through creating a game project, adding an image to that project, displaying the image and adding the effect of fading the image in and out of the scene. Along with the tutorial and it's source code, there is an enhanced sample showing multiple images fading in and out of the scene Cheshire cat style which can be downloaded from within the tutorial.

A tutorial developed to show how to create an RTS style selection box. This tutorial walks you through creating a game project, adding an image to that project, displaying the image, making the mouse pointer visible and using the mouse to create a selection box.

Along with the tutorial and it's source code, there is an enhanced sample showing how you can use the selection box to select some simple "units" and move them around the game window. This method simply uses intersection checks built into the XNA framework to determine whether the projectile intersects i. You will notice placeholders for sound playback and might notice that we once more use constants in place of sizes relative to the catapult asset. We do this as we will retrieve asset sizes using the Animation game class which we have yet to implement.

This concludes our current iteration for the Catapult class. We will now move yet again to the various player classes and expand them further. This concludes all work on the AI class and we can move on to the Human class.

While lengthy, the above method is rather simple. This [A21] [A22] is exactly what the above method is responsible for, all the while updating a variable which will be used to draw visual feedback as the user drags the finger across the display. This concludes our update to the game classes at this stage.

We will now move to the GameplayScreen class to implement the final pieces of game logic. This method is divided into several main segments. We first check whether the game is over, which happens when one of the players reaches a score of five points, and update a flag accordingly in the upcoming exercise, we will also play appropriate sounds.

We then check whether the current turn is over, and reset some fields for the next turn, depending on which type of player has just played either the human player or the computer player. In addition, assuming a turn has ended, we update the wind. Finally, we ask both players to perform respective updates and change the position of the clouds inside the UpdateClouds helper which we will implement next.

This simply updates the positions of the clouds according to the wind, and causes them to wrap around the screen should they exit its boundaries. All the above method does is to handle input that instructs the game to pause or end- using helper methods, which we will soon implement- and pass gesture information to the Human class for processing.

While the game is fully playable in its current state, the game experience is lessened by the lacking presentation. Let us clarify the meaning of the above properties. The above method simply advances the animation by a single frame, stopping the animation if it has reached the final frame. The above methods simply draw the portion of the animation sheet that matches the current frame, with the second override allowing the animation to be scaled.

We now have a class which represents an animation and encapsulates its functionality. We will now add an additional class to support sound playback. The final method enables support for background, and will not be used in the course of this exercise [A25]. Now that we have support for both animation and sound, we can revisit the various classes created during the previous tasks in order to enhance their functionality.

These new fields will be used to map animations to a specific name and to define important frames in the course of specific animations. The above code goes over the animation definition XML file, which is one of the assets contained in the project, and translates the animations defined in the file into instances of the Animation class we have defined.

The above version of the method now contains code to support animation and sound playback. In some places, additional logic was added since we now have to wait for animations to finish playing back before advancing the state of the catapult. Additionally, the method now utilizes several helper methods, which we will implement.

Note: Take the time to go over the above method as it demonstrates how to take animation times into consideration. This will make the catapult arm stretch further as the user increases the shot power. The above method takes the current aim animation frame, translating it to the corresponding firing animation frame and activating the firing animation.

In this exercise, we will utilize additional Windows Phone capabilities, which will enrich the game with the new features. The most prominent of those capabilities, at least by its name, is the Tombstoning. Those capabilities are redundant when we are writing Windows PC application, but they are critical when we are writing Windows Phone applications.

The reasons for this are the following:. For the same reason we need Choosers and Launchers , to launch another applications from our running application.

Note that our application will not run when another application should start. Moreover, the phone should know that we did not exit our application but just switched to another one and still may come back.

The Choosers and Launchers address all those problems. Though Tombstoning and Isolated storage have similar capabilities, they both can store the game state, we use them in different scenarios. We use Tombstoning to store the state of the game when we launch another application, e. We use Isolated storage to store the state of the game when are going to exit the game, but want to continue next time from the same place.

We exit the game, e. Fortunately, Windows Phone itself recognizes those scenarios and raises appropriate events, which we may handle in our game. In this task, we extend the CatapultGame class with event handlers that save and restore the application state using Tombstoning and Isolated storage capabilities and assign those handlers to the correspondent events raised by the Windows Phone:.

Note the highlighted statements, which were added to use the using Tombstoning and Isolated storage capabilities. This field stores the name of the game state file. Later, we will see how to create this file in the Isolated Storage.

This function assigns state saving and restoring handlers to the appropriate events represented by the application level object PhoneApplicationService. Windows Phone provides this object to its applications and raises events in appropriate conditions. In the event handlers we use functions SaveActiveGameState that saves the application state and ReloadLastGameState that restores the application state.

We pass those functions a Boolean argument that indicates what capability to use: if the argument is true, we use Tombstoning , else, we use Isolation Storage. Score ;. Note that when the application state is reloaded from the Isolated storage , the player is asked if continue the saved game or start the new one. PhoneApp licationService. Parse Microsoft. ToString ;. Note the highlighted statements at the end of the function. Those statements utilize the Tombstoning capabilities to reload the application state, where the first highlighted statement checks if any state data is available.

As we already mentioned, we use Choosers and Launchers to launch another application from our game. The difference between Choosers and Launchers is that Choosers provide results back to the game, while Launchers do not.

The development platform provides a rich collection of Choosers and Launchers that launch standard Windows Phone tasks out-of-the box. PhoneNumberChooserTask launches the standard Phone Book application and returns the selected number back to the game. Note the highlighted statements. Those statements introduce a new menu item, which will launch the Phone Book and send SMS to the chosen number. Just discovered very good game called Catapult Wars. Try it by yourself and see! This is the event handler for the new menu item.

This handler launches the Phone Book application, gets back the chosen number and sends an SMS to this number. Now our game is enriched with tombstoning and state reloading features and allows share its score with a friend via SMS.

Then we enriched the game with tombstoning and state reloading features and, after all added a possibility to share the game score with a friend via SMS. By completing this hands-on lab, you also became familiar with the tools required to create and test a Windows Phone XNA Game Studio game. In this lab, you created a new XNA Game Studio game for Windows Phone application using Microsoft Visual Phone Developer Express, and then used this free tool to create the application logic and the layout of the user interface.

You are commenting using your WordPress. You are commenting using your Google account. You are commenting using your Twitter account. You are commenting using your Facebook account.

Notify me of new comments via email. Notify me of new posts via email. Contents Overview.. Graphics; using Microsoft. Framework; using GameStateManagement;. It contains an upgrades ms skinning model sample. The math library also has many high level functions that are easy to understand such as rotating an object to face another in 2D or 3D, as well as position a 2D object with 3D coordinates, get a selected poly from a mesh, etc. Everything is fairly optimized for XBOX which will be useful for many people.

When I wrote this, I barely understood anything about 3D math and I am still no expert, but the good thing about that is I have encapsulated things so that you don't need to know much to do trivial tasks. When you start off in XNA , your expectations are so high, then you learn that the toolkit is not really going to produce quake 5 even in the hands of Carmack or anyone. XNA is not a game engine, you have to create your own or use another one. Game engines are a bit of a catch 22; If you don't understand how to write one yourself, you will likely get stuck trying to do some trivial task.

You can't even load an animated model currently. With this engine, you have a GameObject and GameObject3D that has a few main things such as Position and Destination , speed and gravity as you would kind of expect. You can use it to produce a 2D image or a 3D object with animation as you would expect XNA to do out of the box.