Building an XNA Game Studio XBox360 Indie Game.

[page 0018] ~ One Game A Month Challenge:

The first ten seconds aren’t the count-down, “find the fun”, and we have lift-off.

First of all, I’ll need to give credit where credit is due.  While trying to explain to myself and within my blog, about my gaming horizons from reading assorted game related books on Safari Online Books, I typed a search of the phrase “indie game development” and ran across a title named “The Game Jam Survival Guide”.  I read the overview, once I started I read it straight through to the end.  I clicked on a couple of the links that were given within the book and somehow stumbled across One Game A Month.  I had just started to use Twitter, @Far_Niche, so after more selective reading to figure out how to send them the tweet, have the tweet also sent back to me, and how/why to apply a hash tag (#1GAM) so they knew I knew that I knew that they knew I sent them a tweet, I then was able to sign up @OneGameAMonth.  That was a tidy bit of ehand-shaking.  So now I’m on the wall of those who will embark on that “IronMan” of video games competition.  This challenge is built around the premise that it is possible to build twelve completed games in a year, one for each month.  Apparently, this has been done.  I have barely an idea of what to expect, but days before the start, January 1st 2013, there are well over one-thousand two-hundred entrants.  This seems to be becoming epic . . . Good for them, lucky for me.

Just what the doctor ordered.

Days ago I had no idea what the next year would bring.  My blog entries were filled with what I was trying to accomplish, in a very disparate fashion.  The parts could fit together, but there was no drive, competition, challenge to press the need that when fitted together a game would result.  But then, because of the directives on the One Game A Month site, the next thing to happen was to sign up on, as FarNiche, where the OneGameAMonth has its message board.  While reading through what others in this challenge are finding of importance, a reference to CodePlex and GitHub were mentioned and again I registered/signed-up, as FarNiche, of course.  And so, as of late I have been reading through codes of conduct, terms of use and other agreements just to figure out how this works, not alone how it all fits together; so in short, how to work and play well with others.  Then, it would seem that, App Hub has split its resources to become focused either on Windows phone or the Xbox 360.  Their are two portals on the main page, which are now “Windows Phone Dev Center” with the other “Xbox Live indie games”; ok, whatever.

The year in review.

The last thing I would like to accomplish this year is to make a vlog of Prototype 2012, so I can take a look at what I had accomplished for the year.  Then I’ll need a licensed Fraps so the milestone movies are more discernable in picture clarity, having also a longer run time with a better frame rate.  Before the year comes to a close, I would like to go through the routine once of vlogging an overview of the running game in action, flowcharting the build process documentation, blogging my general trains of thought about it as I build it, and finally share the code somehow somewhere so the chain-o-love rules supreme.  This has started as my short video of OGAM SpaceWar DryRun 2012.  It is my accomplishment/contribution thus far to prime the pump for next years challenge.  As a side note, while my SpaceWar to SpaceWar II conversion progressed, the ship-shield graphic and numeric interfaces along with the collision-detection logic has made my Xbox 360 thick as a brick, but it really rocks, actually asteroids, on the PC.

So, until next year.

G’day, and Happy Piktun #II.

December 31, 2012 Posted by | 2012 [0006] to [0018], The Process | Leave a comment

[page 0017] ~ XMLSpy and the Dragon … et al. :

The Extro-Intro.

It has come to my attention that these monthly synopsis are starting to congeal into their own form.  Most notably is this first paragraph.  So I’ll just run with it and say that this introduction paragraph is set aside to tie the previous post [extro] into this new post [intro].  It sets the tone for what was and then what has come up next.  Recently, this has been my way of letting go of those proverbial reigns, and to then sit back and watch it become what it will.  So far, I see this hobby hobbling along without any real direction, presumably on some kind of brain-storming autopilot.  I guess I need to build an infrastructure so, when I do accomplish something, I’ll have an idea of what and when it has become part of my recollection, within a toolkit.  Self management has become an apparent issue because the desire of an endgame.  The capability to press start on the XBox 360 game pad and play a game of my own creation is the only real endgame I have had in mind.  In between is just a whole lot of, that’s cool, it worked, wow, with even more consternation and hmmm’s dispersed throughout the entire process.  It’s a great way to start out when looking for what’s out there and what can work together with what else.  But when it comes down to saying, OK, I’ve built such and such and it works when I do so and so, and then a few months later, after I had completely forgotten that that had been built at all, and then I can only say, wow, I built that, well, hmmm, again.  So up to this point, there hasn’t been a real way of tracking how it worked when tried with something else, or how it worked, or didn’t work.

Tools of the Trade.

What do I know about building?  Going to a technical school to learn about carpentry and then getting the tools together to construct a house, put on an addition, refurbish a bathroom or add a second story is something that I have already done.  Going to the university to learn about programming and business has also been a side line during that time.  Actually, it started before that time line and has now lead through and into App Hub and Indie games for the Xbox 360.  Both involve a multitude of processes.  So what do they have in common?  You don’t just wake up one day and say, yep, I’m goin’ to build a house today.  The same can be said about building a video game.  So how and where does it all start.  Back in junior high school I took drafting and learned how to draw orthographic views of various items like chairs, desks and mechanical fasteners, i.e. nuts and bolts.  In high school I took a basic programming course and learned about the protocol of software design and how flowcharting becomes an essential part of that process.  Those two courses allowed me to work on a drafting board and a computer and gave me the chance to look at something and then see how that could become something different.  At the technical college I used my previously learned drafting skill, and blended it with another course for residential and commercial blueprint reading.  My software design and flowcharting skills helped out at the university when taking C++ data structure courses and economics.  Now lately, after doing some reading it seems that all of those skills have the potential to transform into something others have called the Game Design Document.  And this document sounds like what I’ll be needing to track my progress as I consolidate my resources so I’ll be able to revisit what I’ve done, and then to become able to grasp what I have previously understood, with a consistent train of thought.  Actually the game design document – “GDD” is to be drafted beforehand and not to be a freeform trace of what capabilities I have a grasp on.  So with that in mind …

Back in the Day.

Having the need for a GDD, I’ve dug up some old programs.  Dragon Naturally Speaking, circa 1999, is an oldie but goody.  The general premise is that I talk and it writes what I have spoken to the screen.  But this Dragon first needs to be trained to understand the way I speak, so I have been feeding and training it with my previously written blog posts.  Giving it the documents in whole, so it can build a dictionary of the words I use, and then reading those same blog posts back, such as this, so I can proof read and append corrections within it when it prints something that sounds like the words I’ve spoken, but are not, is how it learns.  When speaking, I liken it to something my dad had shown to me some time ago, Victor Borge and his “Phonetic Punctuation” routine.  Here, Victor would tell a story.  But for the punctuation which he would also pronounce as the story went along, where differing sounds were consistently dedicated to each period, comma, exclamation point or otherwise silent syntactic symbol.  The same is true for dictating to Dragon.  It takes a little thought at first, and then some reciprocating references to the help file to know what it is capable of and how to verbally produce the intended edit.  It seems a little clumsy, possibly silly, actually saying comma, period, open quote, close quote, new paragraph, select that, read that, but it works.  It works well enough to use it to journal what I’m doing as I think of where I should be going with what I’m doing.  It lets me keep my hands on the keyboard and the mouse while it does its own thing, that being, keeping track of the bread crumb trail from what it is that I say.  OK, I’ll say it again, cool.  Then there is Microsoft Office 97 and Project 98, which, some time ago I had upgraded to 2000, probably because of the Y2K scare, but not necessarily.  Along with those Office 2000 products I have also found my 2000 version of Visio.  But most notably, though, of those is Visio which has tools for flowcharting.  Having a way to schematically diagram the high and low level paths and processes of a program should delude the abstractions I’ve found so cumbersome.  This should give me a way to map my own help files to concepts I’ve created which are briefly comprehended, but become so quickly fleeting as other tasks take precedence. The other office products should help with the construction of a respectable GDD and its presentation.  Word, a place to paste my Dragon journals, and the many other textual ideas that are perpetually revealed.  Excel, to test numeric prototypes from zero sum game theories to like typed statistical scenarios.  Access, to allow for labeled input interfaces which provide search and tracking of game asset names, their properties and related quantities inside a database.  PowerPoint, to use as a scrapbook to bind it all together as a fluid presentation.  Project 2000 is something that, for me, makes no real sense.  I would love to keep track and keep a schedule of what I’m doing, but, ok, alright, maybe I’ll try to drop something in between those lines, just to see if it does something I can understand, but no guarantees, or maybe I’ll just use its calendar.  To move on, within these applications I should be able to build a consolidated GDD.  Another application is XMLSpy 2004 which should help out with some of the web pages in my site, and to also use it for the Role Playing Game from the education catalog in App Hub.  This game utilizes xml files extensively to store and load data into the game.  The Content folder is filled with these files.  And so, if I am to build a game document design, I might as well build one for this education catalog sample game first.  This way, I know the story line and it should be easier to dredge out a format from what is apparent.  Lastly, there is my ancient version of TextAloud from back in the day when SMS was the newest big thing, and with Safari Books Online, when the book is HTML enabled, power reading becomes the mode of choice : see Review.

“Games Without Frontiers” – Peter Gabriel.

So it looks like I need to figure out what a GDD is, and how to piece it together using the tools that I’ve got.  This isn’t quite a proper programming venue but it still inspires intrigue.  And from all accounts, has seemed to be deemed indispensable.

It’s still good!  As seen from a can of bacon grease sitting in the middle of a smoldering campfire.


December 18, 2012 Posted by | 2012 [0006] to [0018], The Process | Leave a comment

[page 0016] ~ Autodesk Softimage and digital-tutors:


The king ain’t dead.  Some secret atlas rocket mission with a space plane cargo (USAF X-37B) space plane launched to do something, yea, we’ve still got vigilance.  And back in October the not so secret SpaceX Dragon has started its active apprenticeship, no pun intended.  Now, back to our scheduled program, another non-pun intended.

Class Reprise.

An old game, back when I thought I was going to build milestone solutions, has surfaced.  Its name is CameraViewports and it doesn’t quite match up with what was built in HUD On.  It seems that its aim was to facilitate the addition of multiple viewports into games which I am planning to build.  It has two major classes, a model, about two hundred lines of code and a camera, about six hundred lines, which define the assets in those classes.  They are looking very generic but are well formed in respects to the declaration and method structures, simple with concisely defined  summaries and comments.  It seems here, that the idea ‘was’ to build a clean milestone solution.  Eh, good for me.  But . . .

The Actual Issue is.

For the last month, because of a thirty-day trial offering, I’ve been working through the latest version of Autodesk Softimage, version 2013.  Also, I thought it would be helpful to get a thirty-day subscription to digital-tutors.  This combination has proven very intriguing and insightful, and has turned out to be something like doing math homework when it is the only class that is scheduled on the dance card.  The path I followed was that of biped character rigging and enveloping with an overview of animation in Softimage and a gleaning over how a dinosaur and a dragon are modeled in ZBrush.  Having worked in Softimage MOD Tool 7.5, a free for non-commercial use predecessor package of the 2013 model, I found that the similarity has been retained, but that the improvements made to the 2013 version are very substantial, from a users point of view.

It’s not GoZ, yes it is.

Sculptris, sounds like it’s promoted as that of a free offering likened to that of Mod Tool, but with different restrictions of usage.  It has a feature called “GoZ”, pronounced Go-zee, that allows the transfer of mesh assets back and forth from Sculptris to ZBrush.  Also, I found this out too late to test it out, GoZ has an add-on for Softimage, which I was unable to test out, just didn’t see it, I wasn’t thinking, too busy to realize it, just missed it, darn, there’s always next year, guess I’ll have to read about it, whatever.

“No Reason To Cry” – Eric Clapton.

Not to dwell on and on, there is an addition in v.2013 that aligns the model mesh with cardinal and intercardinal directions, in respect to a cube, of course, that snap the mesh to an orthographic Front, Back, Top, Bottom, Left, Right, then the edges and corners view of the the mesh because of the cubes snap-to alignment.  This simplifies things like visually assuring that bones realign and have fallen back into their previous placement after a quick IK/FK quality assurance test and therefore a couple of undo’s.  Yes, loth to dwell, but wisdom comes from the remembering.

The Meat and Bones.

So, using Softimage 2013 while scrying the possibilities from the digital-tutors site, I concluded that creating animated mesh actors for video games seems like a real possibility.  First, a mesh is selected or created in ZBrush.  From there, back in Softimage, the bones are set to lie within that imported mesh character, likened to the bones of a skeleton within the skin of any flesh and blood biped actor.  Then there are primary and secondary controls that are used to manipulate those bones.  FK ( forward kinetics ) and IK ( inverse kinetics ) chains are ordered and formulated so Parenting and Constraints of the bones can be added to insure proper motion when the bones are manipulated.  The bone structure is then Enveloped.  This surrounds the bones with the mesh using weights on the vertices of the mesh to hold their proximity about the bone, thereby affording deformations to the mesh as the mesh follows the bone chains when manipulated.  Finally, Keys are used to set the mesh and bones model in place on a timeline.  These produce posable animation sequences of the character, actor, hero, and the timeline animations are used to produce clips that are further manipulated within the Animation Mixer.  Then, supposedly, an FBX file can be exported where it its then imported into the game solution via the C# XNA Content Pipeline.  From there, as a model asset, the camera asset is able to reproduce the actor in the game environment, hopefully with clip animation, inside a Windows and Xbox360 solution, as in my game in my namespace.  Easy Pease, whatever that means.

“The Road Goes Ever On”, Bilbo Baggins.

The only solace I can fathom, at this point, is that the Skinned Model Extensions Tutorial from the APP HUB education catalog loads and is playable on the Xbox 360 console.  So something of this nature is possible to create, and the initial path for doing so has been prepared.  Hmmm, I never got the chance to . . . No glomming!  So anyway, in the Skinned Model Extensions Tutorial there is an .fbx file named dude.  And the dude has an animation clip that represents a walk cycle that will run in Mod Tool, actually walks, the walk runs, in the timeline,  in Mod Tool, on the screen, yep.  That FBX file is a Crosswalk Import so I may need to build any and all animatable assets that I would like to be animated in my games as an fbx file, just to follow suit and produce the same effect.

And so, like my old Master Carpenter would tell me as his Apprentice, “It doesn’t get done by just lookin’ at it.”  So this is what’s going to happen.  Ta-da!

Until I’m sidetracked again, in about a month.


December 12, 2012 Posted by | 2012 [0006] to [0018], The Process | Leave a comment

[page 0015] ~ Genre versus Motif:

But first an adjunct.

Back when video games used two-dimensional squares to build a flat top-down game picturing an obstacle course terrain along with two tanks, the general idea was, mostly, to just shoot the other players tank. One hit, that’s it. These tanks had the same look for either player, the opposing tank looked like my tank except that it was grey instead of white or black, or by some strange twist of fate one could be green and the other red. Back then, I found that that game was enjoyable to play. Maybe overly simple, but still simply enjoyable. This brought to mind what my next mix of game/sample solution could be. As this supra-hobby progresses, some game solutions have been making reappearances because of newly prompted objectives. By rereading my past blog pages, building another game version should again begin with what pieces were used from which ever games fit together well previously.

And the solution is, InOutPad.

Yet another game solution to derive from and continue building on the existing solution CameraAI, with of course, a revised set of directives. This time around, I’m looking at getting the, GSM, being the GameStateManagement sample, solution into InOutPad. Having given this some thought, I can liken GSM as to a beef bullion cube dissolved in boiled water, its not tea and its not soup, although it goes well with a Ry-Krisp, probably because that cracker has so little salt. GSM has a slight flavor to it but it would be put to better use as a base to hold the next ingredients. So what are these next ingredients? What flavor of game should InOutPad become? What is the definition for its genre and motif?

Mixing in Education Catalog Samples.

A game sample that became a phase through the build up of HUD On is TankOnAHeightmap. In the TankOnAHeightmap sample, I changed the terrain by adding it as a new set of bitmaps, one grey scale and the other as a color texture, both are built in and exported from inside GeoControl2. In TankOnAHeightMap the grey scale bitmap is run through the TerrainProcessor.cs of the solution Pipeline during compile time. This is what builds the scale and contour of the terrain mesh. Then, during this same compile time construction process, the Material/Texture color is applied from the other bitmap containing RGB (Red, Green, Blue) data. Within the mesh object created as part of the prebuild process used during this terrain texturing, I incorporated another property under TerrainProcessor that gives access to the height, or lack there of, within this mesh processor. The Content Processor Pipeline project within the solution then adds this TerrainProcessor attribute as a new drop-down item to the list in the C# IDE, so giving color to the mesh, changing its scale and the height of its sea level is substantially simplified. This is one part of this new game, a terrain with a tank that follows the terrains surface height.
The next game to be blended in, giving InOutPad more texture and flavor, is FuelCell. Having a terrain from TankOnAHeightmap, the next order is to coordinate the collision aspects from FuelCell. Giving this games Avatar a different look from what it was originally in FuelCell, thereby having it changed into the tank from the TankOnAHeightmap sample will change the games direction for its win conditions. The challenge here is that another tank/avatar will be added to the mix making it a two player game. This is more than likely why I made HUD On with a main background viewport with two in-screen viewports, one for either player. Having two tanks on the terrain along with the fuel cells will allow for some type of strategy to be incorporated. In FuelCell the cylinder, cube and pyramid are used only as obstacles on a flat 2D grid. Changing these objects into something more advantageous by giving them differing properties will add to the strategy within this new game where their use goes from collision obstacle to collision trigger.
Finally, FuzzyLogic, another sample to find its way into this game, is a top-down view Artificial Intelligence driven game. Here, the only controls used to manipulate the characters within this game are the pads connection to the on screen slider bars. The ratio between this games HUD slider bar sizes give the tank, which truly resembles a top-down picture of the tank from TankOnAHeightmap, three types of behaviors which can be set to varying degrees to modify how the tank responds to its proximity to the mice. The mice also derive their movement from AI modifiers because of there proximity to the tank. So from here I can change this set of mice from FuzzyLogic to become the fuel cells in FuelCell. Giving these new and improved fuel cells some animated behaviors, by changing their mesh’s from a rigid body spool shape to a skinned model biped, should add dynamics vetted from the Skinned Model Extensions Tutorial.

Mixed Up Mix.

It sounds like all this can become a workable game, but I still don’t know what the victory conditions are or could be. Even still, the main purpose of all this mental gymnastics is to build reusable code that will make building other games an even more simplified process. And this, in turn, will allow for the incorporation of yet unstudied samples the time to become applied within upcoming games, things like HLSL, normal and bump maps and post processing.

One More for the Web.

I now have a Twitter account @Far_Niche, with one tweet, my first tweet, t-wee-t.

That is all for now, G’day.

November 29, 2012 Posted by | 2012 [0006] to [0018], The Process | Leave a comment

[page 0014] ~ Class Resolution:

Using application entry and run point interfaces.

My namespace MyI is my interface for MyInterface. FarNiche has no cognizes of things done before its namespaces ‘using’ statements, save that they are observed through seemingly vestiged ideals. And yet they retain need as required References which provide connections umbilically, through the use of interfaces. Now, my Game1 solution in the namespace CameraAI is on one side of a pinch point while the IDE, integrated development environment, is on the other. The production of MAKE files exuded from the compiler make it that way. Good enough, all I need is to deploy my exe with its xnb and other compiled resource files, thank you once again. Now its time to use my newest language, C#, see if I can get a grasp on this OOP paradigm, and get myself to the other side of this new pinch point set from between, top-down Structured Programming and over to Object Oriented Programming.

Reinventing the wheel, the inside not the outside.

And so, to emulate the concepts that promulgate scope and focus, inclusivity of the object oriented language syntax are engaged. With flows of data streams running throughout my games class interfaces, references to systemspace are made from my namespace. With there return, my namespace classes, which are utilized in-house by playerspace, the space the player intrinsically occupies, corroborate response cues. Reciprocation through the games interface elements provided through pad interactions present the player directional options. Inside these classes, methods and properties consume, ingest, digest and distribute data.

And so, what exactly does this OOP do? For instance.

In the main game class the one reference that instantly comes to mind is GraphicsDeviceManager. When given an instance variable, the class, because of references to systemspace, can draw to its type specific interface, the screen. To keep the scope of this class instance variable consistent, allowing other class objects access to this current instance and so can write to this current graphics device is what this OOP paradigm is about to lead me through. If, by poor design, a classes instance inclusivity is lost, the focus toward this dedicated instance variable, and therefore its utilization because of its lack of scope, forces it to become unattainable. The draw-calls provided to the screen no longer agree, the arguments are disjointed and the screen does not function correctly, if at all. Yep.

Hmmm, it worked in rehearsal. Veneration.

The question I have before me now is how to make an array of ScreenManager classes connect to there respective player controllers. Then, because there is a possibility of four players seeing their own player info above a main game board screen, which is subsequently the screen underlying the players info screens, the need of at least five game state management instances are needed. But, seeing that there are four players maximum allowed per console, I won’t be networking more players in just yet, only one PadJoin instance is all that is needed per game console instance to facilitate all four players. Each pad instance, of the four possible, from PadJoin is singularly assigned as an element within the array of the screen managers, leaving only stack index [0] with the background screen as a shared state player interface utilized by all players.

More candidates.

Just when you think you’re moving ahead, there are more choices which deny preclusion. “SpaceOn” is another game that I had started. This game was to be a simplification of the combination of the Chase Camera sample and the Shader Series 1: VertexLighting sample. Each of these contain a 3D camera perspective from either the ChaseCamera or the SampleArcBallCamera classes, respectfully. The direction of this game was to give the main background screen an ArcBall point of view using a position functionally set between player one and player two. The two dedicated split screens for player one and two would use mainly a ChaseCamera class to provide the view connected to their respective players controller. This is the simplified version which makes up SpaceOn. Another work in progress.

The thick gets ever thicker.

GameStateManagement has a ScreenManager and an InputState, the RPG – Role Playing Game has a ScreenManager and in lieu of InputState uses InputManager through the Update method, NetRumble uses three lists of GameScreen and also uses InputState, while NetworkStateManagement sample only uses two lists of GameScreen along with InputState. It looks like there might be a possibility of making PadJoin a GameComponent and just allow it to connect to the game from the this.Components.Add(PadJoin); in LoadContent. The question here is do I want or need it to be a DrawableGameComponent or simply a GameComponent for what it is to accomplish. Then with that in mind, will that move me closer to the OOP paradigm or back to structured programming. If I keep it a DrawableGameComponent, I’ll need the Draw method to be pronounced while in a specific menu option screen from the shared state of the background screen and accompanying menus. And where would that be found? I guess that would land me back into game startup and game level creation. Suoo-per-rrr. I think it would bode well that the drawing of the PadJoin test screen writes are made only provisional to the debug methods, leaving the utilization and drawing to other game play specific objects and components. The other half is that the data that makes PadJoin relevant is used continuously throughout the game, initially noticed all the way back to “Press Start” at the beginning of the game and ending at the point where the game asks “Are You Sure You Want To Exit The Game?” So at any rate, somehow the game needs to read the data from which will remain DrawableGameComponent PadJoin, because of internal test and visual debug processes, and from there the game can figure out how to obtain and utilize data that is relevant. It looks like I’ll need to configure more provider and consumer classes.

The Vlog.

Before this one finishes up, there is yet another UTube addition, “the gamb and his forest friends (Canoe & Rack)”. I’m trying to figure out just how this production was of any help with Object Oriented Programming. I could try to say something but in some cases silence is golden.

Enough for now, G’day.

October 19, 2012 Posted by | 2012 [0006] to [0018], The Process | Leave a comment

[page 0013] ~ What’s In My NameSpace:

Precluding indirectional additivity.

I have recently found a previously started game solution by the name of CameraAI. This was to be a cleaned up milestone effort to consolidate a main screen and two subscreens, player one and two, over laying the main screen. This came from an expansion of the SplitScreen sample and is the interface gathered from the game HUD On. Having built many side samples to recognize patterns within the given sample solutions, I’ve gone about picking up past Hammer-Throw shots of games I’ve previously attempted. This one is the closest fit for what I need now so I’ll just use this solution as this games ’empty’ entry point. Done.

The Knitty and Gritty.

Building for the Xbox 360, for me, means I won’t be using the computer keyboard, cell phone touch pad or Kinect entry routines. It’s all Game Pad manipulation for the console, which should provide me a better resolution, as I focus on this current task. This should lessen the side track subjects and obliquely aligned variable connections required to make each adaptation work on their respective platforms. Using the game pad as the singular mode of interaction, the obfuscation of concepts pertaining to a controller in each game state should become minimized; not to mention the extra testing processes arising from multiple platform inclusion. But for now, . . .

Sample State vs. Game State.

So far, it has all been a matter of learning by doing, where the main sources of code are based on that within the ‘education catalog’ residing in APP HUB. With the given short concise samples, the exposition of stream triggering mechanisma within their solutions are exemplified. Comparatively, games have intricate compilations, involving many samples, providing an observation as to how these given samples, together, comprise a completed game. With the singular sample solution, when the program is activated, the controller and the observable interface immediately appear in the state for which they are to perform. In a game, the state of the viewable interface and its controller are managed. This affords to the player a cohesive understanding that the controllers I/O interfaces are attuned to what is seen and is capable of being manipulated as each game screen rises in and falls out of resolution. The focus of the game pad follows the state of the game screen. In a simple sample there is only one screen and therefore only one state that the player controller must confirm. In a game, the player control conforms to the state of the game. This ‘state’ ranges in complexity as seen by the entry splash screen, main menu, help files, game options, loading and saving routines, game play and exit procedures. Each of these states are companioned with a set of controller commands that correlate a screen with actions which should be obvious to the player. Among these, countless other states can be created, accessed and acted upon throughout the game. Manipulating the course of game play through these requests utilizes a call and response technique where something is required by the game or desired by the player. Direction within the game is thereby presented to the player as a place where a conclusion can be derived. At times this is a different screen and therefore a different game state. There is also the possibility to change the controller state while the game screen remains in its current state such as when a players transport type is changed or when a resource trigger is to be actuated. There are many possibilities, and so, many configurations. Getting the pad and screen to match up is where I’m going with this. Seeing that I would like to have the main screen accessible to all players, while player one and player two each have their own subscreen and management processes, I need to explore the details provided through the Object Oriented Programming paradigm. The prospectus is immense, and it is why I’ll be working through this within the Research section of my site. Gleaning the relevance and importance of all this is also why I’m simplifying my input options to only the game pad from the console and computer.

Relegation and Reciprocity.

The further I dip my hand into the water the wetter my hand gets. It seems that research has once again given way to practice and study, which means that assorted reading, general look-ups, cited clarifications and walk through code trails are in store for the waters ahead. Using some ephemerally idiomatic colloquialisms, I’ll be water park splash-capade-ing, deep diver trolling, shooting the rapids and back water canoeing my way around these ports of call. Each of these endeavors will move my game brain through the subjects deemed relevant and should evolve into their own sets of mindful solace. To these ends, I’ll extrapolate what conjunctive points I have found to be missing and add what is needed as this solution produces an effective utilization of the concepts I’m attending, that being the merger of the GameStateManagement and FuzzyLogic samples. Letting CameraAI soak up all this perturbation and become defined as a watershed of clearer resources, I’ll then pour it back into BasicGameSize which will become what is next on my agenda, a working milestone.

Two new pages are in my site. The first is “Blages“, which stands for Blog Page Titles and links my site to the individual posts in this WordPress site. It’s more of a how should I title these blogs so they progress conceptually, page to page. The second is titled RESEARCH_MENU MECHANISM_PHASE 01. I’ll access it through the Research sections left column menu entry under the Menu Mechanisms “Me Me” link then the right columns “Phase 01” link. It will open space for my commentation extracts captured from all this mental precipitate concerning OOP and its utility.

“I’ve got water on the brain, …” from the band Ten Years After.

So anyway, it seems that “the gamb and his forest friends(whatever)” has taken the lead over “FarNiche_####_?” on the Vlog by two to one. It is a good thing with the newest being; “the gamb and his forest friends(Right Here in Potato-cide)”. And in doing, it gives me some encouragement so that when it comes around to making some video game music clips I’ll at least have an idea of what to expect.

I’m glad I can still get my game face on while sloshing my vacation around along with this endevor about in my head.

September 17, 2012 Posted by | 2012 [0006] to [0018], The Process | Leave a comment

[page 0012] ~ Consolidating a Base-Line Game Level:

June and July were a time to deprogrammefy myself, (see Vlog).

It’s August, and in three days the Curiosity, Mars Science Laboratory, is set to harmlessly land on the planet … , wait for it, … terror ensues 7 minutes, … Mars!


I finally jumped into Facebook for FarNiche, and will leave Facebook to showcase my highlights as what’s new within FarNiche.

Now to get this gaming idea somewhere, I’ll need to get back to my reading, web site Research page, game creation, code testing and more things that I’ll think about as I get to it. First off, in my web, I’ll shift my previous game assets from its existing page on the HOME page off to a subheading under the HOME page such as Prototype. Done, the HOME page is empty again along with some link tweaks. I’ll need to start a Review page for the books that I read as a left column topic under the About page. Lastly it looks like SpaceWar II is the game that I’ll be working with to get back into the swing of things. Yes, that’s nice, it’s nice and messy and it works on both the computer and the console versions. Now, how to get my Babbage engine brain back to work.

It’s time for a walk through to refamiliarize all that was once headway.

The solution “BasicGameSize” has kept the best programming format. Its layout and tidiness should make the placement clear for the desired robustness which will add new features needed to exemplify my generic game shell. For my purposes, this starts with adding the GameStateManagement code class pages and declared initialization variables in there proper locations to connect the logic flow. Ah yes, event handlers, and delegates, and eventargs, and the PlayerIndex all placed and arranged, not. Integration of the GSM Sample will need some research. But already included in BasicGameSize is PadJoin with PadIO as PadJoins dependency. These two small classes affirm connection between the console and the game pads. While going through trying to remember how it fit together to do what it does, I’ve found something about the assignment of the pads within the console and computer receivers. It’s something somewhat unnoticeable but here goes.

A Bit of Recognition Testing.

The Xbox 360 is on. Having been started with the button on the console and not a game controller, then seeing that a controller is needed to interact with the screen interfaces, a game pad is turned on. The console assigns it to slot one for the first controller. Then as other controllers are turned on, they are sequentially assigned to the next open slot, up to four slots, therefore a maximum of four controllers per console. Opening the battery compartment of an active pad, effectively turning off that controlling pad, PadJoin alerts the running game that a pad has disconnected. So when the controller is turned back on, the consoles receiver correctly reassigns the pads previous slot position and previous PlayerIndex as it was initially assigned since the Xbox 360 had been turned on. If the Xbox 360 is turned off, the controller order is lost and as the pads are again turned on, the order of connection as the console recognizes them becoming active, rebuilds a new sequence in the console as a new list ordering PlayerIndex. This might seem blatantly insignificant, but while building this on the computer, then running the debug version which is seen on the computers monitor, the sequential order of the game controllers becomes inconsistent. To see this behavior it requires that the controllers are reset from the Xbox 360 receiver to the Xbox 360 Wireless Receiver for Windows. Now the USB receiver attached to the computer is recognizing the game pads. Doing this while PadJoin is running in BasicGameSize shows on the computer monitor the order of recognition from the now active pads. Here is where the inconsistency becomes obvious. Running the computer version, all the pads are on. The indication of the pad and the owning player index is in a specific slot which is seen as text on the screen. Pads two and four are turned off. Pad four is restarted first and now becomes pad two and fills up the PlayerIndex sequence in order of availability, leaving pad two when restarted to become pad four as indicated by PadJoin. This became a matter of concern while going through a sample game called NetRumble. Because this game can run on both the computer and console at the same time with a network connection in debug mode, the need for consistent pad recognition became apparent. Having an interface that will allow any player to jump back into the game after a disconnect, and then have the pad assigned to the correct PlayerIndex in the game on either the computer or console, must be the reasoning behind my PadJoin class. It seems that tweaking PadJoin will continue as each implementation reveals the slighted intricacies of each solution which utilizes PadJoin. This type of play testing is apparently the “modus de facto” while stabilizing a class for generic use.

Back to the Research Page.

MenuMechanism has come under construction and is the next entry into the research section in my site, so for now, this concludes the monthly synopsis. I think I’ve got my game brain back, now for some reading. G’day.

August 26, 2012 Posted by | 2012 [0006] to [0018], The Process | Leave a comment

[page 0011] ~Amid the Art the Code and the Plot:

Where is my Level Editor?

Another book showing what goes into building an RPG has necessitated a new solution to figure this out, and stands with this main idea where the combination of two games, FuelCell and FuzzyLogic, together become CameraAI. The game plan is to let the fuel cells be the mice and my avatar in the game be the tank. This should give me some practice at blending two games and begin to figure out what makes up a ‘Level’ in a game. The camera part will let me redefine what I have from HUDOn, which is a beefed up version of ChaseCamera, and work on a point of view that is off center of the controlled character.

But there are some things that will slow this down initially. The first bit of trouble comes from the game pad controller itself. Being that the game pads design has been fashioned to comfortably fit into the players hand, it therefore has a limited albeit convenient set of input interfaces. The controller has buttons to press as Boolean input and then graduated input seen as the joysticks and triggers. Another aspect that I have found to have relevance is the amount of time that the button is pressed to activate it and also the speed with which the joystick or trigger is moved. The last caveat holds with the three states of the joystick residing in the GamePadDeadZone, either (None, IndependentAxes or Circular). These modes can be extrapolated from the input states found in the solution InputReporter_4.0 sample. The problem is compounded when adding actions mapped to the controller. This implementation is found in the RolePlayingGame_4.0 sample where the controller inputs perform different actions because of the context stated by the game. The InputReporter sample uses delegates and events that keep the processes distinct from their utilization, and the RollPlayingGame enumerates ActionMaps that are specific to the GameState. The requirements of games larger than “sample size” continuously overload the capacity of the controllers functions. As the game grows, so does the overlap of the game pads inputs. So its time to pick apart these mechanisms and set them into a couple of game components I had previously built, PadJoin and PadIO.

Just to follow this to completion, when a game starts the first thing it seems to do is say, “HELLO… Hello…hello, is there any body out there? Just press start if you can hear me, is there any one at home?”( mostly from Pink Floyd, but you get the idea ). The game would like to assign a specific enumerator to the controller, setting it as the host. So it is asking that the player hosting this games instance press “A” or “Start” so it can initialize PlayerOne as the hosting controller to the game. And of course, that will need to instantiate some incarnation of the GameStateManagement sample, a routine which has happened to elude my greater concern and understanding, from lack of need for a menu system in any game play I’ve created thus far. Getting back to the controller pads, … Just as a thought, in the course class CompSci 351 Data Structures and Algorithms, operator overloading in C++ could be the “idea obscuro” to blend the game pad InputState class with the game state GameScreen class through the game pad state logic as an ActionMap. Hmmm.

An Ode to Muddle & Slog.

To muddle about in a paisley path step.
Belaboring hindsight in thought blinding stare.
Clueless as to my next curious connection.
My gate now a slog with what can be where?

Yep, while looking for another concerted solution attempt that will lead me to a succinct explanation for my GamePadState conundrum, I have run across yet another adaptation in the App Hub ‘education catalog’ Net Rumble 4. This solution game uses both the Windows and the Xbox360 builds simultaneously. First I built and deployed the Xbox solution, then in a separate game studio instance, built the Windows version. On the Xbox360 I run Net Rumble 4 from ‘my games’ and select “Create System Link Session”. Next, starting Net Rumble 4 as the Windows (F5) Debugging version on the computer and in the start game screen I select “Sign In”. From there I can sign into Games for Windows – LIVE using my App Hub account. Once the Windows version signs in to my account, the Xbox360 version disconnects (Code 7). Then restarting the ‘my games’ version on the Xbox 360, Net Rumble 4 can, from either application instance, go to the games “Create System Link Session” or “Join System Link Session”. From there a host game instance on either the Computer or Xbox360 will allow the other instance to client where both players are seen in both game instances. One game pad for the computer screen focuses on the ship on the computer side and another game pad for the console screen focuses on the ship for the Xbox360 side. It works.

Doah, Supra-Segue.

SpaceWar has become a Game Studio XNA Framework Version v4.0 on XBox360.

In this version the System.Xml.Serialization has a Reference in the Runtime Version. But after rebuilding and deploying my version of “SpaceWar II” to the Xbox360 in Settings.cs the File.OpenRead(…) is still producing an error. The settings.xml file isn’t found in …

An unhandled exception of type 'System.IO.FileNotFoundException' occurred in mscorlib.dll

Additional information: Could not find file ‘T:\584E07D1\settings.xml’.

Selecting the settings.xml file in the Solution Explorer of SpaceWar II and in the “Copy to Output Directory” field, setting it from “Do not copy” to “Copy always” allows the build to be played on the Xbox360. OK, that’s not only pretty cool, that is very cool.

Sun light above the muck and mire.

I’ll end this one by saying Thank You to those at the APP HUB place.

May 23, 2012 Posted by | 2012 [0006] to [0018], The Process | Leave a comment

[page 0010] ~ZBrushing and the SketchBookPro Story Board:

ZBrush vs. the Slide Rule.

I’ve been working through a book on ZBrush so I haven’t coded for a couple of weeks.  So far, because of this reading, I have come to an understanding that is best expressed as an analogy.  As such, if you are going to use a Slide Rule as an aid to facilitate the processes through an equation, and initially have no accompanying Users Manual for the slide rule, the chances of success become very limited.

The purpose of a slide rule is to efficiently guide solutions of an equation towards its conclusion, given that the mathematical processes required are understood and so implementation of the functions of the slide rule can be incorporated.  Likewise, my use of the ZBrush software is similar in that, the art assets I create are visual representations of processes that connect the story line logic and thereby will be presentations of ways to contour different paths towards expected conclusions within the video game.  The slide rule and the software are both a means to an end, so having a strong grasp of the intricacies of implementation are needed.

Be that as it may, I sculpt and draw my way through what the book explains and find that the best way to remember is to reinforce the patterns from within the context from which they are implemented.  The flow of plentiful keyboard shortcuts begin anywhere within an array of drawing, painting, sculpting or modeling constructs.  The type of pictorial art can begin its render as an idea that will move towards its conclusion because it is seen as one of these starting points, thus ending as a drawing, painting, sculpture or model.  It sounds like I’ll be in a recursive education mode for some time to come.

To be completely fair, in that a picture paints a thousand words, here is a link to the ZBrush Site and their UTube Channel.

ZBrush Website.

ZBrush on UTube.

An Overhaul of Old Art Assets and Game Matrices.

The HOME page of FarNiche has turned into one very large page, with a longer than usual upload time.  It continues to grow, although the end is in sight.  Once filled, with the lingering portions of previous game ideas, that whole page needs to be subdivided within a subtopic under the HOME page as Phase I.  Then, Phase I can be used to guide the game thoughts through more lucid definitions in the Generic Structures and Resource Templates section under the Research page of the site.  That will leave the title page open again to be refaced as the next Phase of FarNiche.

Oh – my, complexity.

I’ve just about finished the ZBrush book, am half way through an AI book and have also started a book on Economics.  The story board idea will need to suffice with its start as Phase I from my site.  Now, I must jump back into the past and relearn what I was working on before I started digging through my old files and programs for that story board idea.  Eventually, I’ll retool those art assets in ZBrush, but I’m getting an itch to do some programming again and I really need to make those recently learned game load/save procedures useful, for all the research that has been put into it, before its too long forgotten.


April 9, 2012 Posted by | 2012 [0006] to [0018], The Process | Leave a comment

[page 0009] ~Adding Some Game Components:

Gibberish and trust abounding, Aquarius?  A – quar – i – us . . .

The FarNiche Research page should be getting its first real entry soon. It will, it has. It is XML I/O.  And, for the most part, it almost makes sense.  It has to do with the most basic processes confronted when, the need to load and save game files is initially or finally encountered.  The HOME page also has had more added to it, much more.  So far it consists of [the game.], [the cast.], [the character.] and [the environment.].

[the game.] is a short and grand overview of the games scenario with a picture from the first FarNiche Universe Map written in VB_6.0 sp6.  Therein, the dialog explores the story, giving a vague sense of foreboding and the idea of a sinister fate that awaits all of the players in the game.

[the cast.] explains a dilemma, befitting of all characters in the game, depicted in a series of title thoughts connected to an accompanying picture(set).  The pictures are from programs that I had written while taking the respective courses at the University, while others are screen shots of Windows Form based game wanah-bees that I had written on a whim, and still others are my expansions from the XNA C# Education Catalog and new namespace mutations.  The pictures relate to the game more metaphorically seeing that they stand as placeholders to remind me of the type of implementation that will be needed to have the characters coalesce within game play.

[the character.] has existence within the game.  While the characters movement through the game is convoluted, this existence is expanded from the stable format of an ages old game, chess.  Every character is derived from a set piece,(Pawn), involving a combination of, (Bishop, Rook, Knight) attributes, where each attribute has a minimum and maximum sin wave value bound within two limits, the (Queen, King) inclusivity.  An invocation of the character creation process returns an instance of the characters Habiture-Resilience. With this addition, there sets into play and continues the notion of Chaos and Entropy that is inherent throughout the system.  Game play continues as the characters contributions toward their missions success or demise are encountered. There, a positive or negative push or pull is also encountered, effecting the Habiture-Resilience in whole and in part, their recursive dilemma.

[the environment.] consists of the pictorially given environmental Scape.  The Scapes provide differing mediums through which the Soul-juoru mediate their Skill Sets.  So far these Scapes are formed as the Space scape, Air scape, Land scape and Water scape.  These provide the general environmental boundaries.  Through the boundaries, crossings are allowed from and into other Scapes.  The behavior of each Scape enhances or beleaguers each Soul-juoru mission accordingly.  With the provision of barriers, the Soul-juoru is forced to resort to their use of their Skill Sets to overcome the bounding barrier.  Combinations of skill sets between characters increases the likelihood of the barrier becoming comparatively less of a hindrance.  The possibility of mission success to accrue within each of the Scapes can then be realized as an extended advantage between Scapes.  The initial advantage is the capacity of the Scape to consolidate the Soul-juoru mission collective at these barriers which create vortex apices, mission pinch points.  The environment therefore preposes the skills required to overcome the particular Scape.

More [the .] Forthcoming.

[the contour grid.]

[the skill set.]

[the axioms.]

[the ai.]

And yet another Segue.

Going about this consolidation of gamish assets and trying to think through how what fits with what when, has brought to mind the need to hone my own skills of story boarding.  And although, for as much as I would like to cut to the chase and continue to build and rebuild coded game stubs and prototypes, I need to step back and study the workings of ZBrush 4R3.  Economically, it is the greatest pic for the click.  The biggest obstacle here is that it requires a different train of thought while working through the interface.  It is very different from PhotoShop which is also very different from Autodesk XSI.  So anyway, I’ve painted in mostly acrylic, Cray-Pas, color pencils and pens.  It has also been some time since I’ve done any real clay modeling or casting.  I understand the basic artistic concepts so its off to re-realize all that and now, for how its to be captured and expressed in ZBrush.

And then there is the idea of the Object-Oriented Database Management System (OODBMS) that can be used to help define the games data structures and get them ready for the XMLSerializer and the save or load subroutines . . . whatever.

That that is is, that that is not is not, that that is not is not that that is, nor is that that is that that is not.

Yup, seguey me.


March 11, 2012 Posted by | 2012 [0006] to [0018], The Process | Leave a comment

[page 0008] ~IO Storage SaveAs and Load XML Data Streams:

The Vlog has its second entry, FarNiche_0001_HUDOn.

The HUDOn namespace is now unsupported but not nonsupported, it is a milestone. BasicGameSize does exist and already has code pages from its predecessors incorporated into the new namespace. But looking at the Error list, it seems that that left off where the idea was to be continued but, the prep work seemed malevolently daunting.

I’ve rearranged my MyI website to open space for the Research page. It seems that there are some schemes and protocols that might make this task somewhat easier but therein assumedly less efficient, from the stand point of one in whoms’ mind it is now refreshingly relevant. But to move on, the Research page needs work, it has an intro, a direction. Now Research needs research.

What it is and How it does it.

BasicGameSize has its criteria to which its end is understood. The two predecessor games logic is to be decoupled from their namespaces and reoriented within the new game namespace,i.e. BasicGameSize, which will yield this games basic .ccgame file size. The placement of the objects variables need to be reorganized. Their implementation and visibility is currently mostly global. Like I said, one monolithic page of code, all variables global and the GoTo statements are the nails that every good carpenter needs to build a computer program. “note to self, . . . NOT!” Not any more, for the most part.

Encapsulating the concepts of my previous programs processes is what the Research part of the site is to become, so that is probably what brought BasicGameSize to a shrieking halt and sent the direction over to SpaceWar_II. But even there, there are global variables. The idea of encapsulation can be seen as a GameScreen object in GameStateManagementSample when put in play, (some sort of encapsulation?), and in SpaceWar_II the Ship is built as a SpacewarSceneItem, (another sort of encapsulation?). This then opens up the topic of . . .

The Three Pillars of Object-Oriented Programming.

Hmmm . . . still reading. So the next subject is.

I’ll be looking into StorageDemo_4.0.

It’s downloaded, extracted and now, to Build it first, then deploy it from its StartUp project folder to the Xbox 360. Or, look at the error list when the copy of Xbox 360 Project is added to the Solution and do some foot work. References to MS.Xna. Framework, Game, GamerServices, Graphics and Storage have little yellow triangle exclamations in the Solution Explorer. Those need to reference the appropriate version, yes, research. [Serializable] is now my error in the Xbox360 Solution Project only. Removing that project allows the Build of the Windows project. Going to the …’My Documents\SavedGames\StorageDemo’… folder, running the game and pressing game pad “A” changes the Win PC time stamp of the savegame.sav file.

We got a heart beat.

Yes there is, and getting there was definitely research. : XML I/O : StorageDemo deploys, loads and runs on the Xbox 360, it can bring up a Keyboard UI, accept input to the UI and returns that value back into the games data structure. It can also save that data structure as an XML readable, (although I haven’t figured out any process, let alone simple, that I would need to continuously go through to view the changed file on the Xbox 360 disk or storage devise), file and can reload it as a restore point while the game is still running, or from a save point when restarting the game. To get this into the new namespace LoadSaveData, a precursor to BasicGameSize, it needs to bring along some classes as reconstituted game parts that have proven useful in the past.

‘Till then, G’day.

February 20, 2012 Posted by | 2012 [0006] to [0018], The Process | Leave a comment

[page 0007] ~ For The Continuing, of Course, SpaceWar Conversion:

A couple of those “WOW” moments.

Windows 7 and Microsoft Visual Studio 2010 Express for Windows Phone:
When in debug mode and break-points are set and Enabled, the game runs to the point where a break-point is encountered.  The game stops and at that point I can begin to step through the code.  But now, I can also hover over the game icon button in the taskbar and then over the thumbnail of the game that is now stopped but still running in the debugger, giving me a snapshot of where in the game what is now taking place.  Before, there was no way to get a view of the game while in a break-point pause of the game.  This really helps to be able to see how particle emitters and other game objects are performing as the code moves along.  By design or dumb luck, I like it.  Very wow.

Another very cool and neeto slice into the background workings of the logic going on under the hood of the running code, is pinning a list-box with the variable name and its value right next to the logic that is manipulating its value.  The value text color changes as its value is varied by the logical steps in the code.  Having these tools to verify each step of line logic verses value update with integrated arrays, well, . . . again much, much wowness.

And to top it off, App Hub, for the Indie game builders of the Xbox360 the .ccgame file size has become a 500MB maximum game file size, the number of games is now upped to 20 and the points for the 150MB game size have been lowered.

Now, a montage of old bits and pieces, So What’s New.

The short and long of it is, BasicGameSize, for all I know may not even have been compiled yet;(which is to be the successor of HUDOn).

I’ve gotten SpaceWar to run on the PC but not on the Xbox360.  It uses a different IO stream and storage protocol, i.e. some flavor of the compact .NET Framework on the Xbox360 along with the GamerServicesComponent which connects to other services, and therefore needs some retooling to be able to create and access the startup game files.  While working on this 2D game it has turned it into “SpaceWar II”, giving it a new GUID# and namespace which won’t overwrite my older milestone edition of SpaceWar.  A few things needed to resolve this solution into a combined project are the RolePlayingGame, StorageDemo and the GameStateManagementSample.  Digging into a combined project of this sort might reveal an avenue where save protocols could find a way to enable the opening and saving of data to SpaceWar II in the platform used by the Xbox 360.

As for the Archived SpaceShooter, it seems that that games direction was more in line with incorporating HLSL or some such in the graphics pipeline.  GS4.0 changed the way graphics are read into the graphics pipeline, so going from GS3.1 to GS4.0, the planet textures became incompatible with the new interfaces now provided with GS4.0 graphics protocols. Yes, Vestiges, but visually when it did run or still runs in GS3.1, graphically is still a very cool game.

It only looks like a different direction but it’s all still going the same way.

GS4.0 RPGGame.
First just “Build” the project, then, press (F5)Start Debugging, because it seems to need to be built before hand as the StartUp project before its deployed.  Something doesn’t get built if it is only built with the debug command while being initially built and deployed as an Xbox360 build.  Then the GS4.0 RolePlayingGame Builds and Loads into the Xbox360 which means that the Save and SaveAs also work, and they do.  GameStateManagementSample also runs on the Xbox360, but does not implement any saves for any game data.  So it looks like this will be my stompin’ grounds for a while.

And it is, as I have found a case, where when playing the RPG game, a character joins the Party.  When the screen is exited then reentered, that character is re-created in the previous spot from the original position.  The character is not removed from someplace or given a Boolean false to deny a reincarnation.  In public void JoinParty(Player player) I commented out the two Exception if statements but then the characters kept being added to the character list, where the array where it is stored finally over ran its length and the program crashed out.  Then, uncommenting the two Exception if statements, I placed the code that was to run after the exception check, into players.Contains(player) and made it an if Not players.Contains(player) i.e. if (!players.Contains(player)){ then so forth};.  This works except that the added character is always at the point in the map where that character was first encountered, but now it is not added to the players party because there is a player of that type and name in existence.  It’s sloppy and very counter intuitive but I get it and it gets the game to run.  I’m after the ability to learn how to save game files anyway.  So all is well, kinda’.  It also seems that when the final quest is completed not all is reset, what is reset, I don’t know, because once again while continuing to play the game after the final quest has been completed, the duplicate Party characters are still visible in their original starting positions and when encountered again, added to the list, which causes the game to crash.  But again no biggie, for now its just about the file save and load.

Man, that was long in the tooth, for only beginning to prepare the way to extract and infuse the IO ideas from those samples.

So what happens next?

Capture some of HUDOn and get it into the VLOG.  Then splash around in the RPG Game and find out how it does what it does.  Probably start a new project solution to incorporate Save, SaveAs and Load, i.e. Storage, within the GameStateManagementSample using XML readers and writers.  And in the end, figure out how to get the XML files to load in SpaceWar II so that game can get into the Xbox360.

Adieu? Adieu!

February 3, 2012 Posted by | 2012 [0006] to [0018], The Process | Leave a comment

[page 0006] ~ SpaceShooter Conversion:

Job Descriptions and Expectations.

When I was a roofer my best friend and mantra was to just think about what I was doing and not where I was doing it. The same went for my stints with carpentry, landscaping and basement waterproofing. There was danger everywhere, so all I had to do was to keep my mind on my work, be aware of my surroundings, always have an easy-out just in case and all was well. After opening up the archived SpaceShooter game and looking at all of the folders in the project solution I got a little shiver of impending intuition. The chances of things turning out well were there but being wary still didn’t preclude any nor all pitfalls. I’m glad I took that up back then because I can now see that that is a young mans’ game. I’m also very glad I kept up with my continued education so I can use the old adage, “If I knew then what I know now.”, so not all is lost in translation. And with great trepidation, to wit, version conversion.

Stepping through v3.1 SpaceShooter.

Yep, when all else fails, read the instructions, or press ‘Step Into(F11)’ many upon many times until you are in the games’ loops; Update and Draw loops, that is. Doing so will lead you through the initialization of SpaceShooter. Setting the red-spot break points at the end of huge initialization loops, then pressing the ‘Start Debugging(F5)’ arrow button then and again, will run the cursor to that break-point. You then disable that break-point and continue stepping through the code. Doing so should speed the process, unless of course, you’re very interested in watching the variables change hundreds upon hundreds of times. In the end, after stepping into and stepping out and over functions and loops, you end up in the Update and Draw loops. This is where the game acknowledges, accepts and processes the players desires, which are revealed as a flow of requests to contour the current instance of the games scenario.

Stepping through the New and Improved v4.0 SpaceShooter.

Well, that was more like gutting a deer than a graceful and pristine evolution into an integrable conversion template. It didn’t use all too much compiler time though, as the compiler was breaking and barking all the way to the bitter end. After reading the Error List when the compiler could finally stand no more of ‘What Is This Supposto Mean’ verification attempts, the suspect blocks of code were commented out. At times whole code pages would become ‘Excluded From Project’. Gone are the functions, dependant variables, aligning logic flows. But in doing so entire slues of probable errors were created. Needless to say that all that is left are some raw consumables, the vestiges of what was. It looks like the SpaceScape, like the International Space Station, will need to be persued via another route.

Space and Space.

50MB or 150MB, that is the question. And the number one answer is, ding ding ding, 150MB, the maximum size for and Indie game. HUDOn is up to 111MB of space in its slapped together state, according to the .ccgame file size, which leads me to believe that I have only 39MB to play with. GameOn and HUDOn have been great diving board experiences but it looks like I need to put what I’ve created so far into a game format. I don’t think I’ll be incorporating the yet to exist SpaceScape into this game because of .ccgame MB size restrictions. And neither of either of these two project solutions have any sound, so that will also add to the final content size.

What then will my next game project solve?

An appropriate name for the game should come from where I would like to end up. That place needs to be a file size that economizes the GameOn and HUDOn environments in their simplest form. The two subjects I need to extract from GameOn and HUDOn for this new game are the Scapes and the ship that flies about it. HUDOn sum-what fine tuned both the terrain and the ship objects and also added the PerformanceMeasuring sample and my incarnation of a Mini-Map. Taking all these pieces into a new game solution, should give the title of the next game another milestone concept. The topics envolved drive the games’ name, being, BasicGameSize. This is the next increment name for FarNiche as it grows from project solution to project solution.

Tidying up for, One More Vlog Entry.

HUDOn needs to initialize both the 3D terrain map with the 2D mini-map of the 3D terrain so that the two forward facing vectors are aligned, in respect to their X,Z coordinate planes that will be collinear with the ship. A point needs to mark where the ship in the 3D terrain is located in the 2D mini-map. The zoom-in and zoom-out of the mini-map needs to be centered using the ship as the origin when zooming, and the mini-map needs to rotate about the ships origin. Incorporating a portion of a GS v3.1 sample called SkySphere will add the ability to pan around the ship to view the surroundings without changing the direction of the ship. It uses the Quaternion structure and it is my first time to get an understanding of its actions inside a game that I’ve built. The idea of a mini viewport, that is a split-screen view, has also come into play because while the main viewport displays a mode of the current camera settings, the capability to continue a consistent navigation of the ship is lessened when the current view is a focus that does not fully pertain to that of a pilots position in the ship. One case is that of the Seeker mode which incorporates a 360 view camera. This mode moves the camera away from the ship but the focus remains on the ship. The ship can continue moving forward toward its destination as the view about the ship can be seen while turning the camera about the ship so as to see in a cross-view direction to view the ship in its surroundings. Another mode is that of a fourth person camera where it is placed at a position of one of the spheres from the PerformanceMeasuring sample. Watching the ship fly through the Scapes seemingly completely detached from a conventional pilots position proves to be inconvenient as the hills and waters position in consideration to the ships position will still produce a conflict, a crash. Having a picture in picture split-screen should convey to the player that the ship is still being piloted through the controller although it is also seen in the large common viewport as like that of a jet streaking overhead, small, quick to pass over and mostly unnoticeable.

Hello Again.

It’s January 2012, and I started this page sometime around July or August of 2011. I’ve almost completely forgotten how HUDOn works because I hadn’t written any type of help file or graphical view of a controller map page. I can’t even remember if I had gotten it to run on the Xbox 360. So it looks like I need to hook up the console and run the XNA Game Studio Connect game in my Indie folder. Well, HUD-On does have an Xbox 360 Copy() of HUDOn already added to the project solution, so I’ll just go up to the Build/Configuration Manager in my MVS2010EfWP IDE and enable the Build and Deploy check boxes and then click Close and Start Debugging (F5), after I have selected the Xbox 360 Copy () of HUDOn and have set it to Set as StartUp Project. That’s a good sign, it took a while to compile and deploy, and it looks like I have the ship from the ChaseCamera sample hovering over some terrain, now if I can remember what the buttons on the controller do. It works perfectly except for an [eek! I dare not say … gasp], exception in HeightMapInfo. From what I can recall its because at some point in time I was trying to get a fourth person point of view using a sphere from the PerformanceMeasuring sample as the origin of the view frustum and having it over-run the height map data, i.e. It does what TRON did with the motorcycles except for the fact that the debugger halts the logic at a line after the indicies are calculated and some variable is taking some heights, normalizing them and then taking them as a Linearly Interpolated value used in the GetHeight(Vector3) call. When I had just opened the project solution that code page was the viewable page and from what I can recall it was the major bug that produced a game logic crash. Otherwise, except for a couple of on screen variable value pairs cluttering the viewport, I have solved HUDOn and will send a slice of its current state to the VLOG.

How does it fly?

It seems that the ship can fly up to 82300 units before it reaches the SpaceScape, there are two viewports of the same ship with the same person-tense type. OK, another [Additional information: fieldOfView takes a value between 0 and Pi (180 degrees) in radians.] exception, in ChaseCamera UpdateMatrices CreateLookAt. This time it was a green arrow instead of a yellow Step Into(F11).


January 22, 2012 Posted by | 2012 [0006] to [0018], The Process | Leave a comment