MyI@FarNiche

Building an XNA Game Studio XBox360 Indie Game.

[page 0000] ~ In The Beginning …

A good Professor once told me, “You will wallow in complexity.” So without further adieu…

From what direction have I come in building a submitable game for the Xbox 360?

I’ve explored the “education catalog” code examples for a year with the XNA-GSE 2.0/3.0 and also delayed my Premium membership of the Creators Club Online for equally as long. With a Premium membership and the Microsoft XNA Premium Content License with the Creators Club Online I’m provided with mini-games, startup tutorials, examples, samples and other code which allow entry points that focus on a well formed, error free Xbox 360 game. With this setup, my game can be built on the computer, then run and played in debug mode through the Xbox 360 console. The Premium sample game templates show how a games class’s code is declared, initialized and referenced, as the game play becomes the result of integrated systems. There are also other stubbed game project solutions that show specifically how a particular aspect of the games code is processed as an expression of that examples singular intended purpose. FYI: As of this writing the Creators Club Online is now APP HUB with XNA-GameStudio 4.0.

It looks like it’s in the code.

So, I’m given sets of function calls, with parameters that are processed by other functions along with their methods, accessors, mutators, etc. That’s all perfect but, I was thinking more in the line of, where does “my” game start. Then, how does my codes logic acknowledge that it’s time to go. What do my function calls need to set its feet off to a runnin’. Do my function parameters need to be filled with anything before it takes off on its little mission. Does it become resident for the games life cycle. Does the function just go away after its done, or does it return something when it arrives at the goal to which it was sent to accomplish. This sounds very obscure and oblique, but it fits the generality I’ve seen as I’ve perused the articles of code given from the C# .net and xna help libraries. As I search to relate chunks of code to one another or in finding relationships that, because of there interconnectivity to provide a desired result, I have found a need for there to be a point where these blocks of codes logic can set there feet against to push off from, from the very start. Some starting chock blocks need to be initialized. Therefore I am given the games “namespace” where, from there, when I begin to set definitions in place, value types can be programmatically accessed from the games Update and Draw methods to produce an intended result which will then become observable as my game. The track that that codes logic could then initialize would then become the domain and range of that game codes life cycle. What happens along the path is that it traces the logical variances within the bounds of the requests constrains.

For the love of fast-track back-tracking.

What’s the difference between starting over and returning to a point where previously presented materials have become familiar. It’s time to move slowly and read out the codes directives and intent. It seems that there is a namespace which represents my game presentation. If I run my game from within there, where it doesn’t crash out as an exception from my namespace, but all the code has acceptable syntax, the value types produce valid results, the logic plays the desired representation correctly, then exits when requested and therefore as expected, without breaking the bounds of my namespace, I then am on the path to building an Indie game. But, while stepping into and through the code in debug mode, there seems to be a lot of hand shaking prior to the “game.Run();” method which performs as the starting point for my games namespace, whether it is in a 2D or a 3D project solution. Seeing I have little heart or desire to drive off topic, I will relegate that to the “using System;” , et al, directive which is included in the code pages header of any Game Studio C# code page and get on with it. There I can obviate the contents of my games namespace as it is wholly open to my interpretation.

Initially, my game doesn’t do anything other than present itself as a top most window on the computer monitor or, if using the XNA Game Studio Connect in the Indie Games folder in the Game Library of the Xbox 360s consoles My Xbox desktop page, on the Xbox 360s screen. whew! My game is connected to a graphics device but nothing has been initialized and therefore nothing can be drawn to the screen other than a default background color. Pressing the ‘Back’ button on the game pad initiates its exit routine. A perfect name for this game would be ‘Hi – Bye’ because there is nothing in between the start and end of this game. Of course there are a lot of smarts that are put to use for this most minimal production to happen. But a person playing this would only see a one button game, and probably find it even remotely inconceivable to ever call it a game. So, from this space and time, it looks like that, my games diversity is homogenous and from all outward appearances, nonexistent. But in between the start and end, is where my game resides, my namespace.

There is diversity out there.

Through the pieces of code that are given to speed me on my way the diversity has become apparent. But what are the base lines that each of the sample project solutions follow to emulate their expression of their own diversity. How does each particular game kick into gear. What are their first steps. When will each of their defining functions be called. Where are their logic limiters placed. How often are any of their blocks of code called and are their values constant or are they perpetually initialized. What is given global existence. What substantiates the logic streams interconnectivity. How does an object lend itself to allow its scope to be accessible to other object types. What are their functions value types. Where are their values origins and what are their meanings. And in the end, what of all of this can be saved as something new and find reuse in the game I’m seeking to create.

A little break.

Seeing what other Indies are building is a good thing. Having a couple of game titles that others have produced for the XBox360 Marketplace Indie game section helps to keep things in perspective. Go, play a few games of the ‘Indie’ type, and you’ll see what I mean.

Breaks over, reviewing the basics.

It’s time to jump back into the thick of things. I thought it best to follow suit and build code modules. Reusability and modularity allows a sheet of code, usually seen as a class, to be added as an existing copy in whole to the project for further integration. Generalizing a template for reuse isn’t easy but it is productive. So with that in mind I will try to pickup where I left off. Some of the problems I had run into in the past has been thinking too fast and thereby running off the edge of the world. Running with concepts and not code bases leads to a very frustrating position but it does promote the realization that consolidating conceptual logic into code modules clarifies the purpose and placement of the code.

What can I do with what I have.

Building a new game from the pieces of old game parts will be my best option. With pieces I have been given and that I have previously manipulated may help me construct this new game. But what should this game do. What do I want to see and what would I like to have happen when this game is played. Seeing that I have some progress under way, I’ll start with the games title so I can stay focused. I can then begin picking out the best concepts of assorted “education catalog” code and place them into class modules, with lots of comments, so when the progression of this game is drawn up the process is understood more quickly and with better clarity.

That Professor wasn’t kidding, complexity, and it was never mentioned that that wasn’t even the half of it.

Oh, and by the way, my games title is “FarNiche”. So, off to the show!

Advertisements

May 26, 2011 - Posted by | 2011 [0000] to [0005], The Process

No comments yet.

Leave a Reply

Please log in using one of these methods to post your comment:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: