Building an XNA Game Studio XBox360 Indie Game.

[page 0005] ~ Enter the Game Pieces:

Instant game, just add play.

Messy me. HUDOn now has incorporated the PerformanceMeasuring sample\example and as it looks, CollisionSample will be the next to find its way into this collection of concepts I am constructing. The FuelCell Example Game in the MSDN Library will be my guide as I push and drag the code toward the first incarnation of actual game play.

The give and take of the Scapes.

As land, air and water, the Scapes possess properties beyond their visual representation. The Scapes have shared boundaries, for example, a minimum Y coordinate to represent the games floor and a maximum Y coordinate to represent the games ceiling. This will keep the game objects from disappearing as they crash to the ground or fly into space. The upper limit will keep the game play connected to the terrain and delineate it from the Spacescape – [Did I just say spacescape? I must be hearing things]. There also are min and max X and Z coordinates that signal to the game objects of their current position, in comparison to the play fields boundaries. Falling off the edge of the world, in a video game, is an actual possibility. In this instance, Columbus was wrong, the world is flat and does have squared edges. But getting back to the waters, its properties slow the ship to a halt if no positive acceleration is provided. The surface of the water also reflects the ocean filled Landscape back to the player when viewed from below the surface and also allows for some representation of what is below the water covered terrain when viewed from above. This allows for some degree of ‘fog of war’ entering into game play. Breaking the waters surface marks another separation from one Scape behavior to another. When moving upward from the water, the Airscape is entered and some behaviors are contoured to affect a more suitable expression, as likewise for entering the water from the air. When moving downward through the air either land or water are encountered. The land adheres to a no zero rule so that no function that observes the collision testing will allow that function to move beyond a zero crossing. Water does not prohibit these zero crossings and is therefore semipermeable, but there is land below the surface of the water which does enforce the prohibition of zero crossings. Moving upward through the air, yes, its true, the Spacescape is found.

End of the Space Shuttle Era.

The Shuttle is dead. Long live the Shuttle. It looks like I have no choice. Microsoft Visual Basic 6.0 became unsupported and then nonsupported. The Space Shuttle has, in part, followed suit. And in comparison, there is a game that has been archived as of this writing, the game SpaceShooter which was written and compiled with Game Studio v3.1 seems to be also passing away. There were functions and methods that must have found better or improved performance and connectivity because the SpaceShooter game does not import correctly using the Conversion Wizard provided by Microsoft XNA Game Studio v4.0. It is still in archive though so I can only believe that my Spacescape will find its origin from there, if I am able to draw out the last of its communicable resources using the 2008 C# Express Edition. The graphics of SpaceShooter are impressive, but as it stands, I will need to completely overhaul the concepts that were used to give the game the same impression as it was originally experienced. One nice thing about SpaceShooter is that it uses ChaseCamera as one of its classes. It also incorporated the “using Microsoft.Xna.Framework.Content.Pipeline.Processors;” to preprocess game assets which I have become acquainted with and have recently learned about from the GeneratedGeometrySample from the Collision Series in the APP HUB education catalog. My best bet, and only bet, is that I start a new project solution and name it SpaceShuttle, if that name hasn’t been already taken. Then starting with “SpaceShooterGame.cs” of the GS 3.1 version, copy the entire sheet of code from there into a blank .cs sheet in GS 4.0 to my SpaceShuttle game. From there the missing and unknown Keywords will become apparent as errors, warnings and messages. These should provide to me enough guidance so I can slowly recreate what will hopefully become a process that will culminate into a working version of SpaceShooter in GS 4.0.

And so Spock looks at Bones, then slowly speaks, “If he has the time.”

I learned how to juggle a long time ago. You toss one thing into the air to give it some hang time, flip another thing from one hand to the other then catch the hang time toss. Repeat as necessary. Same thing here. Incorporate the CollisionSample into HUDOn, rebuild SpaceShooter from v3.1 to become SpaceShuttle in v4.0 and practice some old licks that I have had a better grasp on in the past so my silent Vlog entries will have some music in them. Ten to one I’ll get sidetracked with some other aspect or process in this game creation journey. So its not, all bets off, but the good money will definitely be on that I’ll learn how this works and eventually have a playable Indie game.


July 22, 2011 Posted by | 2011 [0000] to [0005], The Process | Leave a comment

[page 0004] ~ Me, and my, segue:

