the xna machine

The WPF Machine

2008-10-14T11:27:00.000-07:00

Well I'm abandoning my XNA development efforts in favor of WPF/Silverlight. Primary reasons being:

WPF/Silverlight does not have a language barrier (you can use VB, etc.)

The distribution agility of Silverlight vs. XNA is off the chart. The Silverlight plugin does not require Windows (let alone the .NET framework). It's simply a browser plugin ala Flash, available for both Mac and Windows.

XNA Click-once. Very cool for C# XNA developers, but the prospect of creating a Click-once VB hack/workaround/replacement for VB XNA apps really ups the proverbial "is this really worth it" ante.

The basis of my 2D XNA engine (i.e. the matrix hierarchy, and a scripting engine (which I never covered, but basically it allows you to target any property of a specific data type and interpolate it over time)) this was all very cool indeed. And it all already exists, practically verbatim, in WPF*.

*While it's a bit satisfying to see I came up with the same solution that Microsoft did for scripting any object with time-based animation, it's also a very major /facepalm to see I've been reinventing the wheel for the past several months!

WPF appears to be the future of Windows development, which I'd like to stay on top of for both my career and personal interest. What's more, you can totally make games with it. You can even use GPU shaders. No, it's not as powerful as XNA but you have to admit; the whole ordeal is rather neato.

So someday a new blog might crop up somewhere with my WPF/Silverlight stuff on it (altho for now I'm still pretty green). I still have those game ideas tucked away waiting for implementation... someday.

Off topic

2008-06-20T03:18:00.000-07:00

As a potentially negative side-effect to now giving these blog posts more descriptive labels, there are now several non-XNA related topics on this blog.

Namely, Off topic.

Here are some Off topic links I highly suggest:

LINQ to SQL Server CE

2008-06-19T13:32:00.001-07:00

In Visual Studio 2008, when trying to drag a local SQL Server CE database table onto your LINQ design surface, you receive the following error:

"The selected object(s) use an unsupported data provider."

This message is a little misleading, because you can in fact LINQ over your SQL Server CE database; it's just the drag & drop LINQ design surface in Visual Studio that doesn't know how to interact with SQL CE.

To work around this limitation of the IDE, you can call upon Microsoft's SqlMetal utility to create a .dbml file (aka, a new LINQ to SQL item) on your behalf. Here's a reasonably simple way to accomplish it:

In your project's solution explorer, right-click the node containing your .sdf (database) file and "Open Folder in Windows Explorer". In the resultant window, create a new text document called MakeCeLINQ.bat and edit it, entering this command:

C:\"Program Files\Microsoft SDKs\Windows\v6.0a\bin\sqlmetal.exe" /dbml:CeLINQ.dbml Database.sdf

Replace Database with whatever your .sdf file is called. It's important that this batch file be created in the same folder as your .sdf file, since the command is structured in such a way that assumes the .sdf file is sitting next to the batch file. Close & save MakeCeLINQ.bat, and double-click to run it. SqlMetal will create CeLINQ.dbml.

In Visual Studio, click the button to show all files for your project and include your newly created CeLINQ.dbml file. Include the "MakeCeLINQ.bat" file, too - strictly speaking it's no longer required, but you may find it convenient to keep it with your project.

So now you should have something like this:

You can now work with the CeLINQ object within the IDE as normal (with the ever-present exception of drag & drop functionality). If you change any of the schemas in your CE database, simply re-run the MakeCeLINQ.bat to update the CeLINQ object.

LINQ

2008-06-17T03:12:00.000-07:00

I did a little project for my wife this weekend and used LINQ for the first time. Visual Basic's implementation of LINQ over XML is just about the greatest thing since sliced bread.

Looking at my Web Updater, I get an xml file called the "wum" (web update manifest, which contains a list of server-side files to compare against a client for making decisions about which files to update). To read these wum.xml files in my Web Updater, I was using an XMLReader to simply parse the file in a serial fashion. Which worked fine, really; although there was not any "knowledge" of the xml document itself within the IDE or the Web Updater code, per se; the parsing routine was a bunch of XMLReader.Read statements, with the occasional variable assignment thrown in whenever certain nodes were reached. Without any prior knowledge of the XML file in question, the parsing process is not exactly intuitive to behold, let alone modify/debug.

With LINQ, this task of reading the wum.xml to determine which files on the disk require an update can be accomplished in a radically different fashion.

First of all, rather than simply associating a wum.xsd schema with the XMLReader's xml settings, you can drop said schema into the solution explorer / project itself and in doing so, define an XML type much in the same way you'd define any given class. With the xml schema now available to the compiler, VB provides you with "xml intellisense", allowing you to traverse an xml document in no less than xml statements such as objMyDocument.<customer>.<name>.<first>.Value and things of that nature. It's a little strange at first but pretty fantastic. This obviously injects a great deal more knowledge of the xml structure itself into the code - now someone viewing or even editing this code for the first time has a far less abstract situation on their hands.

If that weren't enough of an improvement, I realized I didn't really have to serially process the wum.xml at all. I can take that XMLReader I'd been using to create an Xml.Linq.XDocument. An XDocument is basically an xml document instance but it's queryable by LINQ - so you can treat it like a database. Now I can save literally dozens of XMLReader calls & parsing effort by simply querying the XDocument Where Not IO.File.Exists OrElse IO.File.LastWriteTime <> (queryResult.LastWriteTime) and viola, an IEnumrable object of XElements matching the query are returned. In addition, the query result can be stuffed into any given appropriate class of your choosing, so you don't even have to deal with XElements in the result set if you don't want to, and then ultimately .ToList(ed) into a generic List(Of <whatever>).

It's all slightly mind-blowing the first time you sit down to use it, particularly when you consolidate 50 lines of mundane XML parsing into a single LINQ query in a matter of minutes, never even having used LINQ before. Just imagine what you can do with this stuff once you actually know how to use it... pretty cool!

Scope creep

2008-06-14T16:36:00.001-07:00

I updated the graphics of this blog a little bit. I'd been playing around with a VB/XNA logo hybrid in photoshop so I thought I'd use it for something.

I've been working very hard on my Web Updater and Wummer applications over the past 2 weeks and I haven't been able to resist putting more and more functionality into them. They're turning into things which may actually be quite useful.

The Wummer will now let you split up the files you want to publish over however many different hosts you specify; so for instance if you have 3 hosts at your disposal but they're slow uploaders (eg., homebrew DSL & Cable broadband line hosting like I use for most things) the Wummer allows you to divide the publication of files amongst multiple hosts, and the manifest now groups files by host.

You can also change the relative path binding of each file, so that any given number of remote URLs can map to the same local client install directory. This all required a somewhat extensive storage system for the Wummer, so I chose to use an sql server ce database, which keeps track of all the projects and files and hosts etc. of every probject you've ever published using the Wummer.

In addition to being able to react property to the new manifest files, the Web Updater will now also attempt to update itself by temporarily cloning it's own executable and launching it with the Web Updater's own manifest file specified. In this way the Web Updater sort of "cheats", using a copy of itself to update itself, which I thought was cute.

There are a few small but important touches to add to the Web Updater before it's ready for prime time, right now I've got the XNA Content Assistant performing updates with it and it's working pretty well, it's just not quite as elegant as I would like yet (currently there is much shutting down and restarting of programs during an update process which, while automatic and not necessarily cumbersome to the user, is unprofessional looking and some of it can be avoided).

At some point I would like to consolidate all this into an "xnamachine software portal" application, which installs the prerequisites & runtimes on your PC (such as the Visual C++ redist for XNA games, .net 3.5, sql server ce, and provide convenient links to the XNA redist & DirectX web installer, which are easier for the user to just run themselves at this time). That way, there would only ever be 1 thing you would ever have to "install" from xnamachine.com in order to use anything I release. The portal would be an updatable application launchpad that provides links to whatever I make available; the Wummer, the XNA Content Assistant, templates for Visual Studio, XNA games, whatever. Such a thing would not be very difficult to make so I may go ahead with that as a software distribution plan, unless I think of some horrible drawback to doing it that way.

The wummer

2008-05-24T02:24:00.000-07:00

The core of the Web Updater program is complete; it can now connect to web servers, obtain wum.xml files, validate them against a public wum schema, perform a differential check against the locally installed files on the client and download the obsolete/missing files. After downloading it can now replace the files on the client via decompression (if the wummer tool had compressed them when publishing) or, just renaming them into place.

My "wummer" publishing tool is finished, save a few UI nuances, and so together they have created a functioning publish/update circuit.

The Web Updater still needs a few more things; certain disaster recovery scenarios still must be accounted for, like if it can't access files it's trying to update or it's connection drops while downloading. It also still needs the ability to accept command line arguments when it runs, and finally it needs the ability to re-launch the target application it's updated. So I guess it's about 85% complete.

Here it is, dutifully "updating" a bunch of nonsense files. I added the little treeview to it this evening, just for fun.

wum

2008-05-20T01:12:00.000-07:00

So the XNA Content Assistant is largely finished and I wanted to distribute it using some kind of web update model, to make it easier for all of you to update the Assistant in the future. So I built a little update functionality into the Assistant under the Visual Studio ClickOnce model.

ClickOnce is really neat and very easy to use, but unfortunately for the XNA Content Assistant it is unacceptable. The problem is that you can't effectively launch a ClickOnce application from another program e.g. via Process.Start while passing command line arguments. At best, you can submit a query string to a web-based application, but having the Assistant be entirely web based is not acceptable. The Content Assistant must be installed on the local machine and must be callable via command line with arguments.

Therefore I abandoned the ClickOnce model and for the past couple days I've been crafting a web update system. This is something I will require anyway, to allow updates to my future XNA applications, so it's somewhat of an inevitable project.

The Web Updater does its best to be somewhat generic; in a nutshell it just needs to know the URL of your application's "wum.xml" file (Web Updater Manifest), a simple xml file which describes the current files available on the update server (name, size, last update, etc). The Web Updater grabs the wum and checks it against whatever application it's updating on the local machine, and updates files as necessary.

To that end, now I'm in the process of writing a companion tool for wum publishing called the Wummer. The Wummer is for developers, we point it at our Release folder (or, whatever you want to publish), and the Wummer uses an IO.CompressionStream to publish your application to your web host as .gz files, creating the wum.xml file for you (an otherwise tedious task).

So I've been pretty busy working on all this lately, juggling work and 3 of my own little mini-projects! I believe these will all be helpful tools though and I hope to have them finished up pretty soon.

XNA Content Assistant

2008-05-14T16:46:00.000-07:00

The logistics of how content gets built in the VB template will change when GS 3.0 is released. Rather than hard-code all of the content building specifics into the VBContentManager class, this functionality has been moved into a stand-alone application, which will act as a bridge between a non-Game Studio project and the Content Pipeline. This application is called the XNA Content Assistant, and is a Windows form application with a graphical interface. However, it also supports being called from the command line in an invisible mode.

I'm currently putting the XNA Content Assistant through beta, naturally I want to debug such an important component thoroughly. It is functional at this time, and so here's a preview of what it looks like, and what it does:

You start out by opening your game's Visual Studio or Visual Express project file. (when running from a command line, you would supply this as an argument)

Based upon the location and contents of the specified project file, the XNA Content Assistant will automatically determine where your content folder is (even if you did not name it "content"). It will then automatically determine which XNA framework version your game is programmed against. The XNA Content Assistant understands how to build content for Game Studio Express (1.0 Refresh) projects, Game Studio 2.0, and Game Studio 3.0 projects created in either VB or C# in Visual Studio 2005, 2008, and the Express editions.

On the GUI, we can see the Assistant has successfully harvested content from my "Timeclock" application, and I am proceeding to select a platform (this would be the 2nd and final parameter you would need to supply via command line)

And lastly when we execute the build process, we can see that MSBuild's output is integrated nicely into the Assistant's UI, to help troubleshoot build issues such as missing fonts, etc. It also exports a log and a copy of the content project submited to MSBuild in your project's folder for reference.

As future XNA versions are released, XNA Content Assistant will be updated and your existing template can simply continue to utilize the updated Assistant, rather than requiring code changes to the template itself (i.e., the VBContentManager class, which will be largely obviated by the Assistant).

XNA 3.0 CTP

2008-05-10T12:47:00.000-07:00

The XNA/GS 3.0 CTP is out and I'm in the process of updating the VBContentManager in preparation for the official release.

XNA 3.0 content processing expects to use the .NET Framework v3.5 edition of MSBuild. For those not interested or ready to move to XNA 3.0, XNA 2.0 compatibility will be retained in the VBContentManager.

To that end, the GS 3.0 release will mark a small change in how the VBContentManager works. A version enumeration is now required by the VBContentManager class, and moving forward, the VBContentManager will be augmented with new version support (rather than replaced wholesale) so that future editions of the VBContentManager can target prior XNA versions (dating back to 2.0). Just pass in which XNA version you're targeting, and it will process your content accordingly.

The VBContentManager currently available for download was never updated with functional, XACT-based audio importing. I do have this working in my "production" VBContentManager, and as part of the 3.0 update I will include this for backward compatibility with 2.0's XACT-based audio. And of course the new audio importing for 3.0 will be available as well, which is what I'm working on now.

Microsoft.VisualBaggage

2008-05-10T00:22:00.000-07:00

Here's an interesting article on Paul Vick's blog (not exactly new, but it was to me): VB Runtime agility, Orcas and new platforms.

Touring

2008-04-20T23:02:00.000-07:00

Someone asked the creator's club a question about writing a Mille Bornes game. I remember liking that game as a kid, but the first version of it I played was the older more simplistic game of Touring.

I've been thinking of putting together a simple game to test the XNAMachine engine with, something a little more simple than Star Maze just to see what it's like to build something with it, and this seemed like the perfect thing. So rather than completely rip off that guy's idea of making Mille Bornes, I've been putting together a Touring card game (ok, so I'm mostly ripping off his idea...)

Making a 1-player Touring game would be a little "too easy" I think, so I'm building both server & client programs to allow for multi-player sessions of Touring to be started by whomever wants to play. If the engine proves to be a decent performer for this application I'll begin the process of "porting" what's completed of my Star Maze project over to the XNAMachine engine.

At this point I've got most of the object structure done for Touring, the game logic is easy, and so now I'm writing the network code for the server. There are no movement predictions or tight synchronizations to worry about here, the server & client really just need to relay simple commands & acknowledgments back & forth so it's a really good starting place for network code I think.

At the risk of enduring a copyright violation lecture I've obtained some rather pristine editions of old Touring games from eBay as texture sources, and I've been browsing around a neat little website called soundsnap, which has a lot of nice free sounds & music loops.

This is something of an unexpected diversion but I guess that's typical; the hardest part about programming is finishing something, right? No worries...

Vacation 2

2008-04-08T14:48:00.000-07:00

I'm in Japan this week. I don't speak or read Japanese so sometimes it feels a little crazy, but at least we haven't gotten lost yet. The train system here was a challenge at first (especially to a foreigner from a small US town without any serious public transport in the first place). But a lot of things are in English of course so it's not so bad. Today we're in Kawaguchi which is a small country town just north of Mt. Fuji. Just hanging out here, it's like a mountain resort type of place.

I wanted to get some good work done on the XNAMachine engine on the 11 hour flight, but after a couple hours I realized I didn't have the right power adapter for the plane's weird DC plug.

The XNAMachine

2008-04-03T01:00:00.000-07:00

I'm continuing to plug away at my new engine here and there, mainly by jotting ideas down into classes & interfaces, and then shaping them into workable objects. It's kind of like throwing lumps of clay down into the IDE & then shaping them into recognizable things. It's probably the world's most inefficient way to design something but I'm having fun with it.

The XNAMachine (my obvious name for this new engine) has grown into 5 primary categories which I've split into as many Namespaces within the project. The primary namespaces are, in no particular order

Core - this contains classes such as the base Game class, the VBContentManager, a static math helper class, all the primary singleton stuff

Objects - the base game object is defined in here along with a base game component for including objects in the XNA Game's components collection. Future items in here will be other common bases; screen, camera, and some sort of base spacial partitioning class either a grid or a quadtree or both

Augments - a base class + various primitive implementations of game object expansion pieces

Automations - this is the bit I've been working on the past couple of days, it's a system of rudimentary classes that primarily hold information which can be used to modify various properties of augments. Automations are intended to be Augments, but it's such a big category of "stuff" that it got it's own namespace. An example of an Automation Augment would be, for example, if you have a Transformation augment attached to a game object, the game object gains the ability to be transformed by a matrix. You can then attach an automation augment to that game object, specify which element of the transformation object you want the automate, and this will allow for "scripting" various activities over pre-defined times & destinations. I have a system like this now, it's just not nearly half as elegant as this revision will hopefully be

Augment Update Services - the way I'm experimenting/planning to update augments is to create a collection of service implementations that perform various tasks, each built to accept a single augment at a time. Every single augment will have a reference to the service it uses to update itself, so when an augment wants to update, it simply passes itself in to it's service reference.

So that's kind of the gist of it so far, and I'm getting reasonably close to finishing up the classes in the Automation Namespace, but my wife is hardcore giving me the stink-eye so I better turn my laptop off before I get busted.

Composition

2008-03-23T14:05:00.000-07:00

Well I've been bitten by the Composition bug. In a big way. So to satiate my newfound curiosity, I must confess I've been spending time on an experimental clone of my 2D engine using a technique of dynamic Composition.

The Composition version of the engine is based around a single "Game Object" class. This class is effectively nothing more than a collection of IAugmentation interfaces.

In my existing engine, the Sprite class has become quite large; what's more, not all Sprites always utilize every member and feature of the class. By partitioning this class into several different stand-alone "mini-classes" (all of which implement the IAugmentation interface), these mini-classes become "Augmentations". From this, one can start with an empty game object and build it into anything by adding the appropriate behavioral and/or data Augmentations to it's IAugmentation collection.

What's seductive about the Composition model is that this building process is not significantly different between design time and run time. To me this is the primary advantage of using Composition over Inheritance, which AFAIK is largely static at run time. I.e., once you define your class that inherits from <whatever>, you're stuck with that at run time. With Composition, you could simply remove one Augment and add another.

My only concern with what I've developed so far is that dictionary lookups are becoming somewhat frequent - i.e., I find myself querying whether or not a game object has been augmented with <augmentX>, and if so, retrieving that augment for use. These queries don't exist so much in the Inheritance model, and this aspect may require some fine-tuning as things get progressively more complex. But, we shall see.

Fun stuff!

PointAt v2.0

2008-03-11T21:41:00.000-07:00

In Tutorial 6 (The PointAt method), I suggested a way one sprite can "point" at another, given totally arbitrary tree nesting / matrix transform between the two objects. The code was:

''' <summary>
''' Point one sprite's origin at another sprite's origin
''' </summary>
Public Sub PointAt(ByVal thePointer As Sprite, ByVal theTarget As Sprite)

Dim objTargetWorldPosition As Vector2

If theTarget.Parent IsNot Nothing Then
objTargetWorldPosition = Vector2.Transform(theTarget.Location, theTarget.Parent.DrawMatrix)
Else
objTargetWorldPosition = theTarget.Location
End If

thePointer.Rotation = 0

With Vector2.Transform(objTargetWorldPosition, Matrix.Invert(thePointer.DrawMatrix)) - thePointer.Origin

thePointer.Rotation = CSng(Math.Atan2(.Y, .X) + (Math.PI / 2))

End With

End Sub

And that works, but I realized an alternative way to solve the same problem today. I haven't compared the raw performance of this new way vs. the other, so I can't say if it's faster... but I suspect it might be.

''' <summary>
''' Gets the radian between two sprite origins
''' </summary>
Public Function PointAt(ByVal thePointer As Sprite, ByVal theTarget As Sprite) As Single

Dim a, b, c As Vector2

Vector2.Transform(thePointer.Origin, thePointer.DrawMatrix, a)
Vector2.Transform(theTarget.Origin, theTarget.DrawMatrix, b)

c = b - a

Return CSng(Math.Atan2(c.Y, c.X) + MathHelper.PiOver2)

End Function

I made it a function that returns the radian value, so that you can do with it whatever you so choose - either assign it to the Rotation value of thePointer, or just query the angle between two things for whatever reason.

Uninventing some wheels - Stacks & Dictionaries

2008-03-07T12:37:00.001-08:00

You know the "Hashtable(Of Type)" class used by the VBContentManager?

There's actually a generic Dictionary class in the .NET framework that serves the same purpose.

The Dictionary class provides two type predicates, one for the key and one for the value, whereas my Hashtable class simply presumes the key to be of type String. We could do away with the Hashtable(Of Type) class all together, and simply start using Dictionaries.

The other thing I started messing with is the generic Stack class. My current ScreenManager class keeps track of Screen order via some rather sloppy and unnecessary list manipulation. But all of that can be done away with and replaced with a Stack(Of Screen).

Stacks are a very convenient way to maintain Screen order within a ScreenManager, because there is a natural synchronization between the inherent nature of Stacks and the way we display Screens.

At the beginning of the program, push Screen1 onto the Stack. When you transition away from that Screen1 to Screen47, pop the Stack (removing Screen1) and push Screen47 onto the Stack. If you want to display Screen2 over Screen47, simply push Screen2 onto the Stack. Now Screen2 is above Screen47, which is exactly what we wanted to display. When Screen2 is finished, pop it off the Stack, and Screen47 resumes the top position. It's a very convenient way to maintain the order of Screens, and I will employ this technique in the Screen tutorial.

Obligatory update

2008-03-05T18:21:00.000-08:00

I've been busier than usual for a while, doing some work on my car (painting wheels - my garage looks, and smells, like a paint shop) and also I'm going through a crunch phase at work, making a great big middle-tier ADO.NET engine which will really expedite creation of business objects & UIs, which is rather cool.

But anyway, I'll be up to my eyeballs in that for another week or so, after that I can get back to continuing with more XNA stuff.

Tutorial schedule

2008-02-25T21:12:00.000-08:00

While I've rambled on about Screens, Scenes and Cameras I haven't really put up any tutorials in 4 months since "Tutorial 8" and I'm getting a little bit ahead of myself.

So here's a rough TODO list, sort of making this for myself, but it's what I want to cover in detail before I get too off track here:

Screens - a proper introduction to Screens, adding a base Screen class to the Engine

Screen Manager - a simple little tool to help shuffle Screens around

Scenes - like a Screen, but bigger - huge, even. I may rename Scenes to... "Worlds" or "Levels" or, something. Screens and Scenes are conceptually similar with similar names, kind of has an inherent confusion built into it

SceneCameras - this will be the in-depth tutorial on what I've been doing lately. Cameras physically exist on Screens, and are used to peek inside of Scenes

Automation - I have an automation system written, which I can actually take the opportunity to improve upon a little bit as I write it up here on the blog, which allows you to "script" change in game object properties over time. Things like movement, rotation, alpha (fade in/out), changing texture, scaling, stuff like that. This is a very useful for doing UI-ish tasks, like Screen transitions, but I use it for all sorts of other stuff

SceneGraph? QuadTrees? - In a big Scene with lots and lots of game objects, for efficiency sake we will need some way to make quick collision checks between potentially thousands of objects. If a bullet is flying through a level of your game with 5,000 potential objects it could strike, you don't want to check for collision with all 5,000 objects if you can help it. I haven't tackled this yet so it's coming up next on my R&D list

AI - Another R&D project

Level Generation - I've been reading up a little on algorithms for creating random mazes, it's kind of interesting and thankfully not too complicated. I'll use it in the Star Maze project

Sound - I'm assuming this won't be too difficult to implement (famous last words)

Star Maze - take everything covered and use it to re-create a classic 2D game

And beyond that... - like most wanna-be game hobbyists I have an ambitious vaporware project I want to turn into a reality. But first I'll create Star Maze, get some good practice there, and if all goes well we can start to tinker around with other things

So that's the plan. There's no ETA :)

www.xnamachine.com

2008-02-25T11:37:00.000-08:00

xnamachine.blogspot.com should now redirect you to www.xnamachine.com. www.xnamachine.com is now the "official" address.

Nothing else is different, I just decided a more succinct name would be cool.

Well, ok I changed the layout just a little bit... just for fun (I don't know how IE-friendly it is yet). I noticed my formatted code posts don't show up right in IE, so that's kind of a bummer. I'll try to fix that... eventually.

SceneCamera class nears completion

2008-02-17T05:35:00.000-08:00

Here is a video demonstrating the features of the SceneCamera class as it nears completion:

direct link

All SceneCameras will by default perform a translation of the subject (e.g., follow it's X/Y position), and all SceneCameras have the ability to scale (zoom in/out). In addition to these two default behaviors there are two optional properties to specify camera style.

Rotate with subject: If this property is True, it causes the SceneCamera to lock rotation with its subject. This creates a camera style whereby the subject appears fixed and the entire Scene rotates. In the video, the SceneCamera on the right side rotates with it's subject. The SceneCamera on the left side has this property set to False, creating an opposite effect (the Scene appears fixed and the subject rotates).

Clamp to Scene: If this property is True, the SceneCamera is not permitted to exit the perimeter of the Scene. In the video, the left side has this property set to True, and it is False on the right side.

Finally, there is a 3rd SceneCamera moving around the perimeter of the Screen to demonstrate the "game object" nature of SceneCameras. Like a Sprite, a SceneCamera can easily be any size, and can move around the Screen without disturbing it's ability to view a subject.

What I will be adding next is a property for Chase lag, so the SceneCamera can be given a variable amount of imprecision when following its subject. Once this is done, the SceneCamera class should be adequately functional.

How to modify the VBContentManager to load other content types

2008-02-06T11:53:00.000-08:00

Here's an example of how you can teach the VBContentManager to load other content types.

This sample code below shows you what to add (in bold) in order to load .fbx models. Please note that to actually display a 3D model, you'll have to write your own 3D rendering code - 3D is out of scope of my 2D engine blog. This just demonstrates how you can teach the VBContentManager to load other content types, the example just happens to use .fbx models.

Public Class VBContentManager
Inherits ContentManager

'Add a Hashtable(Of Model) called Modles, to
'give your models a place to arrive in memory...

Public Models As Hashtable(Of Model)

'Add "intDupeModel" variable to this series...
'This allows the VBContentManager to append a
'unique number to any duplicate filenames it
'may encounter when loading models from disk

Private intDupeSound, intDupeTexture, intDupeFont, intDupeEffect, intDupeModel As Integer

'Add "Models" to the ContentTypes enumeration,
'and make it the next available value

Public Enum ContentTypes
Textures = 0
Fonts = 1
Sounds = 2
Effects = 3
Models = 4
End Enum

'Add "FbxImporter" to the ImporterName enumeration
'Make sure it has the same value as Models in the
'ContentTypes enumeration...

Private Enum ImporterName
TextureImporter = 0
FontDescriptionImporter = 1
XactImporter = 2
EffectImporter = 3
FbxImporter = 4
End Enum

'Add "ModelProcessor" to the ProcessorName enumeration
'Make sure it has the same value as Models in the
'ContentTypes enumeration.

Private Enum ProcessorName
TextureProcessor = 0
FontDescriptionProcessor = 1
XactProcessor = 2
EffectProcessor = 3
ModelProcessor = 4
End Enum

'In Public Sub New, add code to instantiate the Models hashtable
'you added above

Public Sub New(ByVal ServiceProvider As IServiceProvider, ByVal ContentFolder As String)

'(existing code omitted)

'Add code to instantiate the models hashtable

Me.Models = New Hashtable(Of Model)

End Sub

'In LoadAllContent, add a Try block for Model importing in the
'Catch block for Effects, and move the unknown file handler
'to the catch block for attempted Model load

Public Sub LoadAllContent()

'(existing code omitted)

Try

'Effect?

With file.FullName.ToLower
Me.Effects.Add(file.Name.Replace(file.Extension, ""), Me.Load(Of Effect)(.Replace(Me.strExecutingFolder & "\", "").Replace(file.Extension, "")))
End With

'Instead of giving up at this point, catch this as notAnEffect,
'and add 1 more check to see if the file is a model...

Catch notAnEffect As Exception

Try

'Model?

With file.FullName.ToLower
Me.Models.Add(file.Name.Replace(file.Extension, ""), Me.Load(Of Model)(.Replace(Me.strExecutingFolder & "\", "").Replace(file.Extension, "")))
End With

'If that doesn't work, then I've run out of things
'to try, so...

Catch unknown As Exception
strUnknownFiles &= vbCrLf & file.FullName
End Try

End Try

'(existing code omitted)

End Sub

'In HarvestContent, add code to search for .fbx files. Also,
'I'm going to add code to look for .tga texture files as well
'in case I need those too.

Private Sub HarvestContent()

'(existing code omitted)

'Add code to look for .tga files...

For Each texture As System.IO.FileInfo In objRoot.GetFiles("*.tga", IO.SearchOption.AllDirectories)
If Me.objContent.Contains(New ContentFile(ContentTypes.Textures, texture, texture.Name.Replace(texture.Extension, ""))) Then
Me.intDupeTexture += 1
Me.objContent.Add(New ContentFile(ContentTypes.Textures, texture, texture.Name.Replace(texture.Extension, "") & Me.intDupeTexture.ToString))
Else
Me.objContent.Add(New ContentFile(ContentTypes.Textures, texture, texture.Name.Replace(texture.Extension, "")))
End If
Next

'Add code to look for .fbx files... these are similar
'code blocks, just change the ContentType enumeration and the
'extension we want to look for from all the existing ones in
'this sub

For Each model As System.IO.FileInfo In objRoot.GetFiles("*.fbx", IO.SearchOption.AllDirectories)
If Me.objContent.Contains(New ContentFile(ContentTypes.Models, model, model.Name.Replace(model.Extension, ""))) Then
Me.intDupeModel += 1
Me.objContent.Add(New ContentFile(ContentTypes.Models, model, model.Name.Replace(model.Extension, "") & Me.intDupeModel.ToString))
Else
Me.objContent.Add(New ContentFile(ContentTypes.Models, model, model.Name.Replace(model.Extension, "")))
End If
Next

End Sub

The VBContentManager code should now be able to import .fbx files. Create a folder called Models in your Content folder in the solution explorer, and put .fbx files in there:

Here I copied all the models (and textures) from the SpaceWar example, and they now compile & load into the Models hashtable of the VBContentManager.

SceneCamera

2008-02-02T02:19:00.000-08:00

I got a chance to get a little more camera work done over the past couple days. What I've made is a 2D camera which is a game object (as such it can be placed onto a Screen just like anything else). These cameras point at "Scenes", which are similar conceptually to Screens, but unlike Screens a Scene is not meant to "draw itself", it just sits in memory. You use a SceneCamera to view a subset of the Scene.

In this demonstration a Scene exists in memory, it's a simple repeating tile grid w/ a user-controlled ship. Multiple SceneCameras are implemented to demonstrate the concept of viewing a Scene through a SceneCamera. All of the SceneCameras are pointing at the same ship in the same Scene.

Pardon the obnoxious music, I was just having fun with Premiere:

direct link

It's still pretty beta-ish but it basically works, I'll do a write up after it becomes more properly solidified.

Tell Microsoft you want VB support for GS

2008-01-28T18:53:00.000-08:00

Microsoft is offering a survey to XNA/Game Studio users for feedback on the XNA/Game Studio product. There are one or two questions on the survey which give you the opportunity to suggest the support of other, non-C# .NET languages. If you would like Game Studio to support VB, you should fill out the survey and mention it.

Screens & the Screen Manager

2008-01-16T11:39:00.001-08:00

Screens

Screens are what I've been using, prior to implementing Cameras. So they may change. Here's how it all works now, and while the names may change in the future, the basic concept will probably remain mostly the same.

In Tutorial 7 we defined custom game objects as separate classes in our project. In doing so we abstracted a lot of detail out of our game class; not only the construction of the little ship & turret tree, but also the Update code that moved a ship back and forth across the screen. The primary focus on putting these things into a Ship class was to make them readily reusable - but did you notice it really helped tidy up the Game class? In part there is a philosophical benefit to abstraction in that it simply helps to keep things looking tidy, if you're into that sort of thing.

In the previous article A forest for your trees, we simulated this strategy somewhat in a hypothetical Game class that defined some make-believe game objects as members:

Public Class MyGameTutorial
Inherits Game

'Main menu stuff
Private objNewGame As NewGame
Private objGraphics As Graphics
Private objQuit As Quit
Private objContinue As Sprite

'Game stuff
Private objShip1 As BadGuyShip
Private objShip2 As BadGuyShip
Private objPlayer As PlayerShip
Private objHighScore As Sprite

'Initialization, etc.

End Sub

We ended up with 8 game objects or trees, like so:

And in theory you would manage (update/draw) all 8 of them directly from within the game class. That's not too bad, but, half of these objects are meant for the main menu game state, and the other half belong to the actual "playing the game" game state. The only way to know which ones even belong to which state is to read the comments above the member declarations! I'm no coding guru, but even I know that's turning into a sketchy situation.

If we take the time to define custom Screens, just like we defined custom game objects in Tutorial 7, we can perform yet another level of abstraction that will not only help organize us, and help us maintain game state, it will again make our game class a more tidy, simple thing to work with.

Tutorial 7 also walked us through creating custom game objects by deriving new classes from Sprite. You do something like this...

Public Class MenuObject
Inherits Sprite

Private ChildOption1 As Sprite
Private ChildOption2 As Sprite

Public Sub New()

Me.ChildOption1 = New Sprite()
Me.ChildOption2 = New Sprite()

Me.AddChild(ChildOption1)
Me.AddChild(ChildOption2)

End Sub

'Update, Draw etc.

End Sub

We can do the very same thing to create custom Screen objects from our base Screen class. Let's build some hypothetical screens to abstract those 8 game objects into 2 screens representing their respective states. First here's a pseudo Main Menu Screen class:

Public Class MainMenuScreen
Inherits Screen

Private NewGameChoice As MenuObject
Private ContinueChoice As Sprite
Private GraphicSettings As MenuObject
Private Quit As MenuObject

Public Sub New()

Me.NewGameChoice = New MenuObject()
Me.ContinueChoice = New MenuObject()
Me.GraphicSettings = New MenuObject()
Me.Quit = New MenuObject()

Me.AddChild(NewGameChoice)
Me.AddChild(ContinueChoice)
Me.AddChild(GraphicSettings)
Me.AddChild(Quit)

End Sub

'Update, Draw etc.

End Sub

It looks like this:

Now how about a pseudo game screen class:

Public Class TheGameItself
Inherits Screen

Private Ship1 As BadGuyShip
Private Ship2 As BadGuyShip
Private Player As PlayerShip
Private HighScore As Sprite

Public Sub New()

Me.Ship1 = New BadGuyShip()
Me.Ship2 = New BadGuyShip()
Me.Player = New PlayerShip()
Me.HighScore = New Sprite()

Me.AddChild(Ship1)
Me.AddChild(Ship2)
Me.AddChild(Player)
Me.AddChild(HighScore)

End Sub

'Update, Draw etc.

End Sub

There we go:

Nevermind the naming mis-match on the diagram; the "game" node represents the "TheGameItself".

Now instead of adding 8 game objects to our game class and organizing them with code comments, we can use two Screens with names that convey their purpose:

Public Class MyGameTutorial
Inherits Game

Private MainMenu As MainMenuScreen
Private TheGameItself As GameScreen

'Initialization, etc.

End Sub

This gains us a few benefits. With the addition of a Screen node, we can now transform (move rotate scale etc) an entire Screen of "stuff", be it the main menu or the game itself, something we couldn't do easily prior to implementing Screens. This also gives us something of a "choke point" for state management - if we want to draw the Main Menu, we just tell the main menu screen to .Update or .Draw and thanks to the underlying Sprite class, the rest more or less runs itself. All our Game really has to worry about now is calling the Update & Draw methods of whichever Screen(s) are appropriate for the current Game State.

XNA.Framework.Game.Components and the ScreenManager

This has all been very cute, but it seems that all we've done is shuffled the question of which Game Objects to draw to which Screens to draw. What we've done so far helps organize us, but it hasn't helped us answered that important question.

You may be pleased to know we can eliminate the need to ask this question all together. We can simply update/draw whichever Screens happen to be Enabled and/or Visible at the moment. For this, we will borrow upon the Components member of the XNA.Framework.Game class.

In brief, XNA.Framework.Game has a built-in Components collection. This collection is meant to hold objects which derive from GameComponent and/or DrawableGameComponent, but in truth can hold any object which implements the IGameComponent/IUpdateable/IDrawable interface(s). The Game.Components collection is handy because, similar to how our Sprite class was created to automatically draw & update it's children (if any), XNA.Framework.Game understands that if it finds anything in it's Components collection, it should Update and Draw whatever it finds in there. There are a few useful features of this which we're going to borrow upon:

The IUpdateable and IDrawable interfaces have UpdateOrder and DrawOrder properties, respectively. When XNA.Framework.Game processes it's Components collection, it uses these values to determine which objects get Updated first and which ones get Drawn first
The IUpdateable interface has an Enabled property (Boolean). The Game class will only Update components where Enabled=True
Similar to Enabled, the IDrawable interface has a Visible property and only objects which are Visible will be Drawn

This is a convenient little system to plug our Screens into.

Now you may have noticed some Interfaces being included in the base Screen class in the previous article, let's get another look at that:

Public MustInherit Class Screen
Inherits Sprite
Implements IGameComponent
Implements IDrawable
Implements IUpdateable

'etc

End Class

Implementing these interfaces allows our Screen class to be "registered" or added to the Game.Component collection. Alternatively, you could be dealing with classes that inherit from GameComponent or DrawableGameComponent, which Implement these interfaces for you. Since our Screen inherits from Sprite, this hasn't been done for us so I'll just have the Screen class implement the necessary interfaces.

The Screen Manager class is going to be our middle-man between our game code and the Screens stored in the Game.Components collection. The Screen Manager is going to add our Screens to the Collection for us, set DrawOrder for us, set Enabled & Visible for us, all that stuff. We'll just use the "Add", "Load" and "Unload" methods of the Screen Manager, for the most part. Here's the class, which I'll post for your amusement. If I get around to making a video about this I can go into more detail:

Public Class ScreenManager

Public Shared Game As GameEngine
Public Shared Root As Root
Private Shared NameToGameID As New Hashtable(Of Integer)
Private Shared GameIDArrangement As New List(Of Integer)

Public Shared ReadOnly Property GetScreen(ByVal ScreenName As String) As Screen
Get
If NameToGameID.Contains(ScreenName) Then
Return CType(Game.Components(NameToGameID(ScreenName)), Screen)
Else
Return Nothing
End If
End Get
End Property

Public Shared ReadOnly Property CurrentScreen() As Screen
Get
Dim objRet As Screen = Nothing
For intX As Integer = GameIDArrangement.Count - 1 To 0 Step -1
If CType(Game.Components(GameIDArrangement(intX)), Screen).Enabled Then
objRet = CType(Game.Components(GameIDArrangement(intX)), Screen)
Exit For
End If
Next
Return objRet
End Get
End Property

Public Shared ReadOnly Property IsScreen(ByVal ScreenName As String) As Boolean
Get
Return NameToGameID.Contains(ScreenName)
End Get
End Property

Public Shared Function CreateRoot(ByVal YourGame As GameEngine, ByVal objRootSize As Vector2, Optional ByVal strTextureName As String = "", Optional ByVal strTextureNameItem As String = "") As Root

Dim objRetVal As Root

'make a new root object of the specified size at 0,0
objRetVal = New Root(YourGame, Nothing, "root", True, True, strTextureName, strTextureNameItem)
objRetVal.Size = objRootSize

Return objRetVal

End Function

''' <summary>
''' Adds a screen to the screen manager. Adds to the top of the stack by default, but does not alter Enabled or Visible
''' </summary>
''' <param name="obj"></param>
''' <remarks></remarks>
Public Shared Sub AddScreen(ByVal obj As Screen)

Root.AddScreen(obj)
Game.Components.Add(obj)
NameToGameID.Add(obj.Name, Game.Components.Count - 1)
GameIDArrangement.Add(Game.Components.Count - 1)
obj.Initialize()

End Sub

''' <summary>
''' Sends the specified screen to the bottom of the stack and excludes it from the update/draw loop
''' </summary>
''' <remarks></remarks>
Public Overloads Shared Sub Unload(ByVal intScreenID As Integer)

'Remove this screenID the update/draw loop
With CType(Game.Components(intScreenID), Screen)

.SetVisiblity(False)
.SetEnabled(False)

.IsModal = False

End With

End Sub

''' <summary>
''' Brings the specified screen to the front of the stack and includes it in the update/draw loop
''' </summary>
''' <remarks></remarks>
Public Overloads Shared Sub Load(ByVal intScreenID As Integer, ByVal Modal As Boolean, Optional ByVal TransitionIn As Boolean = True)

Dim ModalScreen As Screen
Dim tex As Texture

'Bring to the front of the stack
ScreenManager.BringToFront(intScreenID)

'that changes the gameIDArrangement (this screenID is now at .Count-1 and all others have been pushed -1)

'Include this screenID the update/draw loop

With CType(Game.Components(intScreenID), Screen)

.SetVisiblity(True)
.SetEnabled(True)

'Set modal state
.IsModal = Modal

If TransitionIn Then
.TransitionIn()
End If

End With

'Now if we have just shown something modal, we need to stay in a loop here so the calling code
'can resume when the screen gets hidden. For as long as we are modal, this loop continues

ModalScreen = CType(Game.Components(GameIDArrangement(GameIDArrangement.Count - 1)), Screen)

If ModalScreen.IsModal Then

While ModalScreen.IsModal
Game.Tick()
End While

Game.GraphicsDevice.Textures(0) = tex

End If

End Sub

''' <summary>
''' Brings the screen to the top of the render stack. Does not change Enabled or Visible
''' </summary>
''' <remarks></remarks>
Public Overloads Shared Sub BringToFront(ByVal intScreenID As Integer)

'If this screen is already in the show stack, remove it
If GameIDArrangement.Contains(intScreenID) Then
GameIDArrangement.Remove(intScreenID)
End If

'Put this screen at the top of the show stack
GameIDArrangement.Add(intScreenID)

ScreenManager.SetDrawOrders()

End Sub

''' <summary>
''' Syncs the draw orders of the screens with their positions in the show stack
''' </summary>
''' <remarks></remarks>
Private Shared Sub SetDrawOrders()
For intX As Integer = 0 To GameIDArrangement.Count - 1
CType(Game.Components(GameIDArrangement(intX)), Screen).SetDrawOrder(intX)
Next
End Sub

''' <summary>
''' Sends the screen to the bottom of the render stack
''' </summary>
''' <remarks></remarks>
Public Overloads Shared Sub SendToBack(ByVal intScreenID As Integer)

'If this screen is already in the show stack, remove it
If GameIDArrangement.Contains(intScreenID) Then
GameIDArrangement.Remove(intScreenID)
End If

'Put this screen at the bottom of the show stack
GameIDArrangement.Insert(0, intScreenID)

ScreenManager.SetDrawOrders()

End Sub

Public Overloads Shared Sub Load(ByVal ScreenName As String, ByVal Modal As Boolean, Optional ByVal TransitionIn As Boolean = True)
Load(NameToGameID(ScreenName), Modal, TransitionIn)
End Sub

Public Overloads Shared Sub Unload(ByVal ScreenName As String)
Unload(NameToGameID(ScreenName))
End Sub

Public Overloads Shared Sub BringToFront(ByVal ScreenName As String)
BringToFront(NameToGameID(ScreenName))
End Sub

Public Overloads Shared Sub SendToBack(ByVal ScreenName As String)
SendToBack(NameToGameID(ScreenName))
End Sub

End Class

You'll see some funky oddities in there but it's not too scary.

Let's sum this situation up here before I get carpel tunnel:

Sprites are the building blocks - they contain the code to invoke the Matrix cascade and contain the code necessary to facilitate the creation of tree nodes.

Game Objects are reusable custom Sprite classes, typically with their own custom Update code and usually contain other child sprites to create small trees.

Screens are the building blocks of State management. They derive from Sprite but typically don't require a texture, per se. They mainly exist to act as parent nodes so that we can graft related Game Objects and Sprites together into a Game State context.

We use the Screen Manager to Register screens with the Component collection. We use the "Load" and "Unload" methods of the Screen Manager to basically set the DrawOrder, Enabled and Visible properties of Screens, which in turn causes the Component collection to change their order, start/stop Updating, or start/stop Drawing them.

Game State is defined by whatever the state of our Enabled/Visible properties are on the Screens in the component collection - when a game starts, it registers it's Screens through the Screen Manager and Loads the Main Menu Screen. The Game State simply remains on the Main Menu Screen until changed, leaving no real need to question Game State (we simply allow all Enabled/Visible components in the Game.Component collection to Update & Draw as per their Enabled/Visible properties).

Once you've got this in place and you make a game, add some screens with the screen manager and Load one, you essentially Update and Draw your game by calling MyBase.Update and MyBase.Draw from your game class. This will trigger the underlying XNA.Framework.Game to Draw & Update, which will cause it to process it's Components collection where your Screens live. In the end, you remove all Update and Draw calls to custom objects & screens from your game class and just let the underlying XNA Game process it's Components collection, using the Screen Manager to control which Screens in the collection end up getting Updated & Drawn.

My apologies for the verbosity, I guess it's a lot to cover. There's still more to come...

A forest for your trees

2008-01-14T13:28:00.000-08:00

Trees

The "parent/child" relationship afforded by the Sprite class can be thought of as an unordered tree structure:

In Star Maze, I've got a game object called PlayerShip. Like all game objects it inherits from Sprite:

Public Class PlayerShip
Inherits Sprite
'Update, Draw, etc.
End Class

Considering Sprites to be tree nodes, any class inheriting from Sprite (including PlayerShip) becomes a valid tree node and can be diagrammed as such:

It's not much to look at on it's own so let's use the AddChild method of the PlayerShip to attach a Turret sprite:

PlayerShip.AddChild(Turret)

The thrusters for the player's ship are separate game objects. Like the PlayerShip (and like all game objects we'll make with this engine), a Thruster is another game object derived from Sprite:

Public Class Thruster
Inherits Sprite
'Update, Draw, etc.
End Class

We'll add a couple afterburner sprites to the Thruster,

Thruster.AddChild(YellowAfterburner)
Thruster.AddChild(BlueAfterburner)

and here's the resultant tree diagram for the Thruster object:

Now we've got two different game objects, both of which inherit from Sprite: "Ship" and "Thruster". You can also interpret this as having two sprite trees: the PlayerShip tree and the Thruster tree:

So far in the tutorials we've been using the AddChild method to append simple "leaf" nodes to sprites, but we can also do something slightly more profound, and that is to graft one entire tree onto another:

PlayerShip.AddChild(Thruster)

By adding the root node of the Thruster tree as a child of PlayerShip, the entire Thruster tree is grafted to the PlayerShip.

Thinking about Sprites as tree nodes just gives us an alternate way to describe or illustrate the "parent/child" system Sprites employ.

Trees in a Forest

The "games" created in the tutorials thus far are simple programs meant to demonstrate classes like Sprite and VBContentManager (et al). None of the tutorials have put much thought into organizational techniques yet. A typical tutorial is structured like this:

Public Class MyGameTutorial
Inherits Game

Private GameObject1 As SpriteTree1
Private GameObject2 As SpriteTree2

'etc.

Protected Overrides Sub Update()

GameObject1.Update()
GameObject2.Update()

'etc.

End Sub

Protected Overrides Sub Draw()

GameObject1.Draw()
GameObject2.Draw()

'etc.

End Sub

End Sub

There may be some game object classes defined somewhere, but the general structure so far has been to create instances of game objects as private members of the Game class, and then simply Update & Draw them from within the Game's Update and Draw methods. Which is fine for a quick tutorials dealing with a limited number of sprites and game objects. But when we eventually get to the point where we're creating an actual game, we're going to end up with a lot more than just "a limited number of sprites & game objects". Our lack of organization will turn into a problem.

Consider a tiny, theoretical game with 1 player, 2 bad guys, and a high score. This game starts up on a "main menu" with various options (new game, continue, quit, graphic settings). You can assume game object types such as BadGuyShip and PlayerShip (etc) to be irrelevant, all that matters is they derived from Sprite and are therefore valid tree structures of some kind:

Here's all of our game objects, in tree view.

When this game runs and the update cycle comes around... which game objects do we update? High Score? BadGuy #2? The "Quit" menu item? We're now having to ask ourselves a new question: "Where am I?".

There's a few ways to answer this question; you could just define a string called WhereAmI and if WhereAmI = "MainMenu" then you update/draw main menu stuff, and if WhereAmI = "PlayingTheGame" you update/draw the game stuff. And that would work, but as you add new features and possible "places" you could potentially be in the program (main menu, the game, the inventory screen, the game over screen, any of those but paused, etc) it becomes apparent that there may be better approaches.

First of all, we need to get organized. We need a better method of organization for our game objects. Knowing where we are, ergo what to update & draw, will tie closely into our organizational strategy.

Ironically enough one path to organization can be found in adding more Sprites. Not just any Sprite though; a special game object which is a bit of a Sprite hack, to tell the truth. It's called a Screen:

Public MustInherit Class Screen
Inherits Sprite
Implements IGameComponent
Implements IDrawable
Implements IUpdateable

'etc

End Class

Screens are going to help us turn this:

Into this:

Once you're comfortable with the idea of Sprites as tree nodes, this is pretty simple; you define a MainMenu Screen and then just graft all your main menu game objects via MainMenu.AddChild(). A Screen is basically a container, a bucket into which we can toss game objects; it's the forest of our trees.

Now anything we do to the Screen node - position, rotation, scale - the matrix cascade is going to apply that to every single attached child as well. This is our secret weapon that will let us make fancy screen transitions without too much of a problem.

Ok this is just the beginning of what I want to get into with this, but it's taken me 2 days just to get this much done so I'm going to publish this and start working on part 2 - the Screen Manager, which is what we'll use to show / hide / order screens, we can even use it to show screens & dialogs "modal", continuing to update and draw our game but without loosing our place in code. And then, the great paradigm shift: Cameras, which may change all of it.

Not Vacation

2008-01-03T12:32:00.000-08:00

Back from vacation and busy at work. Working on ADO stuff mostly, I've got this 5+ year project ahead of me here and, like most programs now, it's just a big sprawling database front end. I'm building some good base classes for presenting, editing, and saving SQL data, with generic concurrency checking & error handling, irrespective of database or interface. Kind of a generic data access layer "engine" (well, sort of). It'll really help automate the tedium of dealing with database records & concurrency etc., which is super important for this job (medical records, medical billing - you don't want to screw this stuff up) but the reality is, be it a database of medical records or a database of high scores, it's always the same ADO issues no matter what the columns happen to be or what the tables are named. So as per usual, the stuff I'm working on now will eventually help me somewhere else on the XNA side. Which is always cool to think about.

And speaking of XNA I've been thinking about how exactly I want to implement that 2D camera class into the engine. It's all well and good to just have camera code that "works", but now I want it to be simple to use. I want to have a Camera object abstracted to the point where I just define it, add it to the game, and "there you go".

That's going to be a little trickier than I first thought. Possible, just tricky (for me anyway). If you've read along with half the tutorials here you know the gist of the engine - game objects are in a parent/child relationship, their matrices multiply together and that's basically how stuff is put on the screen. I want Cameras to be a "game object" as well, so I can put a camera here or there just as easily as I could put a sprite here or there.

What's tricky is that you can't necessarily make a game object (like say, the player's ship) a child of a Camera. What if the ship needs to show up in 2 Cameras at once? But then, if game objects aren't children of Cameras, how then could the game object be automatically influenced by the Camera's matrix ala the parent/child matrix cascade?

I don't really know yet - but one of the fundamental changes to the engine I'm considering is to say that a Screen holds a set of game objects - for instance, the Game screen holds a players ship, the bad guys, the bullets, all that crap in it's child collection. And then, Cameras are also in the Screen's child collection. The change would be that when a Screen is told to draw, it only draws it's Cameras; and the actual drawing of objects is performed by the Camera, rather than by the Screen. So the Screen becomes something of a Camera manager... or something like that. I haven't actually sat down with it yet, this is mostly mental fragments pieced together while driving to work or falling asleep at night.

The Camera is going to be a significant component of the engine and may play a very important role in how the engine renders sprites onto the screen, so I want to take care to approach it in a somewhat methodical manner. Under the thumb of bad weather here on the US west coast, perhaps this weekend I'll have nothing better to do.

Vacation

2007-12-22T11:05:00.000-08:00

Taking a break for a week or so, going to fly down south, hang out with my in-laws. Speaking of airports & in-laws, here's a good book to read when you're bored:

"The Design of Everyday Things" is probably the best non-programming book a programmer can read.

As programmers it's our job is to construct systems that make life easier (or just more fun) for someone else. When a user launches our program for the first time, they do so without any knowledge of how it works, or any knowledge of how we expected them to use it. "The Design of Everyday Things" focuses on that moment of initial user interaction, exploring the reasons for a users "success" or "failure" with systems, both foreign and familiar. It mainly boils down to the user interface, and that's what this book is about - building user interfaces that make sense.

Using familiar things like telephones and refrigerators, the author demonstrates how common things, even simple things we have a lot of experience with, can be rendered confusing by an interface that does not convey proper usage to the user. Ever been stopped short by pushing a door that must be pulled? Sometimes stupid mistakes are just stupid mistakes, but sometimes they're actually encouraged by devices that don't naturally convey their proper use.

It's an interesting book that contains lots of useful concepts for anyone who designs anything for other people to use.

2D camera progress

2007-12-15T01:18:00.000-08:00

I got to play with this some more tonight.

direct link

Tonight, my goal was to simply make sure I could occlude tiles correctly using the technique illustrated in the 2D camera article.

A 200 x 200 tile grid of tiles is defined, each tile is 64x64 pixels. A 320x240 camera is affixed to the player's ship (you can see it's white outline in the video), and as the ship moves around, the camera position is transformed, a bounding box is created around the transformed camera, this bounding box is "snapped" to the grid, and a subset of the grid is readily obtained for drawing. I ended up using even less / more simplistic math than I had assumed it would require, you don't really have to use mod arithmetic to do this, you can just mix & match Math.Clamp, .Floor & .Ceiling and pretty much get your array indexes straight away (there will be a fully verbose tutorial on all this when it's done, skip the details for now).

Now that the occlusion works, hopefully I'll get a chance to finish this tomorrow by adding the necessary transforms to make it behave like a camera (ship stays in the center of the screen, game world scrolls, that sort of thing). I think I'll need to use a viewport object to physically clip the excess, although I'm not sure yet. Lots of fun stuff to learn still.

VB.NET XNA Project Template updated for Game Studio 2.0

2007-12-14T11:40:00.000-08:00

The VB.NET XNA Project Template for Visual Studio has been updated to include the latest version of the VBContentManager.

If you have previously placed the VB.NET XNA Project Template into your Visual Studio templates folder, after installing Game Studio 2.0 you should overwrite the older template .zip file with the newer version now available.

VB.NET XNA Content Pipeline for Game Studio 2.0

2007-12-14T10:34:00.001-08:00

[GS 2.0]

Game Studio 2.0 beta has ended and Game Studio 2.0 has been officially released. There are breaking changes in the ContentPipeline.targets file, so I've updated the VBContentManager class to generate a Content.contentproj file that works within the new parameters. The usage of the class remains the same.

Works with Game Studio 2.0

Now outputs content to the appropriate Visual Studio bin location (i.e., bin\Debug or bin\Release, whichever you've set Visual Studio to)

Public Class VBContentManager
Inherits ContentManager

Public Fonts As Hashtable(Of SpriteFont)
Public Textures As Hashtable(Of Texture2D)
Public SubTextures As Hashtable(Of Hashtable(Of Rectangle))
Public Sounds As Hashtable(Of SoundBank)
Public Effects As Hashtable(Of Effect)

Private strContentprojFile, strProjectFolder, strExecutingFolder, strContentFolder As String
Private objContent As List(Of ContentFile)
Private intDupeSound, intDupeTexture, intDupeFont, intDupeEffect As Integer

Public Enum Platform
Windows
XBox360
End Enum

Public Enum ContentTypes
Textures = 0
Fonts = 1
Sounds = 2
Effects = 3
End Enum

Private Enum ImporterName
TextureImporter = 0
FontDescriptionImporter = 1
XactImporter = 2
EffectImporter = 3
End Enum

Private Enum ProcessorName
TextureProcessor = 0
FontDescriptionProcessor = 1
XactProcessor = 2
EffectProcessor = 3
End Enum

Public Structure ContentFile

Public ContentType As ContentTypes
Public File As System.IO.FileInfo
Public Name As String

Public Sub New(ByVal ContentType As ContentTypes, ByVal ContentFile As System.IO.FileInfo, ByVal Name As String)
Me.ContentType = ContentType
Me.File = ContentFile
Me.Name = Name
End Sub

End Structure

''' <summary>
''' Creates a new ContentManager which has been extended with functionality to support a Visual Basic (or other non-C#) project
''' </summary>
''' <param name="ServiceProvider">Your game has a .Services property; send that in here.</param>
''' <param name="ContentFolder">Your content folder (a relative path, from your game's Project node as it appears in the Solution Explorer)</param>
''' <remarks></remarks>
Public Sub New(ByVal ServiceProvider As IServiceProvider, ByVal ContentFolder As String)

MyBase.New(ServiceProvider)

With System.Reflection.Assembly.GetEntryAssembly.Location
Me.strExecutingFolder = .Substring(0, .LastIndexOf("\"))
End With

With Me.strExecutingFolder
With .Substring(0, .LastIndexOf("\") - 1)
Me.strProjectFolder = .Substring(0, .LastIndexOf("\"))
End With
End With

Me.strContentFolder = Me.strProjectFolder & "\" & ContentFolder

Me.Fonts = New Hashtable(Of SpriteFont)
Me.Textures = New Hashtable(Of Texture2D)
Me.SubTextures = New Hashtable(Of Hashtable(Of Rectangle))
Me.Sounds = New Hashtable(Of SoundBank)
Me.Effects = New Hashtable(Of Effect)

End Sub

''' <summary>
''' Attempts to load all assets which have been compiled by the Content Pipeline. Assets are placed into the respective Hash table (Fonts, Textures, et al)
''' </summary>
''' <remarks></remarks>
Public Sub LoadAllContent()

Dim objCompiledContent As New List(Of IO.FileInfo)
Dim strUnknownFiles As String = ""

For Each file As IO.FileInfo In New IO.DirectoryInfo(Me.strExecutingFolder).GetFiles("*.xnb", IO.SearchOption.AllDirectories)

Try

'Font?

With file.FullName.ToLower
Me.Fonts.Add(file.Name.Replace(file.Extension, ""), Me.Load(Of SpriteFont)(.Replace(Me.strExecutingFolder & "\", "").Replace(file.Extension, "")))
End With

Catch notAFont As Exception

Try

'Texture2D?

With file.FullName
Me.Textures.Add(file.Name.Replace(file.Extension, ""), Me.Load(Of Texture2D)(.Replace(Me.strExecutingFolder & "\", "").Replace(file.Extension, "")))
End With

'Is this a sheet w/ a rectangle map?  If so, load the rectangle map

If IO.File.Exists(file.FullName.Replace(file.Extension, ".map")) Then
Me.LoadMap(file.Name.Replace(file.Extension, ""), file.FullName.Replace(file.Extension, ".map"))
End If

Catch notATexture2D As Exception

Try

'Sound?

With file.FullName.ToLower
Me.Sounds.Add(file.Name.Replace(file.Extension, ""), Me.Load(Of SoundBank)(.Replace(Me.strExecutingFolder & "\", "").Replace(file.Extension, "")))
End With

Catch notASoundBank As Exception

Try

'Effect?

With file.FullName.ToLower
Me.Effects.Add(file.Name.Replace(file.Extension, ""), Me.Load(Of Effect)(.Replace(Me.strExecutingFolder & "\", "").Replace(file.Extension, "")))
End With

Catch unknown As Exception

strUnknownFiles &= vbCrLf & file.FullName

End Try

End Try

End Try

End Try

Next

If strUnknownFiles <> "" Then

MsgBox("The VBContentManager was unable to determine the correct loader for:" & vbCrLf & _
strUnknownFiles & vbCrLf & vbCrLf & _
"Unless loaded by something else, the above content won't be available at runtime." & vbCrLf & vbCrLf & _
"This application may become unstable as a result.")

End If

End Sub

Private Sub LoadMap(ByVal strTextureNameName As String, ByVal strMapFile As String)

Dim objReader As IO.StreamReader
Dim strMapData As String
Dim strLine() As String
Dim strItem() As String

objReader = New IO.StreamReader(strMapFile)

Me.SubTextures.Add(strTextureNameName, New Hashtable(Of Rectangle))

strMapData = objReader.ReadToEnd

objReader.Close()

objReader.Dispose()

strLine = strMapData.Split(vbCrLf.ToCharArray, System.StringSplitOptions.RemoveEmptyEntries)

For Each strMapItem As String In strLine

strItem = strMapItem.Split(",".ToCharArray, System.StringSplitOptions.RemoveEmptyEntries)

Me.SubTextures(strTextureNameName).Add(strItem(0), New Rectangle(CInt(strItem(1)), CInt(strItem(2)), CInt(strItem(3)), CInt(strItem(4))))

Next

End Sub

''' <summary>
''' Compiles the VB Content Pipeline
''' </summary>
''' <param name="stealth">Hide/Show the MSBuild window during the compile process</param>
''' <param name="platform">If there's a way the Xbox360 will work with VB, you could pass in the Xbox parameter as a target platform to MSBuild.  But it's Windows by default.</param>
''' <remarks></remarks>
Public Sub CompileContent(ByVal stealth As Boolean, Optional ByVal platform As Platform = VBContentManager.Platform.Windows)

Dim objProcess As Process
Dim objPSI As New Diagnostics.ProcessStartInfo

Me.objContent = New List(Of ContentFile)

Me.HarvestContent()

If Me.objContent.Count > 0 Then

Me.BuildContentProj(platform)

Try 'to write the content project file to disk

Using TempStreamWriter As System.IO.StreamWriter = New System.IO.StreamWriter(Me.strProjectFolder & "\Content.contentproj", False)

With TempStreamWriter

.Write(Me.strContentprojFile)
.Close()

End With

End Using

Try

With objPSI
.FileName = Environment.GetEnvironmentVariable("Windir") & "\Microsoft.NET\Framework\v2.0.50727\MSBuild.exe"
.Arguments = """" & Me.strProjectFolder & "\Content.contentproj""" & _
" /verbosity:normal" & _
" /l:FileLogger,Microsoft.Build.Engine;logfile=""" & Me.strProjectFolder & "\Content.log"""
If stealth Then
.Arguments &= " /noconsolelogger"
.WindowStyle = ProcessWindowStyle.Hidden
End If
End With

'give the .contentproj file to MSBuild

objProcess = System.Diagnostics.Process.Start(objPSI)

While Not objProcess.HasExited
Threading.Thread.Sleep(100)
End While

Catch ex As Exception

MsgBox("When building the pipeline, trying to run MSBuild.exe resulted in: " & ex.Message)

End Try

Catch ex As Exception

MsgBox("When building the pipeline, trying to create the Content.contentproj file """ & Me.strProjectFolder & "\Content.contentproj"" resulted in: " & ex.Message)

End Try

End If

End Sub

Private Sub HarvestContent()

Dim objRoot As System.IO.DirectoryInfo = New System.IO.DirectoryInfo(Me.strContentFolder)

For Each sound As System.IO.FileInfo In objRoot.GetFiles("*.xab", IO.SearchOption.AllDirectories)
If Me.objContent.Contains(New ContentFile(ContentTypes.Sounds, sound, sound.Name.Replace(sound.Extension, ""))) Then
Me.intDupeSound += 1
Me.objContent.Add(New ContentFile(ContentTypes.Sounds, sound, sound.Name.Replace(sound.Extension, "") & Me.intDupeSound.ToString))
Else
Me.objContent.Add(New ContentFile(ContentTypes.Sounds, sound, sound.Name.Replace(sound.Extension, "")))
End If
Next

For Each texture As System.IO.FileInfo In objRoot.GetFiles("*.png", IO.SearchOption.AllDirectories)
If Me.objContent.Contains(New ContentFile(ContentTypes.Textures, texture, texture.Name.Replace(texture.Extension, ""))) Then
Me.intDupeTexture += 1
Me.objContent.Add(New ContentFile(ContentTypes.Textures, texture, texture.Name.Replace(texture.Extension, "") & Me.intDupeTexture.ToString))
Else
Me.objContent.Add(New ContentFile(ContentTypes.Textures, texture, texture.Name.Replace(texture.Extension, "")))
End If
Next

For Each texture As System.IO.FileInfo In objRoot.GetFiles("*.jpg", IO.SearchOption.AllDirectories)
If Me.objContent.Contains(New ContentFile(ContentTypes.Textures, texture, texture.Name.Replace(texture.Extension, ""))) Then
Me.intDupeTexture += 1
Me.objContent.Add(New ContentFile(ContentTypes.Textures, texture, texture.Name.Replace(texture.Extension, "") & Me.intDupeTexture.ToString))
Else
Me.objContent.Add(New ContentFile(ContentTypes.Textures, texture, texture.Name.Replace(texture.Extension, "")))
End If
Next

For Each texture As System.IO.FileInfo In objRoot.GetFiles("*.gif", IO.SearchOption.AllDirectories)
If Me.objContent.Contains(New ContentFile(ContentTypes.Textures, texture, texture.Name.Replace(texture.Extension, ""))) Then
Me.intDupeTexture += 1
Me.objContent.Add(New ContentFile(ContentTypes.Textures, texture, texture.Name.Replace(texture.Extension, "") & Me.intDupeTexture.ToString))
Else
Me.objContent.Add(New ContentFile(ContentTypes.Textures, texture, texture.Name.Replace(texture.Extension, "")))
End If
Next

For Each font As System.IO.FileInfo In objRoot.GetFiles("*.spritefont", IO.SearchOption.AllDirectories)
If Me.objContent.Contains(New ContentFile(ContentTypes.Fonts, font, font.Name.Replace(font.Extension, ""))) Then
Me.intDupeFont += 1
Me.objContent.Add(New ContentFile(ContentTypes.Fonts, font, font.Name.Replace(font.Extension, "") & Me.intDupeFont.ToString))
Else
Me.objContent.Add(New ContentFile(ContentTypes.Fonts, font, font.Name.Replace(font.Extension, "")))
End If
Next

For Each effect As System.IO.FileInfo In objRoot.GetFiles("*.fx", IO.SearchOption.AllDirectories)
If Me.objContent.Contains(New ContentFile(ContentTypes.Effects, effect, effect.Name.Replace(effect.Extension, ""))) Then
Me.intDupeEffect += 1
Me.objContent.Add(New ContentFile(ContentTypes.Effects, effect, effect.Name.Replace(effect.Extension, "") & Me.intDupeEffect.ToString))
Else
Me.objContent.Add(New ContentFile(ContentTypes.Effects, effect, effect.Name.Replace(effect.Extension, "")))
End If
Next

End Sub

Private Sub BuildContentProj(ByVal platform As Platform)

Dim strPlatform As String

Select Case platform
Case VBContentManager.Platform.XBox360
strPlatform = "Xbox 360"
Case Else
strPlatform = "Windows"
End Select

Me.strContentprojFile = _
"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">" & vbCrLf & _
vbTab & "<Import Project=""$(MSBuildExtensionsPath)\Microsoft\XNA Game Studio\v2.0\Microsoft.Xna.GameStudio.ContentPipeline.targets"" />" & vbCrLf & _
vbTab & "<PropertyGroup>" & vbCrLf & _
vbTab & vbTab & "<OutputType>Library</OutputType>" & vbCrLf & _
vbTab & vbTab & "<XnaFrameworkVersion>v2.0</XnaFrameworkVersion>" & vbCrLf & _
vbTab & vbTab & "<ProjectDir>" & Me.strProjectFolder & "\</ProjectDir>" & vbCrLf & _
vbTab & vbTab & "<ParentOutputDir>" & Me.strExecutingFolder & "</ParentOutputDir>" & vbCrLf & _
vbTab & vbTab & "<ContentRootDirectory>\</ContentRootDirectory>" & vbCrLf & _
vbTab & vbTab & "<XNAContentPipelineTargetPlatform>" & strPlatform & "</XNAContentPipelineTargetPlatform>" & vbCrLf & _
vbTab & vbTab & "<OutputPath>" & Me.strExecutingFolder & "\</OutputPath>" & vbCrLf & _
vbTab & vbTab & "<OutputDirectory>" & Me.strExecutingFolder & "\</OutputDirectory>" & vbCrLf & _
vbTab & "</PropertyGroup>" & vbCrLf & _
vbTab & "<ItemGroup>" & vbCrLf & _
vbTab & vbTab & "<Reference Include=""Microsoft.Xna.Framework.Content.Pipeline.EffectImporter, Version=2.0.0.0, Culture=neutral, PublicKeyToken=6d5c3888ef60e27d, processorArchitecture=MSIL"" />" & vbCrLf & _
vbTab & vbTab & "<Reference Include=""Microsoft.Xna.Framework.Content.Pipeline.FBXImporter, Version=2.0.0.0, Culture=neutral, PublicKeyToken=6d5c3888ef60e27d, processorArchitecture=MSIL"" />" & vbCrLf & _
vbTab & vbTab & "<Reference Include=""Microsoft.Xna.Framework.Content.Pipeline.TextureImporter, Version=2.0.0.0, Culture=neutral, PublicKeyToken=6d5c3888ef60e27d, processorArchitecture=MSIL"" />" & vbCrLf & _
vbTab & vbTab & "<Reference Include=""Microsoft.Xna.Framework.Content.Pipeline.XImporter, Version=2.0.0.0, Culture=neutral, PublicKeyToken=6d5c3888ef60e27d, processorArchitecture=MSIL"" />" & vbCrLf & _
vbTab & "</ItemGroup>"

For Each content As ContentFile In Me.objContent

Me.strContentprojFile &= vbCrLf & _
vbTab & "<ItemGroup>" & vbCrLf & _
vbTab & vbTab & "<Compile Include=""" & content.File.FullName & """>" & vbCrLf & _
vbTab & vbTab & vbTab & "<Name>" & content.Name & "</Name>" & vbCrLf & _
vbTab & vbTab & vbTab & "<Importer>" & CType(content.ContentType, ImporterName).ToString & "</Importer>" & vbCrLf & _
vbTab & vbTab & vbTab & "<Processor>" & CType(content.ContentType, ProcessorName).ToString & "</Processor>" & vbCrLf & _
vbTab & vbTab & "</Compile>" & vbCrLf & _
vbTab & "</ItemGroup>"

If content.ContentType = ContentTypes.Textures Then

'If this texture is a sheet w/ a map, copy it's map out in the executable area
'along side the existing or eventual compiled texture

If IO.File.Exists(content.File.FullName.Replace(content.File.Extension, ".map")) Then

Try
IO.File.Copy(content.File.FullName.Replace(content.File.Extension, ".map"), _
Me.strExecutingFolder & content.File.FullName.Replace(Me.strProjectFolder, "").Replace(content.File.Extension, ".map"), True)
Catch ex As Exception
'I'm going to be optimistic and assume that if I can't copy
'it's because the file is already there, and life is just fine
End Try

End If

End If

Next

Me.strContentprojFile &= vbCrLf & vbTab & "" & vbCrLf & _
"</Project>"

End Sub

End Class

2D Camera

2007-12-12T21:01:00.000-08:00

This is the idea:

Create a "bounding box" (orange) around the camera (blue), snap that bounding box to the grid on all sides (moving outwards, in all directions from the bounding box, until you hit a grid line - green). Then just divide the corners of the green square by tilesize, you should end up with actual grid array element positions to fetch tiles with.

There's a little slop when the camera is rotated (you'll pick up extra tiles you don't really need to draw & update) but, on the other hand, you don't have to scan around or perform any intersect tests, so hopefully the net result is reasonably quick.

If this doesn't work I'm screwed, because I can't think of any other way to do it! Now I just have to write it...

Update: I got about half way through it this evening and figured I'd run it just to see what happens. Here's some "unexpected results" for you:

direct link

Yea it's not quite done yet :)

A thruster component

2007-12-11T09:59:00.001-08:00

[GS 2.0 Beta]

One of the things I want to feature in Star Maze are ship upgrades, allowing you to attach different thrusters & weapons to your ship.

Given the parent/child system, we know that we can "attach" one sprite to another, like what we did in Tutorial 7. And since our game objects are nothing more than "sprites with a brain", we can actually attach one game object to another. So after incorporating the psuedo-physics parameters & processing to the sprite class, I created a game component meant soley to be a child of another; a thruster module which can be attached to anything to make it move. This is the base thruster class from which you derive to create a custom thruster object:

Public Interface IThruster
Sub StopThrusterAnim()
Sub StartThrusterAnim()
End Interface

Public MustInherit Class BaseThruster
Inherits Sprite
Implements IThruster

Protected sngForce As Single
Protected enumKey As Keys
Protected bolIsOn As Boolean
Protected enumType As ThrusterType

Public MustOverride Sub StopThrusterAnim() Implements IThruster.StopThrusterAnim
Public MustOverride Sub StartThrusterAnim() Implements IThruster.StartThrusterAnim

Public Property Force() As Single
Get
Return Me.sngForce
End Get
Set(ByVal value As Single)
Me.sngForce = value
End Set
End Property

Enum ThrusterType
Linear
Rotational
End Enum

Public Overrides Sub Update()

Dim quant As Quaternion
Dim direction As Vector2

If Me.Game.KeyboardState.IsKeyDown(Me.enumKey) Then

If Not Me.bolIsOn Then
Me.StartThrusterAnim()
Me.bolIsOn = True
End If

Select Case Me.enumType

Case ThrusterType.Linear

Me.WorldMatrix.Decompose(Nothing, quant, Nothing)
Vector2.Transform(New Vector2(Math.Sin(CDbl(Me.sngRotation)), -Math.Cos(CDbl(Me.sngRotation))), Matrix.CreateFromQuaternion(quant), direction)

Me.Parent.ApplyForce((direction * Me.sngForce) * (Me.Game.GameTime.ElapsedGameTime.TotalMilliseconds / 1000))

Case ThrusterType.Rotational

Me.Parent.ApplyRotationalForce(Me.sngForce * (Me.Game.GameTime.ElapsedGameTime.TotalMilliseconds / 1000))

End Select

ElseIf Me.bolIsOn Then

Me.StopThrusterAnim()
Me.bolIsOn = False

End If

MyBase.Update()

End Sub

Public Sub New(ByVal parent As Ship, ByVal type As ThrusterType, ByVal key As Keys, ByVal name As String, ByVal force As Single, ByVal containerSize As Vector2)
MyBase.New(Program.StarMaze, parent, name, True, True, containerSize)
Me.sngForce = force
Me.enumKey = key
Me.enumType = type
End Sub

Public Sub New(ByVal parent As Ship, ByVal type As ThrusterType, ByVal key As Keys, ByVal name As String, ByVal force As Single, ByVal sheet As String, ByVal subtexture As String)
MyBase.New(Program.StarMaze, parent, name, True, True, sheet, subtexture)
Me.sngForce = force
Me.enumKey = key
Me.enumType = type
End Sub

End Class

With the base thruster class you can create a rotational thruster for spinning around or a linear thruster for vector movement. A keyboard key parameter will be monitored by the thruster to turn itself on and off, and there's a parameter to hold how much force the thruster applies to it's parent (whatever it's attached to).

When it Updates, it calls the ApplyForce or ApplyRotationalForce methods of it's parent, and the system moves accordingly.

A simple interface defines two routines, StopThrusterAnim & StartThrusterAnim, which provides the implementor with a place & time to perform graphical feedback as it relates to the thruster entering an On or Off state.

Using this base thruster class I created 4 different game components; custom thrusters which I can attach to the player's ship. Two different aft thrusters (linear), a port thruster (clockwise rotational), and a starboard thruster (counterclockwise rotational).

The player's ship object can now be defined very simply, by creating instances of these thrusters and attaching whichever ones we want accordingly:

Public Class Ship
Inherits Sprite

Protected aftThruster, portThruster, starboardThruster As BaseThruster

Public Sub New()

MyBase.New(Program.StarMaze, Nothing, "playership", True, True, "starmaze", "playership")

Me.Origin = New Vector2(54, 82)

Me.sngMass = 1
Me.sngFriction = 25

Me.aftThruster = New AftThruster2(Me)
Me.portThruster = New PortThruster1(Me)
Me.starboardThruster = New StarboardThruster1(Me)

Me.AddChild(Me.aftThruster)
Me.AddChild(Me.portThruster)
Me.AddChild(Me.starboardThruster)

End Sub

End Class

Here's a quick lo-fi vid of this in action:

(direct link to youtube)

In the video I start out using one of two aft thruster classes which derive from base thruster (the green one, it produces 500 pixels per second (pps) of linear force). When the app stops and I go into the IDE, I swap out the green 500pps thruster for a different thruster class, a red one that produces 250 pps of linear force. You my also be able to see the tiny little port and starboard thrusters applying the counter- and clockwise rotational forces as well.

As you can see from the Ship class code above, the ship itself has no inherit way to move itself; it's just a hull that doesn't handle keyboard input or anything of the sort. To make it move, we simply attach thruster components. The neat part about this system is that you can attach any thruster you want to any game object you want. You can put thrusters on the player's ship, on enemy AI ships, you can stick one on a bowling ball if you want. The thruster component is a somewhat generic way to apply force, to any game object.

My laptop was lagging for unrelated reasons when I recorded this, so the fps is kinda low, but in an otherwise normal environment the code runs quite nicely.

Fun with (very basic) physics

2007-12-09T14:52:00.001-08:00

[GS 2.0 Beta]

So in developing a new system of sprite movement, I decided to try a little bit of really basic physics. Adding a few simple members to the sprite class to store values relating to velocity, momentum & friction:

Protected objVelocity As Vector2
Protected sngFriction, sngMass As Single

and then, adding method called ApplyForce:

Public Sub ApplyForce(ByVal force As Vector2)

If Me.sngMass > 0 Then
Me.objVelocity += (force / Me.sngMass)
Else
Me.objVelocity += force
End If

End Sub

and finally, processing this information during update:

Public Sub UpdatePhysics()

Dim time As Single
Dim negX, negY As Boolean

'Our unit of measure is pixles per second
time = Me.Game.GameTime.ElapsedGameTime.TotalMilliseconds / 1000

'If there is any velocity...

If Me.objVelocity <> Vector2.Zero Then

'before we apply friction, let's remember whether
'or not we started out with positive or negative
'velocity value, for both x and y, by setting
'"wasNegativeX/Y" booleans

negX = Me.objVelocity.X < 0
negY = Me.objVelocity.Y < 0

'simulate some psuedo-friction by normalizing the
'velocity vector and multiplying it by the friction
'value.  This gives us an amount to "push" the object
'in the exact opposite direction.  Multiplied by
'time to do just enough for this frame only.  Subtract
'the result from the object's velocity, to slow it down.

Me.objVelocity -= (Vector2.Normalize(Me.objVelocity) * Me.sngFriction) * time

'Because friction is simulated by pushing the object in
'the opposite direction, towards the end when the object
'is almost stopped we don't want the psuedo-friction to
'start pushing the object backwards; at most, friction
'stops something, but it shouldn't ever move it.  So using
'or cached "whether or not it was negative" booleans,
'check to see if the polarity of our X/Y velocity changed
'due to friction.  If it did, snap the velocity of that
'value to 0.

If (negX And Me.objVelocity.X > 0) Or (Not negX And Me.objVelocity.X < 0) Then
Me.objVelocity.X = 0
End If

If (negY And Me.objVelocity.Y > 0) Or (Not negY And Me.objVelocity.Y < 0) Then
Me.objVelocity.Y = 0
End If

'increment the object's position by the amount of
'velocity appropriate for this frame by multiplying
'by the time value.

Me.Position += (Me.objVelocity * time)

End If

End Sub

I haven't really discussed my existing system for movement on the blog yet; we'll get to that eventually, but I was amused by this velocity/friction/mass approach and it's probably more relevant to the needs of gaming anyway.

This is far from an actual simulator, I'm only using mass to resist initial force and not really applying it to friction but that's ok. This is supposed to be simple, and the results aren't too shabby.

In the video, just the new "physics" values introduced are being used to move the spaceship around. While the player holds down the thrust key, the current orientation of the ship * some thrust value determines a parameter for ApplyForce. Using a PlayerShip game object (as described in previous tutorials, it just inherits from sprite), I created a ThrusterOn method. As long as the user holds the truster key down, I call PlayerShip.ThrusterOn

Public Sub ThrusterOn()

Dim time As Single

time = Me.Game.GameTime.ElapsedGameTime.TotalMilliseconds / 1000

Me.ApplyForce((Vector2.Normalize(New Vector2(Math.Sin(CDbl(Me.sngRotation)), -Math.Cos(CDbl(Me.sngRotation)))) * 250) * time)

End Sub

The ship has a little mass to it, so it resists force somewhat (this gives you a way to tweak acceleration curve vs. thruster power), and the ship's psuedo-friction value constantly pulls it's velocity toward zero. This example was built using my "real" 2D engine (which is a little further along than what the blog has covered so far, i.e. there's keyboard handling & debugging & screen management, etc.), but the movement you see is achieved through the simple additions described above.

Velocity, distance and time

2007-12-08T12:48:00.000-08:00

The first animation system I created, which I currently use, was designed with UI components in mind. Things like buttons, windows, forms & controls, stuff like that. The current animation system I have for this is very good at moving something from one predefined point to another: from A to B. Or from rotation value X to rotation value Y. But always from one finite value to another finite value.

I'll keep this around, because it's useful, but games are not so rigidly constructed as UIs. I'm forming the opinion that it's better to not rely on knowledge of predefined points when moving game objects, but rather rely on movement values such as velocity and direction, and just react accordingly to those values over time. So in consuming yet more R&D time before I put any more tutorials out, I'm going to construct such a thing. I have a few ideas I want to play with which may prove very useful.

I'm also working on a grid object which can be incorporated into the parent/child system so that at any point, a grid w/ a camera can be arbitrarily put anywhere & globally transformed by it's parent.

Ramble

2007-12-03T14:25:00.000-08:00

I've been surprised by how much GPU power it takes to run a pixel shader over a scene. The 2-pass Gaussian blur I've been testing with pushes my laptop's GPU pretty hard (a Mobility FireGL V5200; not exactly an uber GPU). Initially I attributed the performance I was seeing to my code being inefficient, but after comparing performance with the post processing samples on the Creator's Club site (which I presume to be well formed) I don't think I'm doing anything "wrong" - I'm just a little bit brainwashed by the performance of modern CPUs.

A modern CPU (like an Intel core duo 2.0Ghz processor) can perform mathematical operations so fast as to be indistinguishable from magic. But I was forgetting that the modern GPU hasn't had as much time as the CPU to mature & advance as a technology. GPUs are fast, but they still have plenty of room to grow. In thinking my code was inefficient, in truth I was overestimating the ability of my laptop's GPU.

So the shader business is basically done. I've got a system of renderTargets built into the engine to handle arbitrary scene processing at arbitrary points in the parent/child hierarchy, which accomplishes the goal. Now all I need to do is steal my wife's 8800GTX out of her gaming rig and cram it into my laptop with a vice. Yea, that should work.

My job has me somewhat diverted from this blog, although, the stuff I'm tasked with at work is vicariously related. In my current project, a "mostly complete" version of this 2D engine is used to create an XNA application. But I'm a "regular" programmer, not a "game developer", and so the goal of this 2D engine is to create a really user-friendly, neato touch-screen interface in an attempt to delude all who use it into believing their job is not quite as boring and mundane as it is. Which is not such a bad thing to do for people, really.

This app at work likes to get real chummy with a SQL database to conduct important workly business. About a 3rd of this chummy relationship is facilitated through the DataAdapter.Fill method, mainly because I have a small ADO engine with some built in concurrency checking features etc which I'm reusing in the XNA app. What's particularly problematic about using DataAdapter.Fill with an XNA application is the fact that DataAdapter.Fill is a synchronous method: this means DataAdapter.Fill "blocks the calling thread" while it's grabbing data out of SQL. I'm no game industry veteran by any means, but I can guess blocking the main thread of a game probably ranks in the top 3 "worst design features of all time". While it just so happens I can get away with this over the LAN, deploying this app over a VPN is obviously not going to work.

So currently I'm devising an async system for DataAdapter.Fill and just basically making all the changes I have to make to get this done, it's a little extensive because I'm revamping an entire remote access system, just a little. To be honest it's something I've always known I should do, I just never had a real critical reason to do it. Kind of a hassle but certainly for the best.

But this relates partly to my 2D engine / game programming hobby in that I'll end up with a model whereby the game loop submits requests for remote data, then continues to render normally while it polls for the result to complete. I would assume this sort of model will be handy for a networking layer to a multiplayer game, like for sending requests to a game server or peer client and awaiting the response. So, mundane as it is, this sort of thing should prove reasonably useful in the future.

Star Maze

2007-11-30T21:01:00.000-08:00

When I was a kid, my dad, in a uncharacteristic fit of runaway consumerism, came home one afternoon with an Apple IIe rig. Monochrome green monitor, dual disk drives and a really big molded plastic desk to house it all. Expensive, cutting-edge technology that no one in my family really knew what to do with - including dad. But it was pretty awesome anyway.

I wouldn't become interested in programming for another decade or more (long after the Apple IIe was gone), but I have a lot of good memories of the unique & quirky games I played back on the Apple. So a few years ago when I discovered the AppleWin emulator project and the impressive ftp.apple.asimov.net disk image repository, I was stoked.

The vast array of software available in the asimov repository can be a blessing and a curse; it's comprehensive, but it quickly turns into a proverbial haystack when you can't remember the name of that one game you played 25 years ago. Last night I was pretty thrilled to finally reunite a vague memory of "that one gem collecting space game" with Star Maze.

Star Maze running in AppleWin
Since I've been building this 2D engine in XNA, there's been something of a worker thread spawned in the back of my mind. A background process that examines the games I play through a programmer's prism. Last night as I drifted around Star Maze, shooting bad guys, collecting jewels and enjoying the nostalgia, it occurred to me that Star Maze is actually a well designed game. It's ancient, and a hassle to play via the emulator, but whereas a lot of these old games I've exhumed from asimov lately have primarily had only nostalgic value and not much else, Star Maze sticks out as a somewhat viable game. I think there's a spark of gameplay beating beneath it's crude surface, preserved all these years.

Once the engine is done, I think I'll give my old pal Star Maze a face-lift.

VB.NET XNA Windows Game Project Template

2007-11-27T18:10:00.000-08:00

I've made a VB.NET XNA Windows Game project template for Visual Studio. It should work with Visual Studio 2005 & Visual Basic Express edition (and may work in others, but has not been tested) It requires you install Game Studio 2.0.

The project template comes in 2 flavors: With Examples, and Without.

"With Examples" gives you a Game class that contains code and comments that take you step by step through the LoadContent, Update and Draw routines to perform a simple 2D task using XNA and VB.NET.

"Without Examples" gives you the same thing, without the sample code.

Both include an initialized VBContentManager for you to study, hack apart, belittle, delete, or just use as-is.

How to install it

Just save either one of the following files into your Visual Studio 2005 templates folder

With Examples

or

Without Examples

This is a zip file - do you mean unzip it into the templates folder?

Nope, just save the zip file right into the templates folder. Visual Studio 2005 knows what to do with it.

"Templates folder"?

Unless you've told Visual Studio otherwise, it's located on your computer here:

My Documents\Visual Studio 2005\Templates\ProjectTemplates\Visual Basic

You can just tell your browser to save the file there.

When you start a new project, you should now see WindowsGame under "My Templates" for Visual Basic:

Using the template should create a project for you that looks like this:

This is the "Without Examples" version

The goal is for you to be able to start one of these projects anew just like you see above, hit F5, and have a working "game" you can start modifying & adding content to right away.

Is this actual support for VB.NET + XNA?

Not really, this is the same old hack stuff you've been reading on my blog or Alan Phipp's site or wherever, I've just packaged up my version of the hack for you into a Visual Studio template, so you can be up and running with it right away.

The five P's

2007-11-25T12:46:00.000-08:00

Before I move on with more tutorials, I'm going to do a little R&D on a few logistical things that I want to improve and/or be sure will still work once we're further down the road.

I want to reduce the number of calls being made to SpriteBatch.Begin and SpriteBatch.End, so a maximum number of sprites are actually sent as a batch (rather than having hundreds of "batches" of 1 sprite each, which is not exactly the optimal way to use SpriteBatch). I have an idea for this but I still need to play with it this week.

What I've been playing with this weekend are ways to make certain shader effects (like blurs) happen much, much faster. This is reasonably out of scope of what the blog has covered so far, but seeing as how I want to tie shader effects into the engine later on without invoking a messy refactor, I'm going to get it all straightened out before I continue the tutorials.

I also want to study the idea of a particle engine that will integrate nicely into what's being built here.

So the next tutorial whenever it comes will probably be a quick tour through the changes in Game Studio / XNA 2.0 and then we'll roll on from there.

The five P's are Prior Planning Prevents Poor Projects. Good advice.

VB.NET XNA Content Pipeline for Game Studio 2.0 (beta)

2007-11-20T19:43:00.001-08:00

[GS 2.0 Beta]

Moving forward, the tutorials on this website will be referencing XNA 2.0.

Here is an updated version of the VBContentManager class for use with XNA 2.0

The class itself now inherits from the XNA 2.0 ContentManager

The LoadPipeline() method has been replaced by the CompileContent & LoadAllContent methods. Call these methods as appropriate where LoadPipeline was used before.

You can now specify a platform (Windows or Xbox360), although it's not exactly known whether or not you can run VB.NET on an Xbox360. This is there just in case/for the future. The target platform is Windows by default

You can now specify whether or not the MSBuild window is visible, having the content compile in "stealth mode" (as a C# project does)

The content folder is no longer supplied relative to the bin\Debug folder. You now supply it relative to the Project node in which the folder resides. For example, if you made a folder called "My Content" in your game's project in the Solution Explorer, you would simply supply "My Content" as the path to your content (rather than "../../My Content" like before)

The 'fake' project file built for MSBuild is now a .contentproj file, rather than an actual .csproj file. Not that the extension matters much, this was simply for the sake of emulating the file created in XNA 2.0 (where, in C#, content is now a sub-project of the game and has it's own project file - the VBContentManager simply simulates this file). As an aside, the project file being generated is more well formed than before, so MSBuild should no longer throw warning messages as it compiles.

In the previous version of the VBContentManager, choosing not to compile the content would result in a runtime error. You no longer have to compile the content; if you know it's already compiled (like say for instance, right before you are going to distribute the application to someone's PC) you can omit the call to CompileContent in your code and load the already-compiled content (skips the call to MSBuild completely).

Here is the code for the class:

Public Class VBContentManager
Inherits ContentManager

Public Fonts As Hashtable(Of SpriteFont)
Public Textures As Hashtable(Of Texture2D)
Public SubTextures As Hashtable(Of Hashtable(Of Rectangle))
Public Sounds As Hashtable(Of SoundBank)
Public Effects As Hashtable(Of Effect)

Private strContentprojFile, strProjectFolder, strExecutingFolder, strContentFolder As String
Private objContent As List(Of ContentFile)
Private intDupeSound, intDupeTexture, intDupeFont, intDupeEffect As Integer

Public Enum Platform
Windows
XBox360
End Enum

Public Enum ContentTypes
Textures = 0
Fonts = 1
Sounds = 2
Effects = 3
End Enum

Private Enum ImporterName
TextureImporter = 0
FontDescriptionImporter = 1
XactImporter = 2
EffectImporter = 3
End Enum

Private Enum ProcessorName
TextureProcessor = 0
FontDescriptionProcessor = 1
XactProcessor = 2
EffectProcessor = 3
End Enum

Public Structure ContentFile

Public ContentType As ContentTypes
Public File As System.IO.FileInfo
Public Name As String

Public Sub New(ByVal ContentType As ContentTypes, ByVal ContentFile As System.IO.FileInfo, ByVal Name As String)
Me.ContentType = ContentType
Me.File = ContentFile
Me.Name = Name
End Sub

End Structure

''' <summary>
''' Creates a new ContentManager which has been extended with functionality to support a Visual Basic (or other non-C#) project
''' </summary>
''' <param name="ServiceProvider">Your game has a .Services property; send that in here.</param>
''' <param name="ContentFolder">Your content folder (a relative path, from your game's Project node as it appears in the Solution Explorer)</param>
''' <remarks></remarks>
Public Sub New(ByVal ServiceProvider As IServiceProvider, ByVal ContentFolder As String)

MyBase.New(ServiceProvider)

With System.Reflection.Assembly.GetEntryAssembly.Location
Me.strExecutingFolder = .Substring(0, .LastIndexOf("\"))
End With

With Me.strExecutingFolder
With .Substring(0, .LastIndexOf("\") - 1)
Me.strProjectFolder = .Substring(0, .LastIndexOf("\"))
End With
End With

Me.strContentFolder = Me.strProjectFolder & "\" & ContentFolder

Me.Fonts = New Hashtable(Of SpriteFont)
Me.Textures = New Hashtable(Of Texture2D)
Me.SubTextures = New Hashtable(Of Hashtable(Of Rectangle))
Me.Sounds = New Hashtable(Of SoundBank)
Me.Effects = New Hashtable(Of Effect)

End Sub

''' <summary>
''' Attempts to load all assets which have been compiled by the Content Pipeline. Assets are placed into the respective Hash table (Fonts, Textures, et al)
''' </summary>
''' <remarks></remarks>
Public Sub LoadAllContent()

Dim objCompiledContent As New List(Of IO.FileInfo)
Dim strUnknownFiles As String = ""

For Each file As IO.FileInfo In New IO.DirectoryInfo(Me.strExecutingFolder).GetFiles("*.xnb", IO.SearchOption.AllDirectories)

Try

'Font?

With file.FullName.ToLower
Me.Fonts.Add(file.Name.Replace(file.Extension, ""), Me.Load(Of SpriteFont)(.Replace(Me.strExecutingFolder & "\", "").Replace(file.Extension, "")))
End With

Catch notAFont As Exception

Try

'Texture2D?

With file.FullName
Me.Textures.Add(file.Name.Replace(file.Extension, ""), Me.Load(Of Texture2D)(.Replace(Me.strExecutingFolder & "\", "").Replace(file.Extension, "")))
End With

Catch notATexture2D As Exception

Try

'Sound?

With file.FullName.ToLower
Me.Sounds.Add(file.Name.Replace(file.Extension, ""), Me.Load(Of SoundBank)(.Replace(Me.strExecutingFolder & "\", "").Replace(file.Extension, "")))
End With

Catch notASoundBank As Exception

Try

'Effect?

With file.FullName.ToLower
Me.Effects.Add(file.Name.Replace(file.Extension, ""), Me.Load(Of Effect)(.Replace(Me.strExecutingFolder & "\", "").Replace(file.Extension, "")))
End With

Catch unknown As Exception

strUnknownFiles &= vbCrLf & file.FullName

End Try

End Try

End Try

End Try

Next

If strUnknownFiles <> "" Then

MsgBox("The VBContentManager was unable to determine the correct loader for:" & vbCrLf & _
strUnknownFiles & vbCrLf & vbCrLf & _
"Unless loaded by something else, the above content won't be available at runtime." & vbCrLf & vbCrLf & _
"This application may become unstable as a result.")

End If

End Sub

''' <summary>
''' Compiles the VB Content Pipeline
''' </summary>
''' <param name="stealth">Hide/Show the MSBuild window during the compile process</param>
''' <param name="platform">If there's a way the Xbox360 will work with VB, you could pass in the Xbox parameter as a target platform to MSBuild. But it's Windows by default.</param>
''' <remarks></remarks>
Public Sub CompileContent(ByVal stealth As Boolean, Optional ByVal platform As Platform = VBContentManager.Platform.Windows)

Dim objProcess As Process
Dim objPSI As New Diagnostics.ProcessStartInfo

Me.objContent = New List(Of ContentFile)

Me.HarvestContent()

If Me.objContent.Count > 0 Then

Me.BuildContentProj(platform)

Try 'to write the content project file to disk

Using TempStreamWriter As System.IO.StreamWriter = New System.IO.StreamWriter(Me.strProjectFolder & "\Content.contentproj", False)

With TempStreamWriter

.Write(Me.strContentprojFile)
.Close()

End With

End Using

Try

With objPSI
.FileName = Environment.GetEnvironmentVariable("Windir") & "\Microsoft.NET\Framework\v2.0.50727\MSBuild.exe"
.Arguments = """" & Me.strProjectFolder & "\Content.contentproj""" & _
" /verbosity:normal" & _
" /l:FileLogger,Microsoft.Build.Engine;logfile=""" & Me.strProjectFolder & "\Content.log"""
If stealth Then
.Arguments &= " /noconsolelogger"
End If
If stealth Then
.WindowStyle = ProcessWindowStyle.Hidden
End If
End With

'give the .contentproj file to MSBuild

objProcess = System.Diagnostics.Process.Start(objPSI)

While Not objProcess.HasExited
Threading.Thread.Sleep(100)
End While

Catch ex As Exception

MsgBox("When building the pipeline, trying to run MSBuild.exe resulted in: " & ex.Message)

End Try

Catch ex As Exception

MsgBox("When building the pipeline, trying to create the Content.contentproj file """ & Me.strContentFolder & "\Content.contentproj"" resulted in: " & ex.Message)

End Try

End If

End Sub

Private Sub HarvestContent()

Dim objRoot As System.IO.DirectoryInfo = New System.IO.DirectoryInfo(Me.strContentFolder)

For Each sound As System.IO.FileInfo In objRoot.GetFiles("*.xab", IO.SearchOption.AllDirectories)
If Me.objContent.Contains(New ContentFile(ContentTypes.Sounds, sound, sound.Name.Replace(sound.Extension, ""))) Then
Me.intDupeSound += 1
Me.objContent.Add(New ContentFile(ContentTypes.Sounds, sound, sound.Name.Replace(sound.Extension, "") & Me.intDupeSound.ToString))
Else
Me.objContent.Add(New ContentFile(ContentTypes.Sounds, sound, sound.Name.Replace(sound.Extension, "")))
End If
Next

For Each texture As System.IO.FileInfo In objRoot.GetFiles("*.png", IO.SearchOption.AllDirectories)
If Me.objContent.Contains(New ContentFile(ContentTypes.Textures, texture, texture.Name.Replace(texture.Extension, ""))) Then
Me.intDupeTexture += 1
Me.objContent.Add(New ContentFile(ContentTypes.Textures, texture, texture.Name.Replace(texture.Extension, "") & Me.intDupeTexture.ToString))
Else
Me.objContent.Add(New ContentFile(ContentTypes.Textures, texture, texture.Name.Replace(texture.Extension, "")))
End If
Next

For Each texture As System.IO.FileInfo In objRoot.GetFiles("*.jpg", IO.SearchOption.AllDirectories)
If Me.objContent.Contains(New ContentFile(ContentTypes.Textures, texture, texture.Name.Replace(texture.Extension, ""))) Then
Me.intDupeTexture += 1
Me.objContent.Add(New ContentFile(ContentTypes.Textures, texture, texture.Name.Replace(texture.Extension, "") & Me.intDupeTexture.ToString))
Else
Me.objContent.Add(New ContentFile(ContentTypes.Textures, texture, texture.Name.Replace(texture.Extension, "")))
End If
Next

For Each texture As System.IO.FileInfo In objRoot.GetFiles("*.gif", IO.SearchOption.AllDirectories)
If Me.objContent.Contains(New ContentFile(ContentTypes.Textures, texture, texture.Name.Replace(texture.Extension, ""))) Then
Me.intDupeTexture += 1
Me.objContent.Add(New ContentFile(ContentTypes.Textures, texture, texture.Name.Replace(texture.Extension, "") & Me.intDupeTexture.ToString))
Else
Me.objContent.Add(New ContentFile(ContentTypes.Textures, texture, texture.Name.Replace(texture.Extension, "")))
End If
Next

For Each font As System.IO.FileInfo In objRoot.GetFiles("*.spritefont", IO.SearchOption.AllDirectories)
If Me.objContent.Contains(New ContentFile(ContentTypes.Fonts, font, font.Name.Replace(font.Extension, ""))) Then
Me.intDupeFont += 1
Me.objContent.Add(New ContentFile(ContentTypes.Fonts, font, font.Name.Replace(font.Extension, "") & Me.intDupeFont.ToString))
Else
Me.objContent.Add(New ContentFile(ContentTypes.Fonts, font, font.Name.Replace(font.Extension, "")))
End If
Next

For Each effect As System.IO.FileInfo In objRoot.GetFiles("*.fx", IO.SearchOption.AllDirectories)
If Me.objContent.Contains(New ContentFile(ContentTypes.Effects, effect, effect.Name.Replace(effect.Extension, ""))) Then
Me.intDupeEffect += 1
Me.objContent.Add(New ContentFile(ContentTypes.Effects, effect, effect.Name.Replace(effect.Extension, "") & Me.intDupeEffect.ToString))
Else
Me.objContent.Add(New ContentFile(ContentTypes.Effects, effect, effect.Name.Replace(effect.Extension, "")))
End If
Next

End Sub

Private Sub BuildContentProj(ByVal platform As Platform)

Dim strPlatform As String

Select Case platform
Case VBContentManager.Platform.XBox360
strPlatform = "Xbox 360"
Case Else
strPlatform = "Windows"
End Select

Me.strContentprojFile = _
"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">" & vbCrLf & _
vbTab & "<Import Project=""$(MSBuildExtensionsPath)\Microsoft\XNA Game Studio\v2.0\Microsoft.Xna.GameStudio.ContentPipeline.targets"" />" & vbCrLf & _
vbTab & "<PropertyGroup>" & vbCrLf & _
vbTab & vbTab & "<OutputType>Library</OutputType>" & vbCrLf & _
vbTab & vbTab & "<XnaFrameworkVersion>v2.0</XnaFrameworkVersion>" & vbCrLf & _
vbTab & vbTab & "<ProjectDir>" & Me.strProjectFolder & "\</ProjectDir>" & vbCrLf & _
vbTab & vbTab & "<XNAContentPipelineTargetPlatform>" & strPlatform & "</XNAContentPipelineTargetPlatform>" & vbCrLf & _
vbTab & vbTab & "<OutputPath>" & Me.strExecutingFolder & "\</OutputPath>" & vbCrLf & _
vbTab & "</PropertyGroup>" & vbCrLf & _
vbTab & "<ItemGroup>" & vbCrLf & _
vbTab & vbTab & "<Reference Include=""Microsoft.Xna.Framework.Content.Pipeline.EffectImporter, Version=2.0.0.0, Culture=neutral, PublicKeyToken=6d5c3888ef60e27d, processorArchitecture=MSIL"" />" & vbCrLf & _
vbTab & vbTab & "<Reference Include=""Microsoft.Xna.Framework.Content.Pipeline.FBXImporter, Version=2.0.0.0, Culture=neutral, PublicKeyToken=6d5c3888ef60e27d, processorArchitecture=MSIL"" />" & vbCrLf & _
vbTab & vbTab & "<Reference Include=""Microsoft.Xna.Framework.Content.Pipeline.TextureImporter, Version=2.0.0.0, Culture=neutral, PublicKeyToken=6d5c3888ef60e27d, processorArchitecture=MSIL"" />" & vbCrLf & _
vbTab & vbTab & "<Reference Include=""Microsoft.Xna.Framework.Content.Pipeline.XImporter, Version=2.0.0.0, Culture=neutral, PublicKeyToken=6d5c3888ef60e27d, processorArchitecture=MSIL"" />" & vbCrLf & _
vbTab & "</ItemGroup>"

For Each content As ContentFile In Me.objContent

Me.strContentprojFile &= vbCrLf & _
vbTab & "<ItemGroup>" & vbCrLf & _
vbTab & vbTab & "<Compile Include=""" & content.File.FullName & """>" & vbCrLf & _
vbTab & vbTab & vbTab & "<Name>" & content.Name & "</Name>" & vbCrLf & _
vbTab & vbTab & vbTab & "<Importer>" & CType(content.ContentType, ImporterName).ToString & "</Importer>" & vbCrLf & _
vbTab & vbTab & vbTab & "<Processor>" & CType(content.ContentType, ProcessorName).ToString & "</Processor>" & vbCrLf & _
vbTab & vbTab & "</Compile>" & vbCrLf & _
vbTab & "</ItemGroup>"

Next

Me.strContentprojFile &= vbCrLf & "</Project>"

End Sub

End Class

To see how a Game can utilize the VBContentManager class, see the previous tutorial on the subject, and then read the change log at the top of this post.

Some slight changes can be made to the MyBaseGame class as well. Now that a ContentManager is built into v2.0 of the XNA Game class, you can overload the Content property to return your VBContentManager.

Game Studio 2.0

2007-11-20T08:51:00.000-08:00

Game Studio 2.0 (Beta) has been released. At first glance, it looks like the most significant change (in terms of our VB shenanigans here) is the ContentManager class, and some logistics regarding the Content Pipeline. The VBContentManager class may change to reflect this, as necessary. I'll be taking my first look at it later today.

A big feature now included is networking. I don't really know yet if the networking component of XNA is going to be the most useful when communicating with MS services like XBox Live (et al) or, if you're actually supposed to utilize XNA on the server side of your own client/server game. I would suspect you'd probably just end up rolling your own network code for the custom scenario, but, who knows! We'll cross that bridge when we come to it.

There are some other changes that don't apply to us when using VB (such as the C# Game class template created by the IDE when you start a new Game Project).

VB.NET XNA Tutorial 8: Text

2007-11-17T15:56:00.001-08:00

[GSE 1.0 Refresh]

Text as sprites

In XNA, text gets drawn to the screen in much the same way everything else in our 2D engine is being drawn to the screen: by having SpriteBatch draw sprites.

In order to put "Hello world!" on the screen, we'll need 8 regular sprites that just happen to look like characters. Specifically, we'll need the following sprites that look like:

H
e
l (we can use this one 3 times)
o (can be used twice)
w
r
d
!

Once we've made those sprites (and loaded them into the game), the next step will be to meticulously draw each one, in the right order, in the right place with perfect spacing, so when we're done we end up with words (and don't forget to offset "world!" from "Hello" to simulate a space character between them).

Sound tedious? How about an RPG with ten thousand lines of dialog. Sound daunting? If so, good! You're ready to appreciate the fact XNA can do all of the aforementioned work for you. Not only will it line up the little sprites on the screen for you, it can even create all the sprites for you.

MSBuild & SpriteFont

All we've asked MSBuild to do for us so far is convert our texture content (.png or .jpg, etc.) into .xnb files. The .xnb file format is a "cross-platform" file that can be used on either Windows or the Xbox360. In light of the known compatibility issues with VB.NET and the .NET framework found on the XBox360, why are we bothering to use MSBuild to produce a "cross-platform" file, anyway?

If you're making an XNA app exclusively for Windows, ending up with "cross-platform" content is somewhat incidental (a side-effect of the process). On the other hand, a distinct advantage to using MSBuild and the ContentManager can be found in SpriteFonts.

A SpriteFont starts out life as a small XML file with a ".spritefont" extension that you place in your content folder. The same MSBuild process that takes our texutre images and creates .xnb files can also take a .spritefont file to create another .xnb file - one that contains the characters of a specific font, at a specific size, as described by the contents of the .spritefont XML file. Here's an example of a .spritefont XML file:


<?xml version="1.0" encoding="utf-8"?>
<!--
This file contains an xml description of a font, and will be read by the XNA
Framework Content Pipeline. Follow the comments to customize the appearance
of the font in your game, and to change the characters which are available to draw
with.
-->
<XnaContent xmlns:Graphics="Microsoft.Xna.Framework.Content.Pipeline.Graphics">
  <Asset Type="Graphics:FontDescription">

    <!--
    Modify this string to change the font that will be imported.
    -->
    <FontName>Arial</FontName>

    <!--
    Size is a float value, measured in points. Modify this value to change
    the size of the font.
    -->
    <Size>14</Size>

    <!--
    Spacing is a float value, measured in pixels. Modify this value to change
    the amount of spacing in between characters.
    -->
    <Spacing>2</Spacing>

    <!--
    Style controls the style of the font. Valid entries are "Regular", "Bold", "Italic",
    and "Bold, Italic", and are case sensitive.
    -->
    <Style>Regular</Style>

    <!--
    CharacterRegions control what letters are available in the font. Every
    character from Start to End will be built and made available for drawing. The
    default range is from 32, (ASCII space), to 126, ('~'), covering the basic Latin
    character set. The characters are ordered according to the Unicode standard.
    See the documentation for more information.
    -->
    <CharacterRegions>
      <CharacterRegion>
        <Start>&#32;</Start>
        <End>&#126;</End>
      </CharacterRegion>
    </CharacterRegions>
  </Asset>
</XnaContent>

The C# Express IDE has native support for creating new .spritefont files, you just right-click the project and add one like you were adding a class file. With VB.NET, it's pretty much just as easy. There's no magic here, it's just an XML file. You can bring in an existing .spritefont file from disk, or just make a new text document item in your project, paste in the above code, and rename the file so it has a .spritefont extension. If you place it somewhere in your content folder, the VBContentManager understands to harvest .spritefont files and send them along to MSBuild. Similar to Textures, SpriteFonts are processed by MSBuild and the result is stored onto the VBContentManager as a SpriteFont object in the Fonts hashtable.

Implementation with the VBContentManager

Ok, so how do we use this "SpriteFont object" to get text onto the screen? It's a lot like drawing a texture; the SpriteBatch has a Draw() method for drawing textures, and it has a DrawString() method for drawing text to the screen. The DrawString() method accepts your SpriteFont object as a parameter (as well the text to render using the font, where to render it at, and what color to make it)

'Draws "Hello world!" to the screen, using whatever font definition is found in
'the file "test.spritefont" from the content folder. Draws the string at the
'upper-left corner of the screen in yellow.

Me.objSB.Begin()

Me.objSB.DrawString(Me.objCM.Fonts("test"), "Hello world!", Vector2.Zero, Color.Yellow)

Me.objSB.End()

Without too much fuss, you'll just get the result you expect.

SpriteFont objects feature the MeasureString() method, which you may be familiar with already as it appears elsewhere in .NET, outside of XNA. MeasureString() is just a way to get the width and height of any string (but in a particular font and size), which can be handy for string-size related math (like centering text on the screen, for example).

In the screenshot below, I've placed a sprite font file in my project's Content\Fonts folder called test.spritefont. Test.spritefont specifies Arial at a size of 30. In the main draw loop of the game, I retrieve the SpriteFont object from the game's VBContentManager.Fonts hashtable, and use it's MeasureString method (in conjunction with the BackBufferWidth and BackBufferHeight) to center the text on the screen when calling SpriteBatch.DrawString:

A few quick extras re: the creation of SpriteFont files:

Mono-spaced fonts are not supported by Game Studio Express 1.0 (refresh) (the current version when I wrote this article). Last I heard, mono-spaced font support should make it into Game Studio 2.0.

As an aside, it's probably a reasonable speculation to guess that, due to Game Studio 2.0's compatibility with Visual Studio, it may be possible to simply add a SpriteFont file directly to a VB.NET XNA project after GS 2.0 is released (rather than having to "make your own"). Either way, we would continue to rely on something like the VBContentManager to invoke the MSBuild process in order to get the .xnb file created for us.

And finally, if you are interested in going beyond using the plain old fonts installed on your system, read this. My VBContentManager doesn't support what's discussed there, but you could certainly perform a quick & dirty modification along the lines of "if you find a texture in the fonts folder..." sort of thing.

VB.NET XNA Tutorial 7: Sprites as Game Objects

2007-11-16T21:42:00.000-08:00

[GSE 1.0 Refresh]

Taking a second look at what was designed in Tutorial 6, Tutorial 7 explores how the Sprite class can be more than just a texture on the screen. We'll create a Ship class that derives from Sprite, and end up with something that's more of a "game object" than a "sprite".

This tutorial is only about 14 minutes and is pretty easy stuff; the main focus is basically re-usability of code via object-oriented design. Creating reusable game objects is a concept that will lend itself to things like UI components and Screens and eventually game state management (in future tutorials).

For now, here's Tutorial 7: Sprites as Game Objects.

VB.NET XNA Tutorial 6: The PointAt method

2007-11-15T20:16:00.000-08:00

[GSE 1.0 Refresh]

In the comments for tutorial 5.3, Matt asked a practical question about how to solve a real-world problem using all this matrix cascade stuff; if a ship sprite had a "child" gun turret, how could we get that gun turret to aim at some other sprite on the screen?

Here's a method written to accomplish this task, called PointAt. Accepting two sprites as arguments, it will rotate the first in order to point at the second. This will cut through all the matrix clutter by turning that clutter around and using it to our advantage.

''' <summary>
''' Point one sprite's origin at another sprite's origin
''' </summary>
''' <param name="thePointer">The sprite you want to rotate</param>
''' <param name="theTarget">The sprite you want thePointer to point at</param>
''' <remarks></remarks>
Public Sub PointAt(ByVal thePointer As Sprite, ByVal theTarget As Sprite)

Dim objTargetWorldPosition As Vector2

If theTarget.Parent IsNot Nothing Then
objTargetWorldPosition = Vector2.Transform(theTarget.Location, theTarget.Parent.DrawMatrix)
Else
objTargetWorldPosition = theTarget.Location
End If

thePointer.Rotation = 0

With Vector2.Transform(objTargetWorldPosition, Matrix.Invert(thePointer.DrawMatrix)) - thePointer.Origin

thePointer.Rotation = (CSng(Math.Atan2(.Y, .X)) + (Math.PI / 2))

End With

End Sub

It looks simple, doesn't it? There's some new stuff in there (Matrix.Invert?) so I went ahead and made a video demonstrating what this "simple" method does, adding some slight difficulty for the PointAt method to overcome. The PointAt method is nice because it doesn't really care what we throw at it. It should be able to point any sprite at any other sprite, no matter where either sprite is or how far down any given matrix cascade either sprite happens to be.

Here is the link to Tutorial 6: The PointAt method on Vimeo.

In the video, the steps shown in Photoshop for inverting the matrix are oversimplified a little bit; in actuality, inverting the DrawMatrix of the cannon sprite would also involve un-doing the rotation of the PlayersShip (which would require a lot more steps to simulate in PhotoShop) but the net result is the same.

VB.NET XNA Tutorial 5.3: The Parent/Child Matrix Cascade

2007-11-14T00:48:00.000-08:00

[GSE 1.0 Refresh]

While tutorial 5.3 encodes (...it really takes forever), I'll write a little preface. Things get a little "weird" in tutorial 5.3, so hopefully I'll be making sense.

In the previous tutorial we saw how a sprite can use a matrix to position itself on the screen. We drew kermit to the screen by supplying his matrix to the Begin method of the SpriteBatch, and then supplied his origin to the Draw method. These two separate pieces of data (the matrix and the origin) passed to those two methods worked together to put kermit where we wanted on the screen, and make him rotate how we wanted about his origin.

In tutorial 5.3, we're going merge origin information into the matrix, so that we no longer have our matrix and origin supplied as separate data pieces when we draw; we'll be able to pass a single matrix to Begin without supplying an origin value to Draw.

By incorporating the origin information into the matrix, the matrix becomes a more comprehensive/accurate/complete description of how to place a sprite on the screen. In turn, we can use that matrix to transform other things in addition to the sprite itself (such as the sprite's children).

So we're going to create a simple Parent/Child system, whereby each sprite has a reference to a parent sprite as well as a list of children sprites. This will give us a way to organize groups of sprites together into logical objects, and at the same time it will give us a vehicle for the "matrix cascade". Here's what a "matrix cascade" is designed to accomplish:

Dinner on a Plate

Dinner on a Plate demonstrates the net result of what our engine can do after tutorial 5.3. I thought it might be a good idea to get a clear picture of our goal, without which tutorial 5.3 can be, unfortunately, "a long trip through abstract city".

As you can see in Dinner on a Plate, it's starting to become pretty easy to build a new application that, if nothing else, demonstrates how a mildly complicated positioning exercise can be greatly simplified. In the video, a cookie and a piece of pizza are "put onto a dinner plate", and when the plate is rotated, the pizza and cookie behave as if they are intuitively attached to the plate. There are no laws of physics at work here, the explanation is simply that, as children of the dinner plate, the cookie and the pizza are subject to the dinner plates matrix cascade. This means that every time the dinner plate "changes" (location, rotation, origin or (eventually) scale), the cookie and pizza slice are automatically incorporating the new dinner plate matrix into their own matrices when they draw.

The "exciting" details can be found in Tutorial 5.3 - The Parent/Child Matrix Cascade.

Next tutorials will appear this week

2007-11-12T13:35:00.000-08:00

I don't have to work this week. Ahh... it's so nice.

So now I'm trying to figure out a performance issue since I've added shader effects to my 2D engine. Right now I can script a 2-pass Gaussian blur effect on a per-sprite basis, but this causes the framerate to drop from 300-400fps, down to 18fps when the effect is activated. This is not good :) Figuring it out has my curiosity occupied for the time being.

There will be new tutorial entries this week, continuing with building the sprite class and at some point, introducing the animation script engine.

VB.NET XNA Tutorial 5: Sprites

2007-11-05T09:31:00.000-08:00

[GSE 1.0 Refresh]

Before we get into Screens, ScreenManagers and scripting interfaces, we have to create a Sprite class. It will be the base class that all of those things either inherit from, or are made to manipulate.

I've split the Sprite tutorial into a series of videos, since as it turns out there's a bit to cover. It's not too complicated, but since sprites are the heart & soul of a 2D game, making the Sprite class is a pretty important step.

In the 5.x series of videos below, we'll create a Sprite class from the ground up, and give it the ability to move around. Later on, we'll create Screen objects from this Sprite class, as well as hooking up a scripting interface that can move a Sprite or a Screen. For now, here are the Sprite class tutorials:

Tutorial 5.0: A Sprite class
The basics; adding the Sprite class to the 2D Engine project. This one's pretty easy.

Tutorial 5.1: Implementing a transform matrix
Incorporating a transform matrix into the Sprite class, and using it to put the sprite at various places on the screen. Doesn't go into much detail regarding matrices.

Tutorial 5.2: Coordinate spaces, Origins, and Matrices
I take a crack at explaining how transformation matrices, screen coordinates, and sprite origin all come together for the 2D sprite class. Not necessarily specific to VB, I just think easy-to-follow, non-mathematical tutorials on this subject are in short supply so hopefully this one makes sense and helps someone out. And hopefully I'm not making too many errors...

Tutorial 5.3: Creating a parent/child system
This link takes you to a subsequent post dedicated to the subject.

That's about all I can muster for the weekend. This sprite class gives us a very strong foundation upon which to grow and add some very cool features, so we're not done yet; more to come in the weeks ahead.

Working for the weekend

2007-11-02T13:49:00.001-07:00

Well I'm trying to push a project to the "beta" milestone here at work, so I've been putting all my time into that. I really want to get to the next tutorial because I've got some neat stuff I want to demonstrate. I think I'm going to take some anti-burnout time away from work pretty soon as well, which will let me play with the XNA stuff. Never the less, I should have time this weekend to put together tutorial 5.

I have a 2D sprite scripting interface coming along that I'm just about ready to use in the next tutorail. The scripting engine is lacking a couple features, but it's got more than enough functionality to demonstrate it as a system that works, so we'll step through building it from the ground up and learn how we can control sprite movement over time. So far the scripting interface can perform movement along a linear vector, movement over a bezier curve, rotate, scale, change texture, change origin, change tint, and just recently I added the ability to repeat arbitrary subsets of script, allowing you to create animation loops from any of those features. Later on down the road, it will be reasonably trivial to add just about anything, even post-processing effects like bloom or Gaussian blur (something I have in late stages development at the moment, but it's not quite ready).

The scripting engine works in tandem with a parent/child sprite class that implements a "cascading matrix" scheme. That means if you have a screen with a bunch of sprites on it, the screen is the "parent" and the sprites are the "children". You can use the scripting engine to rotate just one individual child on the screen, or, you could rotate the entire screen which would effectively rotate all the sprites. Like rotating a dinner plate, all the stuff on the plate goes along for the ride. I'll show you how it all works in the next tutorial, it's not too complicated and it gives you enough flexibility to start doing meaningful stuff on the screen.

Coming up

2007-10-28T16:36:00.000-07:00

Coming up in the next tutorial, we'll demonstrate a way you can organize the objects you want to see on the screen into a hierarchy of nested container objects (Sprites, Components and Screens). We'll create a Screen Manager class that will allow us to easily switch from one Screen to another. We'll also start animating things by having all of our objects implement a scripting interface.

I've been working on real-world stuff for my job this week (and weekend) but I should have time to put together the next tutorial over the next week or so.

VB.NET XNA Tutorial 4: Starting an engine, and the VBContentManager

2007-10-21T23:08:00.000-07:00

[GSE 1.0 Refresh]

Here's the link to Tutorial 4: Starting an engine on Vimeo.

This tutorial is a little bit longer and a little bit more involved than the past tutorials. We'll start down the road to separating game logic from game logistics by creating a new project called XNA 2D Engine and moving the "MyGame" class into it. We'll turn the MyGame into a base class to be used with the 2D engine.

We'll introduce the VBContentManager class, my implementation of a ContentManager extended with our "VB Content Pipeline hack" code (there's lots more on that, below). We'll then go on to making a primitive sprite in Photoshop and drawing it to the screen with a SpriteBatch object.

Here is some companion text to go with the video, that describes in detail some code I'll be importing but not spending a lot of time describing in the video:

In a standard C# XNA project, the default game class is created for you with a GraphicsDeviceManager and a ContentManager both instantiated and ready to go. As we saw in Tutorial 3, it's fairly easily make our own class that inherits from the base XNA Game class, create our own GraphicsDeviceManager and quickly reproduce what the C# template generates automatically.

What tutorial 3 did not touch on was the ContentManager, because for us VB'ers, the ContentManager is really the point where the lack of VB support in XNA requires us to do a little bit of legwork, so I held off on the subject until now.

In C#, the ContentManager class loads cross-platform file types (like .xnb files) that MSBuild creates automatically from things like .png or .jpg files that get included in the C# project. The primary issue when using a ContentManager with VB is getting these .xnb files created from our .png or .jpg files, because there is no automatic conversion process built into the IDE.

My approach to solving this problem was to borrow largely what's been documented by Alan Phipps, and from that, create my own ContentManager class called the VBContentManager class. Here's is the VBContentManager class, in it's entirety:

Public Class VBContentManager
Inherits ContentManager

Public Fonts As Hashtable(Of SpriteFont)
Public Textures As Hashtable(Of Texture2D)
Public SubTextures As Hashtable(Of Hashtable(Of Rectangle))
Public Sounds As Hashtable(Of SoundBank)

Private strFakeCSharpProject As String
Private strContentRootFolder As String
Private strPipelineRootFolder As String
Private objContent As List(Of ContentFile)
Private intDupeSound, intDupeTexture, intDupeFont As Integer

Public Enum ContentTypes
Textures = 0
Fonts = 1
Sounds = 2
End Enum

Private Enum ImporterName
TextureImporter = 0
FontDescriptionImporter = 1
XactImporter = 2
End Enum

Private Enum ProcessorName
SpriteTextureProcessor = 0
FontDescriptionProcessor = 1
XactProcessor = 2
End Enum

Public Structure ContentFile

Public ContentType As ContentTypes
Public File As System.IO.FileInfo
Public Name As String

Public Sub New(ByVal ContentType As ContentTypes, ByVal ContentFile As System.IO.FileInfo, ByVal Name As String)
Me.ContentType = ContentType
Me.File = ContentFile
Me.Name = Name
End Sub

End Structure

''' <summary>
''' Creates a new ContentManager which has been extended with functionality to support a Visual Basic (or other non-C#) project
''' </summary>
''' <param name="ServiceProvider">Your game has a .Services property; send that in here.</param>
''' <param name="ContentRootFolder">The root of your content folder, relative to your projects bin\Debug folder.</param>
''' <remarks></remarks>
Public Sub New(ByVal ServiceProvider As IServiceProvider, ByVal ContentRootFolder As String)

MyBase.New(ServiceProvider)

Me.strContentRootFolder = ContentRootFolder
Me.strPipelineRootFolder = ContentRootFolder.Replace("../", "")

Me.Fonts = New Hashtable(Of SpriteFont)
Me.Textures = New Hashtable(Of Texture2D)
Me.SubTextures = New Hashtable(Of Hashtable(Of Rectangle))
Me.Sounds = New Hashtable(Of SoundBank)

End Sub

''' <summary>
''' Load all assets that have been compiled by a VBContentManager.
''' </summary>
''' <param name="Compile">Whether or not to have MSBuild compile your game content before attempting to load it</param>
''' <remarks></remarks>
Public Sub LoadPipeline(ByVal Compile As Boolean)

If Compile Then
Me.CompileContent()
End If

For Each obj As ContentFile In Me.objContent

Try

Select Case obj.ContentType

'The pipeline will be compiled into either debug or release, depending upon
'which option is chosen in the IDE. We don't want to use the My namespace
'though, because it does not work with the xbox 360.

Case ContentTypes.Fonts

With obj.File.FullName.ToLower
Me.Fonts.Add(obj.Name, Me.Load(Of SpriteFont)(.Substring(.LastIndexOf("\" & Me.strPipelineRootFolder.ToLower) + 1).Replace(obj.File.Extension.ToLower, "")))
End With

Case ContentTypes.Sounds

With obj.File.FullName.ToLower
Me.Sounds.Add(obj.Name, Me.Load(Of SoundBank)(.Substring(.LastIndexOf("\" & Me.strPipelineRootFolder.ToLower) + 1).Replace(obj.File.Extension.ToLower, "")))
End With

Case ContentTypes.Textures

With obj.File.FullName.ToLower
Me.Textures.Add(obj.Name, Me.Load(Of Texture2D)(.Substring(.LastIndexOf("\" & Me.strPipelineRootFolder.ToLower) + 1).Replace(obj.File.Extension.ToLower, "")))
End With

End Select

Catch ex As Exception

'msgBox("While loading the pipeline, a piece of content called " & obj.Name & " could not be found, and was skipped")

'A new piece of content has been added, but the programmer failed
'to instruct the VBContentPipeline to compile it. So the content
'will not be available during this instance of the Game.

End Try

Next

End Sub

Private Sub CompileContent()

Dim objProcess As Process

Me.objContent = New List(Of ContentFile)

Me.HarvestContent()

If Me.objContent.Count > 0 Then

Me.StartTheFakeCSharpFile()

Me.AddContentToTheFakeCSharpFile()

Me.EndTheFakeCSharpFile()

Try 'to write the fake C# project file to disk

Using TempStreamWriter As System.IO.StreamWriter = New System.IO.StreamWriter(Me.strContentRootFolder & "\VBContentPipeline.csproj", False)

With TempStreamWriter

.Write(Me.strFakeCSharpProject)
.Close()

End With

End Using

Try 'to shell out to MSBuild.exe, sending it our fake c# project file

objProcess = System.Diagnostics.Process.Start("""" & Environment.GetEnvironmentVariable("Windir") & _
"\Microsoft.NET\Framework\v2.0.50727\MSBuild.exe""", """" & Me.strContentRootFolder & _
"\VBContentPipeline.csproj"" /verbosity:d /l:FileLogger,Microsoft.Build.Engine;logfile=""" & _
Me.strContentRootFolder & "\VBPipelineBuild.log""")

'wait for that to finish

While Not objProcess.HasExited
Threading.Thread.Sleep(100)
End While

Catch ex As Exception

MsgBox("When building the pipeline and trying to run MSBuild.exe, " & ex.Message)

End Try

Catch ex As Exception

MsgBox("When building the pipeline and trying to create the fake C# file """ & Me.strContentRootFolder & "\VBContentPipeline.csproj"", " & ex.Message)

End Try

End If

End Sub

Private Sub HarvestContent()

Dim objRoot As System.IO.DirectoryInfo = New System.IO.DirectoryInfo(Me.strContentRootFolder)

For Each sound As System.IO.FileInfo In objRoot.GetFiles("*.xab", IO.SearchOption.AllDirectories)
If Me.objContent.Contains(New ContentFile(ContentTypes.Sounds, sound, sound.Name.Replace(sound.Extension, ""))) Then
Me.intDupeSound += 1
Me.objContent.Add(New ContentFile(ContentTypes.Sounds, sound, sound.Name.Replace(sound.Extension, "") & Me.intDupeSound.ToString))
Else
Me.objContent.Add(New ContentFile(ContentTypes.Sounds, sound, sound.Name.Replace(sound.Extension, "")))
End If
Next

For Each texture As System.IO.FileInfo In objRoot.GetFiles("*.png", IO.SearchOption.AllDirectories)
If Me.objContent.Contains(New ContentFile(ContentTypes.Textures, texture, texture.Name.Replace(texture.Extension, ""))) Then
Me.intDupeTexture += 1
Me.objContent.Add(New ContentFile(ContentTypes.Textures, texture, texture.Name.Replace(texture.Extension, "") & Me.intDupeSound.ToString))
Else
Me.objContent.Add(New ContentFile(ContentTypes.Textures, texture, texture.Name.Replace(texture.Extension, "")))
End If
Next

For Each texture As System.IO.FileInfo In objRoot.GetFiles("*.jpg", IO.SearchOption.AllDirectories)
If Me.objContent.Contains(New ContentFile(ContentTypes.Textures, texture, texture.Name.Replace(texture.Extension, ""))) Then
Me.intDupeTexture += 1
Me.objContent.Add(New ContentFile(ContentTypes.Textures, texture, texture.Name.Replace(texture.Extension, "") & Me.intDupeSound.ToString))
Else
Me.objContent.Add(New ContentFile(ContentTypes.Textures, texture, texture.Name.Replace(texture.Extension, "")))
End If
Next

For Each texture As System.IO.FileInfo In objRoot.GetFiles("*.gif", IO.SearchOption.AllDirectories)
If Me.objContent.Contains(New ContentFile(ContentTypes.Textures, texture, texture.Name.Replace(texture.Extension, ""))) Then
Me.intDupeTexture += 1
Me.objContent.Add(New ContentFile(ContentTypes.Textures, texture, texture.Name.Replace(texture.Extension, "") & Me.intDupeSound.ToString))
Else
Me.objContent.Add(New ContentFile(ContentTypes.Textures, texture, texture.Name.Replace(texture.Extension, "")))
End If
Next

For Each font As System.IO.FileInfo In objRoot.GetFiles("*.spritefont", IO.SearchOption.AllDirectories)
If Me.objContent.Contains(New ContentFile(ContentTypes.Fonts, font, font.Name.Replace(font.Extension, ""))) Then
Me.intDupeFont += 1
Me.objContent.Add(New ContentFile(ContentTypes.Fonts, font, font.Name.Replace(font.Extension, "") & Me.intDupeSound.ToString))
Else
Me.objContent.Add(New ContentFile(ContentTypes.Fonts, font, font.Name.Replace(font.Extension, "")))
End If
Next

End Sub

Private Sub StartTheFakeCSharpFile()

Me.strFakeCSharpProject = _
"<Project DefaultTargets=""Build"" xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">" & vbCrLf & _
"<PropertyGroup>" & vbCrLf & _
"<Configuration Condition="" '$(Configuration)' == '' "">Debug</Configuration>" & vbCrLf & _
"<Platform Condition="" '$(Platform)' == '' "">x86</Platform>" & vbCrLf & _
"<OutputType>WinExe</OutputType>" & vbCrLf & _
"<AppDesignerFolder>Properties</AppDesignerFolder>" & vbCrLf & _
"<AssemblyName>" & My.Application.Info.AssemblyName & "</AssemblyName>" & vbCrLf & _
"<XnaPlatform>Windows</XnaPlatform>" & vbCrLf & _
"<XnaFrameworkVersion>v1.0</XnaFrameworkVersion>" & vbCrLf & _
"<XNAGlobalContentPipelineAssemblies>Microsoft.Xna.Framework.Content.Pipeline.EffectImporter.dll;" & _
"Microsoft.Xna.Framework.Content." & _
"Pipeline.FBXImporter.dll;Microsoft.Xna.Framework.Content.Pipeline.TextureImporter.dll;" & _
"Microsoft.Xna.Framework.Content.Pipeline.XImporter.dll</XNAGlobalContentPipelineAssemblies>" & vbCrLf & _
"</PropertyGroup>" & vbCrLf & _
"<PropertyGroup Condition="" '$(Configuration)|$(Platform)' == 'Debug|x86' "">" & vbCrLf & _
"<OutputPath>" & My.Application.Info.DirectoryPath & "\" & Me.strPipelineRootFolder & "</OutputPath>" & vbCrLf & _
"</PropertyGroup>" & vbCrLf & _
"<ItemGroup>"

End Sub

Private Sub AddContentToTheFakeCSharpFile()

For Each content As ContentFile In Me.objContent

Me.strFakeCSharpProject &= vbCrLf & _
"<Content Include=""" & content.File.FullName & """>" & vbCrLf & _
"<XNAUseContentPipeline>true</XNAUseContentPipeline>" & vbCrLf & _
"<Importer>" & CType(content.ContentType, ImporterName).ToString & "</Importer>" & vbCrLf & _
"<Processor>" & CType(content.ContentType, ProcessorName).ToString & "</Processor>" & vbCrLf & _
"<Name>" & content.Name & "</Name>" & vbCrLf & _
"</Content>"
Next

End Sub

Private Sub EndTheFakeCSharpFile()

Me.strFakeCSharpProject &= _
"</ItemGroup>" & vbCrLf & _
"<Import Project=""$(MSBuildBinPath)\Microsoft.CSharp.targets"" />" & vbCrLf & _
"<Import Project=""$(MSBuildExtensionsPath)\Microsoft\XNA\Game Studio Express\v1.0\Microsoft.Xna.ContentPipeline.targets"" />" & vbCrLf & _
"<Import Project=""$(MSBuildExtensionsPath)\Microsoft\XNA\Game Studio Express\v1.0\Microsoft.Xna.Common.targets"" />" & vbCrLf & _
"</Project>"

End Sub

End Class

In a nutshell, the VBContentManager class uses a supplied directory as a root folder which it scans for content (texture files, XACT sound projects, and spritefonts) in the HarvestContent method. It also has the ability to produce a C# project file that includes information about the harvested content, which it can pass to MSBuild in order to have the corresponding .xnb (et al) files created on your behalf.

To use the VBContentManager class, all you have to do is call the LoadPipeline method in your game's LoadGraphicsContent sub, indicating whether or not the content is already compiled (false) or whether you want to execute the C# hack process (true).

The last thing the LoadPipeline method does for you is it uses the Load method of the underlying ContentManager to import the texture, sound and font files into corresponding typed hash tables, which reside as public members of the VBContentManager. The resources are keyed by filename (no extension) in the respective hash table.

Here is an example of a simple base game class that makes use of the VBContentManager class (you can also watch the video tutorial to see this class being used by a game project).

Public Class MyBaseGame
Inherits Game

Protected objGDM As GraphicsDeviceManager
Protected objCM As VBContentManager
Protected objSB As SpriteBatch

''' <summary>
''' Starts a new game for the XNA 2D Engine
''' </summary>
''' <param name="WindowTitle">The window title when the game is not full-screen</param>
''' <param name="MouseIsVisible">Whether or not the mouse is visible by default</param>
''' <param name="ContentRootFolder">The root of your content folder, relative to your projects bin\debug (or release) folder</param>
''' <remarks></remarks>
Public Sub New(ByVal WindowTitle As String, ByVal MouseIsVisible As Boolean, ByVal ContentRootFolder As String)

Me.objGDM = New GraphicsDeviceManager(Me)
Me.objCM = New VBContentManager(Me.Services, ContentRootFolder)

Me.Window.Title = WindowTitle

Me.IsMouseVisible = MouseIsVisible

End Sub

Protected Overrides Sub LoadGraphicsContent(ByVal loadAllContent As Boolean)
MyBase.LoadGraphicsContent(loadAllContent)

Me.objCM.LoadPipeline(True)

End Sub

Protected Overrides Sub Initialize()
MyBase.Initialize()

Me.objSB = New SpriteBatch(Me.objGDM.GraphicsDevice)

End Sub

End Class

Here is a game that inherits from the above base game class. The root content folder for this game is a peer folder of the project's bin folder. Once you've got all the other stuff sitting in an engine somewhere, this is essentially all you need to do to spawn a new game with a vb content manager, effectively simulating VB support for XNA.

Public Class XNAGameForWindows
Inherits MyBaseGame

Public Sub New()
MyBase.New("XNA Game for Windows", True, "../../Content")
End Sub

End Class

And here's the typed hash table. I wouldn't grab textures & the like out of a hash tables directly from a draw routine, but at the top of your program you can pull them out into discrete references or put them into lists, or whatever. The VBContentManager just makes them available in the hash in a way that's easy for humans to find them (ie. by file name), and you can do whatever you want with them from there.

Public Class Hashtable(Of Type)
Inherits DictionaryBase

Public ReadOnly Property Keys() As ICollection
Get
Return MyBase.Dictionary.Keys
End Get
End Property

Default Public Property Item(ByVal key As String) As Type
Get
Return CType(MyBase.Dictionary(key), Type)
End Get
Set(ByVal value As Type)
MyBase.Dictionary(key) = value
End Set
End Property

Public Overloads Sub Add(ByVal key As String, ByVal obj As Type)
MyBase.Dictionary.Add(key, obj)
End Sub

Public ReadOnly Property Values() As ICollection
Get
Return Dictionary.Values
End Get
End Property

Public Function Contains(ByVal key As String) As Boolean
Return Dictionary.Contains(key)
End Function

Public Sub Remove(ByVal key As String)
Dictionary.Remove(key)
End Sub

End Class

VB.NET XNA Tutorial 3: Creating a Game class

2007-10-17T14:58:00.001-07:00

[GSE 1.0 Refresh]

There is now a Visual Studio template for starting a VB.NET XNA Windows Game project. This template automates the steps shown in the video.

First, read this!

Video tutorials are now hosted at Vimeo in High Definition

Be sure to watch them in Full mode

If your video quality goes all wacky, look in the lower right for a Scaling button and turn Scaling off (this will make life easier on the player and allow the quality to go back up)

You can't embed HD vids from Vimeo to your website, otherwise I would!

Ok, that's it. Here's the link to Tutorial 3: Creating a Game class on Vimeo.

Vimeo

2007-10-15T12:18:00.000-07:00

Vimeo's like YouTube, but Vimeo lets you host HD quality videos that look worlds better than YouTube. The only catch is you can't embed HD quality stuff off-site (you have to watch them directly from Vimeo's website, which I'm sure it's an add-revenue thing that makes it all possible to begin with).

But check out the kind of quality you can get hosted for free, it's pretty cool. This is just my test upload, and if you play it full screen you'll see what I'm talking about:

Test #9 @ Vimeo.com

So from now on any video tutorials I make will be hosted at Vimeo and I've got a namespace setup there which I'll add to the permalinks.

VB.NET XNA Tutorial 2: Creating an XNA Windows Game project

2007-10-13T19:41:00.000-07:00

[GSE 1.0 Refresh]

There is now a Visual Studio template for starting a VB.NET XNA Windows Game project. This template automates the steps shown in the video.

Here is a video tutorial that describes very simply how to setup a "game" project for Windows using VB.NET and Visual Studio 2005.

Tutorial 2: Creating an XNA Windows Game project from emachine on Vimeo.

VB.NET XNA Tutorial 1: Getting started

2007-10-12T18:35:00.000-07:00

First things first; let's get this whole XNA thing straight.

The XNA framework is a managed wrapper for DirectX. So you'll need the latest version of DirectX installed.

XNA comes to you branded in a somewhat vaguely (and soon to be confusingly) named piece of software called "Game Studio Express". The deal is, Microsoft diverted their previous Managed DirectX project into the XNA project; the XNA project grew to include not only a managed wrapper for DirectX, but also some other tools like the Content Pipeline, and XACT. All of this was then wrapped into a software suite - not called XNA - but actually called "Game Studio Express", which was designed specifically to be an "expansion pack" of sorts for Visual C# 2005 Express Edition.

So anyway... what this all means for us VB freaks is that in order to get the managed wrapper for DirectX on our development machines, and in order to have at that Content Pipeline and XACT stuff, we have to do what everybody else has to do: install Visual C# 2005 Express Edition, and then install Game Studio Express. Which is all the more counter-intuitive for us, since our goal is to avoid using C# in the first place because we're too lazy to start using curly braces and semi-colons.

Don't worry. But you'd better get crackin'; you've got some progress bars to baby sit and many a "Next" button in your future. Enjoy it, involve a beverage perhaps.

Once you've got Game Studio Express installed, your newly acquired C# IDE gains XNA-related project options that no other IDE gets. To learn a little bit about what we're going to be missing out on in terms of XNA-related IDE options, let's go ahead and poke around the C# IDE for a sec. Run the C# IDE, and start a New Project - check out the types of projects you can start:

Go ahead and start a new Windows Game project, just to look around. Pop open the solution explorer and add a new Item to the project; check out what options we have available for creating New Items in the C# IDE:

Using the C# IDE, there are nifty items available like "Sprite Font" and "Game Component":

So those are Game Studio Express IDE hooks, they're just templates for making stuff. Nothing we can't handle ourselves.

Ok, we've seen enough. Cancel all that business and let's move over to our Visual Basic IDE.

Game Studio Express isn't going to do anything for our Visual Basic IDE, so if you go looking for a Windows Game project you're going to be disappointed

Update: The remainder of this tutorial is obsolete. A VB.NET XNA Windows Game project template for use with Visual Studio 2005 and Game Studio 2.0 Beta was posted on this blog in November 2007

But, what it has done is installed the managed XNA libraries, the Content Pipeline compiler, and tools like XACT. We've got everything we need to do some serious damage, there's just a couple things we'll have to do that the C# guys don't have to:

1. We will need to initiate our own project, rather than use the Game project template. And that means we'll have to create those nifty items like "Game Component" and "Sprite Font" by ourselves, too.

In tutorial 20, Alan Phipps demonstrates how to start an XNA Windows Game using the Visual Studio .NET IDE.

In addition to the advice he gives there, I would suggest removing the System.Drawing reference from your project, as this can create an ambiguity with items of the same name (such as Color and Rectangle) that exist in the XNA namespace.

I also suggest you not wait until tutorial 20 to start making your XNA projects in this way, but hindsight is 20/20.

2. We'll want to use the Content Pipeline, because it's fairly cool. The Content Pipeline has some rules though - mainly it wants us to convert our resources into a "cross platform format" (something that works on both Windows and XBox360). So for example, if you have a sprite texture that's a .gif file, the Content Pipeline will want that to be an .xnb file. And sounds are even more wacky. If you make a sound resource with XACT, it will actually need to be broken down into 3 files: an .xgs file, .xsb file, and .xwb file. Yea, I know. This sounds crazy already and we haven't even started yet. Hang in there, we're almost done:

The Content Pipeline hassle does seems kind of unnecessarily complicated at first. You'll like it though, I promise (and you don't have to remember those file extensions). Here's the deal: out in your 's .NET 2.0 framework folder there is a program called MSBuild.exe. MSBuild knows how to convert textures (like "spaceship.png") and sound projects you create with XACT into all those .x-blah-blah files for the Content Pipepline. It's actually really easy; MSBuild does all the work for you. You just tell it what you want to convert (pass it file names in a batch) and it converts them all for you.

Now here's the catch; the way you "tell MSBuild to convert stuff in a batch" is to pass it a C# project file. Yea, like "WindowsGame1.csproj". Which kinda makes sense when you remember that all this stuff was designed to work with Visual C# Express Edition projects. MSBuild takes a .csproj file and for each resource it finds described in there, it creates a Content Pipeline .x-whatever file. With C# projects, this call to MSBuild is performed at the time the project is compiled. In XNA marketing lingo they call this "automatic". For us this will be a "manual" process... but we're lazy, so we'll automate it, and at the end of the day it'll end up being just as automatic as the next guy's.

In tutorial 21, Alan Phipps demonstrates how he simply builds a "fake" .csproj file with his resource references in it, and then feeds that file to MSBuild in order to trick it into thinking it's processing a C# XNA project.

Not bad! So I do the same thing, but I chose to integrate this process into my engine with a "compile" flag (rather than have it be a separate project that must be run). I'll show you how I did this in the next tutorial, and between the two you can choose to do it my way, Alan's way, or say "screw this, I'm using C#"

That's it for Tutorial 1. A little bit of dry reading, but rather than do a bunch of stuff the "wrong" way then refactor it later to the "right" way, I'd rather we just start out understanding the right way to do it. And if you managed to cram all of that into one sitting, you're doing better than I did when I first tried to understand all this stuff.

In the next article, we'll check out my adaptations of the "Start a new project" and "deal with the Content Pipeline hack" and I'll probably start brushing up against the merits of putting all of this stuff into a common project you can reuse for future games (in other words, we'll start building the engine).

VB.NET code posting tool now available

2007-10-11T00:28:00.000-07:00

My vb.net source code posting tool is now online and can be found on my personal web server at http://www.reddinghaze.com/codeformatter.aspx.

You can optionally assign width and height to the output div and toggle whether or not it scrolls overflow. Here's some output generated by the code posting tool (a chunk of the code posting tool page's own code... run through itself... trippy!

 Public Class codeformatter
    Inherits Page

    Private txtInput, txtOutput, txtWidth, txtHeight As TextBox
    Private chkScroll As CheckBox
    Private objForm As HtmlForm
    Private WithEvents btnFormat As Button

    Private Tokens As New System.Collections.Generic.List(Of String)
    Private Keywords As New System.Collections.Generic.List(Of String)

    Protected Sub Page_Init(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Me.Init

        Me.InitializeControls()

        Me.Controls.Add(New LiteralControl("<html><head><title>emachine's vb.net post formatter</title></head><body><center><h1>emachine's vb.net post formatter*</h1>" & _
            "<font size=""2"">*now with zero aesthetic appeal</font>"))

        Me.Controls.Add(Me.objForm)

        With Me.objForm
            .Controls.Add(New LiteralControl("<br />Paste from your IDE <font size=""2"">(tip: Ctrl+A, Ctrl+V)</font><br />"))
            .Controls.Add(Me.txtInput)
            .Controls.Add(New LiteralControl("<br />width:"))
            .Controls.Add(Me.txtWidth)
            .Controls.Add(New LiteralControl("px, height:"))
            .Controls.Add(Me.txtHeight)
            .Controls.Add(New LiteralControl("px "))
            .Controls.Add(Me.chkScroll)
            .Controls.Add(New LiteralControl("<br /><br />"))
            .Controls.Add(Me.btnFormat)
            .Controls.Add(New LiteralControl("<br /><br />Copy to your blog <font size=""2"">(tip: Ctrl+A, Ctrl+C)</font><br />"))
            .Controls.Add(Me.txtOutput)
        End With

        Me.Controls.Add(New LiteralControl("Preview:<br />"))

        'etc.

Oh yea, it knows the difference between keywords and properties now, too:

 If ItsAClass.End Then
    "No more blue .Ends!"
End If

Great bugs err alike

2007-10-10T14:30:00.001-07:00

So as I've mentioned I'm working on a source-code formatter and it currently has this, uh, "feature" where it doesn't quite know the difference between a keyword and a class member of the same name. Given the input "MyClass.End" where End is a keyword, it will erroneously produce the output "MyClass.End" rather than "MyClass.End".

But today I noticed something which made me feel slightly less dumb about that. If you see the post of mine on the xna forums where I used the xna forums code posting tool, check out the 3rd-to-last line of the code block.

Perhaps the xna forum web programmer was drinking and watching TV while they wrote the code posting tool :)

Code posting tool in the works

2007-10-10T01:47:00.001-07:00

If I'm going to have a blog about coding I'll probably want to post source code now and then. But I couldn't find a VB.NET source -> HTML formatter anywhere, so I'm writing a little online utility to facilitate a relatively painless/intuitive "copy & paste" from the IDE into HTML for posting/blogging.

It's still beta-ish, just worked on it for an hour or so last night. Here's a sample of it's output, it's my current XNA game's Draw method, copied & pasted from the IDE into the processor, then from the processor into this blog's HTML editor:

    Protected Overrides Sub Draw(ByVal gameTime As Microsoft.Xna.Framework.GameTime)

        XNALib.GraphicsDeviceManager.GraphicsDevice.Clear(ClearOptions.Target, Me.objFrameColor, 1.0F, 0)
        ScreenManager.Root.Draw(gameTime)

        MyBase.Draw(gameTime)

        XNALib.RenderDebugOptions()

        'calculate fps data

        Me.intFrames += 1
        Me.objOneSecond += gameTime.ElapsedGameTime

        'update this information every [gametime] elapsed second

        If Me.objOneSecond.TotalSeconds >= 1 Then

            Me.strActualFPS = Math.Round((Me.intFrames / Me.objOneSecond.TotalSeconds) * Me.objOneSecond.TotalSeconds, 1).ToString
            Me.objOneSecond -= Me.objOneSecond
            Me.intFrames = 0

        End If

        If XNALib.ShowFPS Then

            'render
            XNALib.SpriteDrawer.Begin()

            XNALib.SpriteDrawer.DrawString(XNALib.Fonts("dialog"), Me.strActualFPS & " fps", Vector2.One, New Color(0, 0, 0, 175))
            XNALib.SpriteDrawer.DrawString(XNALib.Fonts("dialog"), Me.strActualFPS & " fps", Vector2.Zero, Color.Red)

            XNALib.SpriteDrawer.End()

        End If

    End Sub

Not half bad, considering I was drinking and watching TV while I wrote it. Basically it just sets the font and the spaces to be non-breaking, re-colors keywords, comments and literal strings to the default Visual Studio 2005 IDE colors. No biggie, but oddly enough I couldn't find a (free) tool that does this anywhere online.

It's just about good as-is, before I "release" it I do need to teach it the difference between keywords and properties (i.e., MyClass.End isn't quite right, which you can see did in fact happen on the 3rd to last line in the above sample).

And before I put it out there I want to add some quick options, like whether or not to restrict the dimensions of the output div container, whether or not the container scrolls, and maybe even toss in BBCode support.

Basic doesn't really have that many tokenization characters, maybe half a dozen or so and that's it. So this was pretty easy to tackle. I'm not a C# programmer and I dunno how how many tokenization chars they have, but if it's not too crazy I could add C# support.

The utility won't beautify your code like the IDE does, it just recovers formatting lost in the copy & paste process from the IDE to the web using whatever you paste into it verbatim.

VB.NET XNA Tutorial 0: Prologue

2007-10-09T12:50:00.000-07:00

I hesitated a little bit about doing this VB.NET related XNA blog stuff for a couple of reasons. First, there's a new version of Game Studio Express on the way out shortly (version 2.0) which has support for Visual Studio 2005. That means very soon, you will no longer be required to use Visual C# Express for XNA related IDE features.

But unfortunately, support for Visual Studio 2005 doesn't equate to support for languages other than C#. Here's a good thread on the subject over at the xna forums, the meat of which is captured in this post by Shawn Hargreaves (one of Microsoft's XNA guys)

"... we are only doing IDE work to integrate the XNA Framework into the C# project system, and not currently supporting the project systems for any other languages. In the absence of this IDE work, you miss out on exactly two things:
Content pipeline integration
The ability to deploy and debug on Xbox 360
Now, you may be just fine without those things. Maybe you're making a Windows game that doesn't use the Content Pipeline. In that case you don't care about our IDE integration, so the lack of it will not hurt you, and you can use any .NET langauge you like.

If you want to use the Content Pipeline, or deploy to Xbox, you can still do that by building your other-language code into an assembly, then using a stub C# project that links with this assembly to build your content, deploy to Xbox, and then call into your real assembly as soon as it starts up. It's a hack, but some people have reported success working this way."

So that means for the immediate to long term, we're officially "XNA hackers". I dunno about you but that makes me feel like a rebel.

Anyway, the other reason I thought twice about this was the fact that, over at Alan Phipps's website (which is permalinked right over there in the links area), a lot of this has been explained already. After following the tutorials and gaining a little bit of insight into the process, I've decided I'm going to offer you my take on it. Rather than build a specific application for a specific task (which a lot of tutorials seem to do), here we'll be building something a little more generic; more of an engine that can be used to do "whatever" in 2D. Some of it will be "here's how you do it", and some of it will be me showing up to the party 5 months late with "omg I didn't even know about render targets! Holy crap, now we have to totally rewrite the engine!"

At any rate, you'll have a couple different sources to draw from when it comes to using XNA with VB.NET, and there's really not much of that floating around the net right now.

Sub Main()

2007-10-08T14:44:00.000-07:00

Just my boring 1st post when setting up the blog. There's nothing real interesting here.

I'm building a 2D engine with XNA, using Visual Basic .NET & Visual Studio 2005. The purpose of the engine will be to provide a front end for a vaporware game I want to write someday in my free time (there's a lot to be blogged about that later), and at the same time, I'll be using the engine to drive some touch-screen applications I'll be writing for my employer. Work on my game is almost entirely conceptual so far, but the engine itself is being used in the real world and being worked on quite regularly.

A significant portion of the engine is actually written, but as I go along I learn new things about XNA and from time to time I change stuff about it. You know how it goes.

So why bother with this blog, since there are so many more knowledgeable people out there than me? I just want to try and help fill the massive gaps in VB.NET XNA examples on the web. Whenever I feel like I've designed something worth mentioning, I'll try to take some time to post examples.