Stay the Segue. (And Happy Last NASA Space Shuttle Launch, about 3 or 4 hours ago.)

Opening the PerformanceMeasuring example solution I find that there are a lot of new concepts that are used to make this game go. The GameDebugTools folder in the game solution looks to be the most daunting. But all in all, fitting this sample game into the mutated ChaseCamera/TankOnAHeightMap, i.e. HUD On, looks very doable, maybe.

Famous last words.

“Never break a build.” Hopefully, blending the PerformanceMeasuring sample and my HUDOn game will not produce such results. Everything is in and all the gauges, meters and text interfaces are present and visible. Everything is there, the meters and text displays perform as in the original sample game except that I can’t see the spheres, and also my terrain scale eludes me. I built this game for the look of the landscape and as its flown over when flying in a ship. But it seems the lesson here is that I need to find the spheres and have them match up with the scale and dimensions used for the terrain in the game.

It’s not broken, its just hiding.

Here, sphere, sphere, sphere. What do spheres like to eat? Dog biscuits? Cat nip? Fish food? Where O where have my little spheres gone? Oh where oh where can they be? Hmmm.

I have found my spheres, and I can still throw an OUT OF MEMORY error, to boot. I didn’t have my view and projection arguments in sync with the graphics device that my other draw methods were using. It seems that everybody needs to be hooked up through the same ChaseCamera class instance. So be it.

OK, that’s pretty cool. I have an invisible box that contains a bunch of spheres that float around above my terrain and in which my ship can fly through. They collide with the invisible box walls and so are all contained to a certain area. The land, water, air, ship, and sphere box are centered on a point where X and Z are both zero, the true world origin, I assume, and of course, an apparent Y coordinate some distance above the terrain.

Why is Y a negative?

Segue the segue. It is truly a cryin’ shame that resurrecting the Spaceshooter (ARCHIVED) into GS4.0 might be really difficult, but worth it. Alrighty then, back to HeightMapInfoContentTank.cs and TerrainProcessorTank.cs. These should probably come from some mutated version of that Collision Series, yes Collision Series 5: Heightmap Collision with Normals. I think I changed some of the processor description from there and incorporated some of Collision Series 4: Collision with a Heightmap. I also added a Boolean property for two different versions to be built where either setting would change the triangle mesh of the terrain design. I may need to run through the process of terrain creation and game import before its forgotten, again. That’s about it, now where was I. The Y coordinate comes from a gray scale bitmap with what seems to be built maximized for import at a 512 Width and Height. Black is the lowest point for the mesh and White the highest point of the mesh. 0.0f and 1.0f are the min and max, and then there is the bumpiness factor. There needs to be some point in that range where the spheres are located. I need a Vector3 where X and Z are at zero and Y is a percentage of a point in the range of the given height field, eventually found in Ship.cs which comes from the new and overloaded Update method using heightMapInfo.

If Y isn’t a zero than what is it?

Its assignment in the Vector3, and thus probably, or more than likely, precludes it from being aligned in/as the true world origin. So what is this right hand rule that produces coordinate shift here, (+)X == Right, (+)Y == Up, (+)Z == [the space between the viewport and the viewer, moving from the screen to the viewer]. So at some point Y > 0 OR Y < 0 OR Y == 0, but which would be considered true world origin if and only if the origin is:
Vector3 XYZ = new Vector3.Zero();

July 11, 2011 Posted by | 2011 [0000] to [0005], The Process | Leave a comment

[page 0003] ~ Setbacks and the Long-Run:

Simplistic perfection first, we’re all in time but never the same time.

Once again theory and substance collide and it looks like I’m running straight back into the chicken and the egg dilemma. Having a question of how extensible do I need these classes to be, and at what point does it slow down the progression of concept realization and then integration, leads me to one conclusion. I think there was a motto or some such that went, “It Works”, and for some odd reason, I think it had something to do with UNIX, so I might as well just run with it. Its like what my Dad told me once upon a time, “Build it first, then worry about it.”

And what does this have to do with the game pad and the HUD?

I’ve changed the configuration of what was GameOn in the new version HUDOn. There are now four equally sized viewports along the bottom edge of the game screen and one large viewport across the top. The height of the four smaller viewports take up about one fourth to one third of the Title-Safe-Area along the bottom edge of the screen . I’m thinking that this should provide enough screen real-estate for each of the four players and the space assigned for their game pad controller interfaces, as this seems to be turning into a one console one thru four player game.

Me, and my, shaaa doe…, no not shadow, faulty logic.

I’ve taken the SplitScreen sample and have built the above mentioned game screen to match the dimensions of the slicing and dicing design. Now I remember. Each of the smaller screens is where any one of the four players will end up contouring their version of the game play as the game evolves through its progression. Previously, I’ve made some GameComponents that acknowledge that a game pad has been connected and also allows the connection of the controller after a disconnect, to be reinstantiated for continued game play. Admittedly, I can just walk away from the game, only to return later on and find the state of the game looking for any of my connected controllers. Ee-yah, life happens. But, I need some way of reintegrating disconnected controllers back into the game, either from a paused game state or possibly a hot connect as the running game would take the stance of, ‘You snooze you loose’, or ‘I’ll run your player in AI mode until you reconnect’. In any case, a game pad needs to be connected to a player in the game and also have the capability to acknowledge that it has become inactive and reactivated through-out the life cycle of the game. And so I have a class which I had previously written in Game Studio 3.1. Dropping that PadJoin v3.1 class into HUDOn v4.0 game should work, but as for the egg and the chicken, who owns whom? The player plays the game. The player has a game pad. The player looks at the screen and would like to know which of the four bottom rectangles are linked to the pad that the player is holding. Through the game on the screen, each of the four rectangular pad interfaces are the connection ports for the players of the game. So each game pad needs to reveal the actions performed on the pad in a specific rectangle owned by the player. Wow, more things to build and reconfigure.

“And so It begins … “

Naming conventions aren’t always snap decisions. In the past, while working with MS Visual Basic 6.0, I had become accustomed to Hungarian notation to name variables and the like in the small applications and games I had written. With the new Game Studio 4.0, (with windows phone stuff included with the app), the need for that has become prehistoric in that, when the mouse cursor is hovered over the code in GS 4.0, a popup window will appear explaining what type, its usage, any overloads to the function, and a comment or so, to minimize the need to fully investigate its purpose. Given this extended simplicity, the names can be declared as what a variable, function, object or class is in respect to the game itself, rather than for what it does systemically or how it does it programmatically.

The Scenario.

All games on the XBox 360 start from the consoles game library. The game is loaded, then waits for a player to accept by pressing the ‘start’ button on the game pad. That player becomes the host of the game…

OK, party’s over. Über segue.

I just found an example called PerformanceMeasuring and if I don’t try to muck-up my HUDOn code with this example it just wouldn’t be like me. Yes, setbacks and the long-run. What makes me think that this is a good idea is that the landscape in this example is the same landscape in the ChaseCamera sample. And I kinda feel like seeing if I can add any physics to those spheres as they collide with one another. I gota play too, ya know.

July 8, 2011 Posted by | 2011 [0000] to [0005], The Process | Leave a comment

[page 0002] ~ Constructural Analysis:

The Vlog has its first entry, FarNiche_0000_TheScapesTour.

So far so good. It’s a big environment out there, lots to see and much to do. If you stay in one spot and don’t move, the world actually can revolve around you. And now for the treachery. How can it be, that the view of the world is from a point where the center of its revolutions are not formed from the center of the object in focus, or is it all ‘ceteris paribus’. It seems that, as the game cameras viewing frustum is what is portrayed on the screen, there is a need for an attended focus. The large picture is that the terrain map has some sort of resolution. It’s a boundary and a place setting for the playable objects in the game. So, in keeping with the idea that a ship is being flown about the terrain, it is of more concern that its flight is recognizable as a ship that can fly through air and water, while still observing the terrains restrictions. Also, having the ship fly away and out of the understood center of focus, would leave the pilot to find another way, if possible, to correctly navigate the ship.

So it looks like this game so far is about flying a ship through the Scapes.

If a ship crashes, its not flying. If a ship is not understood as being piloted, the general assertion is that the control of a ships actions are either no longer accessible or somehow now limited. If there is no discernable response to a derived and deduced action, the conclusion is, the lack of correlated responce expressed has been created by some degree of erroneous reasoning. Something between the game pad and the screen has produced a conceivably conflicted behavior. As a result, the assumption, would be noticed in that the ships controllable existence has ceased to portray a cohiesive bond to a desired affect. So the controls of the ship need to reveal changes as subjectively observable reactions occurring through the game screen. At this point in time a minimal HUD is the only analog reference for the game pads interface and for what is going on under the hood as it relates to the movement of the ship while it moves through the Scapes. The terrain map can be seen as a terrestrial environment moving closer or further from what is recognized as a potentially hazardous position in relation to the ships well being. The HUD can give numeric, graphic and texted clues as to how close to sea level the ship is, and the altitude above the absolute floor of the terrains model mesh, that is, hard ground, which is above where all game play will ensue.

Belaboring thus far. Refining the obvious.

The ships viability is wrested from the game pad and affirmed from the game screen. Seeing that the two entities up to this point consist of the players ship and the NPC (non-player character) terrain, the understandable inbetweenness of both the ship and the scapes will require an improved HUD. The ship would do well if its responsiveness could be better observed and contoured through a tweakable interface, i.e. the HUD.

HUD and HUD what is HUD? (Heads Up Display).

There are a lot of golden nuggets in the “education catalog” apart from what the samples title might suggest. Small graphical bar-meter utilities are used to show what portions of Distance, Angle and Time are applied in the FuzzyLogic example in the AI section. These I’ve changed and used for the Altitude and Sea Level meters. I have found how to draw a 2D Texture over a portion of the game screen, and so in my game, over the 3D terrain in which I have built so far. This I found in CardsStarterKit, a black jack card game example. SpriteBatch and SpriteFont are found in most, if not nearly all, of the examples and can be used to textually display the property information of a given Matrix, Vector3, float or whatever mystery that is encountered. Unblack-boxing the sample code in this way has provided to me a means to encorporate these techniques into my own game. And therein lies my HUD, made of bits and pieces that allow the game to become a more coordinated flow of quickly accessable pertinent information.

Information – The Elixir of Life, or at least a better chance of continued survival.

I’m having trouble with my newly added mini-map. I can zoom in and out, but there is no correlation between where the ship is in the 3D world map when compared to the image of the 2D mini-map. I have made a function that moves the view about the 2D image, but its logic is faulty. Some things I should line up are the forward vectors. There initial settings should face in the same direction to cut down on the guess work.

Well, so much for the treachery.

What I need for this mini-map is that the 2D image center is positioned at the point of the ships current position on the 3D map. That the scale from the large 3D map and the 2D mini-map have a consistent ratio as the scale of view changes. A new function that will take that ratio, and because of the new position of the ship, will realign the center of the mini-map to the new position of the ship.

To coordinate the changes in scale and position I need to use the TimeSpan object because running the changes primarily dependent on the game Update method uses a looping construct that is much more inconsistent than the system clock. Yeah, treachery, I guess its something like what I was expecting.

Getting on with it.

GameOn is the first integrated system and prototype of FarNiche the game. The next is called, for lack of a too much over-thought name, HUDOn. It will take most of what is in GameOn, only that it will clean out the commented out trial and error code and get some pseudo-logical reconstruction. A general tidying is in order, so instead of a purely manufactured mile stone project for its own set aside purpose, a new and clean GUID solution built to hit the ground running will need to do. This next step might as well be a working mile stone solution. It should consist of building a HUD that is a blend of: seeing the ship fly, coupling the surrounding 2D terrain map to the ships position in the 3D environment, giving it some vector icons to show its direction and velocity, improving the Land and Sea Level meters and inserting the capability of contouring the sensitivity of the flying controls. All of this, while trying to consolidate the above information into a space so this can be run by four players with controllers that are connected to the same XBox360 console. Hopefully I can cut through most of this in a month and make it ready for the Vlog. Until then…

July 1, 2011 Posted by | 2011 [0000] to [0005], The Process | Leave a comment

[page 0001] ~ A Propensity For Desire:

What then, is this niche?

Somewhere I’ve heard an expression that, “Nature abhors a vacuum.” So, where there is space to be had, nature will more than likely act to fill that space and take that opportunity while it exists, . Therein lies the dichotomy. To build this niche it needs to exist as a niche. And a niche isn’t a niche if nothing comes along to reside because it is not desired as a niche. My best bet again will be to take what I know and apply what I’ve been given. Nearly all of what I may desire to incorporate into this game will then come from what I can relate to here and now. My big picture consists of land, air and water. Everything that I’ve come to know and love is pretty much bound to a combination of these three places, call it a world that holds the environment. I’ll need to go out on a limb here and press a surmiseation, “Life desires a niche.”

The nature of nature.

Well, it looks as if this game is going to incorporate life, and its aspects in an environment that contains land, water and air. From the outside looking in, in this world, gravity rules supreme. If I jump up I am pulled back down. If I throw a penny into the fountain my hand and arm get wet when I try to get my penny back. Birds can glide and propel themselves through the air for hours at a time but eventually they will land. And that is the key word, Land. On dry ground my homeostatic relationship with the land is that I don’t fall through it, and the land is lenient enough in that I am not crushingly pulled into it. The same is true in the water, save for the fact my lungs are far from attuned to functioning correctly where the bottom of the water meets the top of the land. I fall through the water but not the land at the bottom. I guess the same can be said about the air. I fall through the air but not the land at the bottom. And just to get fancy, I can fall through the air above the water, then through the water but not the land at the bottom. Simple, it all makes sense now.

Just to clear things up a little, what I need so as to provide a niche, is a Landscape, Waterscape and an Airscape. This sounds familiar. It sounds like this is the lead in to behaviors. But, forgoing all else, nothing will have consistent behavior without the ‘scapes’, I didn’t mention Spacescape. [ ( note to self ) – Stop running off the edge of the world!! ]

How can the “education catalog” help me define this niche.

Now that I’m done with my hands and arms flailing about, along with my willy-nilly brain dance, I can get back on topic and a little more technical. I’ve gone over the sections in the “education catalog” many times and have begun to notice possibilities because of the bread crumb trails that have been left throughout the code. Many of the variable names are preserved from solution to solution. The sample game projects are opened and after a somewhat thorough gleaning, I’ve noticed how coherency is promoted as the various solutions explain their title and description. Nearly all of the solutions are succinct. They say this is the concept. Open the project, run it, see how it works, step through the code, watch how objects are loaded, initialized, and utilized, how the variables values change, how loops perform, and on and on and on. The real beauty of it is that it’s given up for interpretation to be understood and incorporated into my namespace and therefore into my game. Cool, very cool. Ah, but alas and alack I have not weather in my game – em hem ( note to self, again ).

It looks like land is the order of the day.

Seeing that this will be a 3D game, with a smattering of 2D Heads-Up-Display interfaces, I need to recreate an expression that when seen will present itself as a recognizable environment. What then is provided because of this terrain? This terrain can then become the homeostatic range and domain of observable game play and as what is experienced as the niches cause. The land slopes upward and downward at differing degrees and angles from a seemingly endless array of points of view and perspectives. In always looking for a starting point, I notice that the antithesis of up is experienced as gravities insatiable desire to draw me through its terrain because of its great mass. No matter what the degree of any angle, my up orientation is always effected by a force which comes through what I understand as gravity. Therefore, the effect of a terrain can be observed as two simple elements, a mostly non-semipermeable membrane, and a force which will draw an object towards that membranes surface as a tangent of that membrane as a whole. That being said, the capacity to place and orient what will reside in this games niches, and then their limits which encompass them as they rise and fall from existance in the game, because of the terrains two underlying elements, will form the grid and glue as the base line force of attraction and settlement.

Into the dark throws where roiling conceptual matter meets the compiler.

For me, I need to integrate a couple of the “education catalog” samples to derive a suitable environment for my games liveliness to occur. The GeneratedGeometrySample, HeightmapCollisionSample, TankOnAHightMapSample, all from the Collision Series, SpaceWar and the ChaseCamera sample originate from APP HUB. There is another called FuelCell_Example_Game which is buried somewhere in the MSDN library. Bringing these samples together has given provisional insight as helpful How To’s. With a lot of inference, sledge hammer and tweezers manipulation, I have exuded a congealed representation of an environment.

Remiss in synapse.

I have come to the point in this creative endeavor where it becomes a necessity to build a web site; i.e. In addition I’ve appended a WordPress – Blog and a UTube – Vlog. I have spent some effort expanding this blog, so now I must revisit my C# code. In building my code creation as a milestone project solution, the progress of processes up to this point will become the first of a series of save points and static backups. Excerpts from these milestones debug runs also need to be captured as an observable score of frames from my games point in time for the vlog. To express what graphic processes are becoming game worthy thus far seems to be the next logical step for this chronicle.

June 5, 2011 Posted by | 2011 [0000] to [0005], The Process | Leave a comment

[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!

May 26, 2011 Posted by | 2011 [0000] to [0005], The Process | Leave a comment