For me the conference really began at Day 0 when I had the opportunity to meet with lots of folks from the AI Guild including the opportunity to finally meet Alex Champandard from AIGameDev.com who literally felt like a celebrity at the event. Speaking of AIGameDev, I got to speak with two very cool contributors from the Sanbox project, Ken Short and Radur (I hope I’m spelling this right since I never got a business card *hint hint*). I met with two long time friends and people who I feel like I already owe a lot to; Dave Mark, and Neil Kirby. While I’ve followed Dave around the states throughout 2009 as well as joined him on some Team Fortress 2 skirmishes, it was a real pleasure to shake hands with Neil Kirby once again. With that being said, Neil introduced me to this year’s Eric Dybsand scholarship recipient Gabriel Deyerle who I felt like I instantly became friends with, and speaking of scholarship recipients I met Victoria Smith for the second time who was the third recipient of the scholarship in 2009. Only missing Andrew Armstrong, Neil was nice enough to take a picture which I hope to post into here once he gets around to uploading it onto flickr. And speaking of flickr do check out the AI Game Programmer’s Guild group at http://www.flickr.com/groups/agpg/. To wrap up Day Zero I met with three other speakers of the AISummit, Borut Pfeifer, Chris Jurney and the great Emily Short.

Day One officially began as I made my from the Union Square Hotel and made sure to get an early seat while watching Dave and Chris go through some last minute set up work.

10am-11am
The first session began with three case studies on recent AI trends. Tara Teich (Double Fine Productions) spoke about the challanges in Brutal Legends when it came to integrating 50+ unit types of various sizes, proportions, attacks combinations with the main avatar, and the design decisions of the AI Avatar character. This reminded me a bit of my own game from full sail when creating Amoeba Sports. Creating a believable AI opponent that resembles that of the human player’s avatar is a very daunting task. Tara explained that for the AI Avatar they kept his behavioral priority to something like the following:

1. Retreat if low Health
2. Capture Resources
3. Defend the Base
4. Join a battle in progress
5. Hang out with the largest army and look cool

Tara also mentioned their flat state machine that utilized “Utility” functions for transitions.

Alex Champandard gave a talk on Killzone II AI with how they integrated bots into almost everything they did. Killzone II bots’ greatest challenge being the ability to adapt to various maps, and class combinations. This was handle using the standard logic separation between strategy, squad based, and individual AI systems. Alex stressed the heavy use of annotation and referenced several papers on the subject. Something worth noting though is that the annotations never dictated behaviour but instead acted as hints to the AI, such as chock point areas, or good sniper locations. Generally this kept the AI very competitive but did not resolve, what Alex called the third plateau, the ability for the AI to adapt to human tactics that were not accounted for or the evolving beyond expert systems, data mining, and creative AI. For this I followed up with Alex after the session and personally I feel not enough is being done. The only real solutions available are forms of learning and pattern recognition, neither is currently being used in commercial games.

Finally Chris Jurney spoke about Dawn of War II and the challenges faced with transitioning from a game like Company of Heroes that was very impersonal based combat to DoW2 which had quite a bit of melee. Chris summarized the solution to this problem through what he referred to as search based melee. Essentially casting a radius around various units that represented their melee distance, and performing an A* pathfinding to where the their unit radius must be exactly touching the enemies unit radius in order to perform a melee attack. Combined with an additional rule to avoid overlap on a given target created very convincing battle simulations and made the animation bit a lot easier to handle.

11:15am – 12:15am
Behaviour Trees by Alex Champandard, Michael Dawe, and David Hernandez Cerpa began the talk by exclaiming the sheer popularity and flexibility of BTs in video games. For those who aren’t familiar with Behaviour Trees I recommend doing some light reading on AIGameDev.com, but for all intensive purposes they are Hierarchical Finite State Machines that don’t really operate in the sense of states, and use very light and compact nodes to transition behaviours. David opened up by talking about the various node types (Priority, Sequential, Stochastic) and continued with defining slightly more advanced topics such as Event-Driven behaviours (the ability to enable behaviours through events), and Dynamic Behaviours (mostly referring to enticers). Enticers are behaviour trees that attach themselves to actors and detach themselves when finished. These BTs are useful for level behaviour support, and downloadable content. Alex continued by talking about common Design Patterns within BTs, such as scaling up using a HFSM mindset. For this he recommended to not approach behaviour stringing in a linear fashion, but instead chunk BT hierarchies into a blackboard architecture and than create more abstract behaviours that utilize them such as SneakToCover(), PeakAtThreat(), RunToCover(). This of course is hinting at the problem that Alex has been trying to solve and that is the creation of generalized AI. The most important take away from Alex’s bit was to keep BTs decoupled from the problem at hand. Be careful of “state like” behaviours. Lastly, Michael spoke about integrating scripting into BTs, which is quite a common thing to do. BTs are about flexibility and rapid iterations and scripting is usually the ideal solution to the problem. For LUA Michael spoke about a common interface that integrates with the C++ code. They would make sure that no trig was performed in any of the scripts. A tool was created to allow for the designers to rapidly iterate through behaviours, where he himself only created 7 out of the 50+ that were in the game. Lua was optimized by removing floating point math, and prevent mid-frame garbage collection. He typically would spend 10% of his time debugging existing scripts from the designers, and 10% on functionality requests (trig) that were done in C++ and executed using dll functions. He also stressed that BTs need to be periodically reviewed.

1:45pm-2:45pm
The next session was a panel discussion on AI Middleware. I’ll thankfully keep this one brief as it was pretty synonymous that we should continue to be wary of AI Middleware granted the rent at the end of day by the host John Funge was really interesting. Key points of note were:

• We want tools over black boxes
• Integration support by the middle ware company is often moot, due to the precieved benefits
• Evaluating middleware is often difficult due to their inability to simulate production environments during testing

The only success story came from Steve Gargolinski from Blue Fang Games who intergrated Havok Behaviours into their Wii title.

– intermission –
Well I’m already getting very tired as I am already at 1300 words and really need to sleep. I’ll do my best to continue while it may not actually happen until my plane ride home on Saturday evening. After all GDC tends to get busier, and its an event that is difficult to cover in great detail

In short, it has been almost a year since I’ve graduated Full Sail University and since then I have had a number of experiences that made me on numerous occasions question the validity of my life-choices. This stems from the idea of immediate sacrifice and delayed gratification towards a brighter and happier future. This for most is an accepted part of life and being successful. While ultimately we all strive for happiness and each time we sacrifice and give we hope it to be a means to an end. Of course as we grow older we slowly but surely realize the real cynical nature of human life.

I’ve asked myself on occasion; what makes me happy? Is it having a high paycheck? Is it the process of creating video games? Is it sitting at a bar? While I’ve questioned my motives, I always arrive at the same answer sooner or later. I realize that I simply wish to be challenged and learn. At the core that is what drives me! That is what motivates and inspires me. Still I’ve never been able to make the jump to a full time Indie, or a commit towards academia.

In the near future I hope to reevaluate why I have failed to follow my real agenda. Attain courage, and achieve some closure.

This is essentially a slightly longer twitter post. Thanks for reading.

Wordpress Page Templates

My first question was how to create a new page in wordpress and apply to it my own layout and stylesheets. This was incredibly easy and intuitive.

1. Create a new .php page that will serve as a template for your new wordpress page.
2. Page templates are easily recognized by the wordpress CMS via a magical comment.

1
2
3
4
5

<?php
/*
Template Name: Your Template Name Here
*/
?>

3. Navigate to /wp-admin/ and depending on the version of your dashboard click add page.
4. Here you can give your page any title you want. And somewhere on the page you should see an option to apply a template to the page (again this varies with wordpress versions so Google or check documentation). If you uploaded your new .php template to the proper location you should conveniently see “Your Template Name Here” as an option.

Installing a Pagination Plugin

I decided to use WP-PageNavi although there are several alternatives I’ve found.

• WP Page Numbers
• Different Posts Per Page

To download and install follow these instructions:

1. Download WP-PageNavi
2. Upload folder “pagenavi” under wp-contents/plugins
3. Activate the plugin
4. Add the following code into your current theme’s php file.

5. Configure the settings under WP-Admin -> Options -> PageNavi
6. Click “Update Options” and you are done.

The Lonely Loop

The reason I titled this lonely loop is because most wordpress documentation will refer to the post entries as “THE LOOP“. The final code snippet that finally got things rolling for me was as follows:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

<?php $page = (get_query_var('paged')) ? get_query_var('paged') : 1; 
 
		$my_query = new WP_Query('showposts=5&paged=$page');
		$wp_query = $my_query;
 
		query_posts("showposts=5&paged=$page");
 
		while ( have_posts() ) : the_post() ?>
  			<div class="post" id="post-<?php the_ID(); ?>">
                    <div class="date">
                    	<div class="day"><center><?php the_time('d') ?></center> </div>
                    	<div class="month"><center><?php the_time('F') ?></center> </div>
                    	<div class="year"><center><?php the_time('Y') ?></center> </div>
                    </div>
 
                    <h2><a href="<?php the_permalink() ?>" rel="bookmark" title="Permanent Link to <?php the_title_attribute(); ?>"><?php the_title(); ?></a></h2>
 
                    <?php the_content('Read the rest of this entry &raquo;'); ?>
 
                    <p><?php comments_popup_link('No Comments &#187;', '1 Comment &#187;', '% Comments &#187;'); ?></p>
                </div>
                <br class="clear" />
                <br class="clear" />
		<?php endwhile; ?>
 
 
       <div><?php next_posts_link('Older Entries')?></div>
       <div><?php previous_posts_link('Newer Entries')?></div>
 
        <?php if(function_exists('wp_pagenavi')) { wp_pagenavi(); } ?>

Obstacles Overcome

One of the first challenges I faced was realizing that the default loop provided in index.php did not properly render posts but instead interpreted function calls like the_title() with regard to the title of the page (template) opposed to individual posts. I later found according to slightly misleading documentation that a new query object is required. I proceeded to create one called $my_query. Where I would prefix function calls as such.

$my_query->have_posts()

and

$my_query->the_post()

This seemed to work, but the next problem was getting pagination to work in synch with this new query. The problem was that WP-PageNavi only listens to $wp_query. I had wondered around for some time trying to resolve this particular delima short of writing ajax and the pagination functionality by hand or maybe trying a different plug in. Thank fully after jumping from link to link I finally stumbled onto the following code block.

<?php $page = (get_query_var('paged')) ? get_query_var('paged') : 1;
query_posts("showposts=5&paged=$page");
while ( have_posts() ) : the_post() ?>
<h2><a href="<?php the_permalink() ?>"><?php the_title() ?></a></h2>
<span class="entry-date"><?php the_time('F d, Y'); ?></span>
<?php the_content(); ?>
<?php endwhile ?>

This finally got the ball rolling. I had only correct a few errors that sparked from the constant experimentation like a random reseting of the query at the end of the while loop. Conveniently above the pagination caused the current page to always read 1.

Hope this will be helpful to someone in the future. Here is an unordered list of sources.
http://codex.wordpress.org/Template_Tags/query_posts
http://codex.wordpress.org/The_Loop
http://codex.wordpress.org/Function_Reference/WP_Query
http://codex.wordpress.org/IRC
http://almosteffortless.com/2006/12/21/wordpress-pagination-on-a-page/
http://jarodtaylor.com/blog/wordpress-ultimate-archive-index-with-pagination/
http://www.w3cgallery.com/w3c-css/wordpress-pagination-in-pagephp-or-display-subpages-as-paging-under-parent-page
http://wordpress.org/support/topic/256899
http://www.lesterchan.net/wordpress/readme/wp-pagenavi.html

Download the latest stable release http://www.wxwidgets.org/downloads/
Go ahead and grab wxMSW – installer for Windows. Make sure your visual studio is closed so that the environment variable gets set up correctly.

Next your going to need to compile the library. So go ahead and navigate to installDir\build\msw.
Open up wx.dsw and convert it to your native Visual Studio format. Close visual studio back down and open up each vcproj in the current directory through notepad or notepad++. Search and replace each of the following:
– RuntimeLibrary=”3″ with RuntimeLibrary=”1″
– RuntimeLibrary=”2″ with RuntimeLibrary=”0″

Once your done. Open up the solution again, and right click the solution in the solution explorer. Select Batch Build. Select only the release and debug for each project. Once complete your ready to create your first wxWidget application with the added work of including all the directories and .lib in your project settings.

Here are two good links to help you get through this:
http://wiki.wxwidgets.org/Compiling_WxWidgets_on_Windows
http://wiki.wxwidgets.org/MSVC_.NET_Setup_Guide#Project_Properties

If it doesn’t work out right, go ahead and triple check everything!

What I learned from all this was that while wxWidgets are great for multiplatform development they are probably not a solution for developing game GUIs. I’d love to hear what others think on this subject, meanwhile I’ll move on to setting up my own GUI framework after a few hours of sleep.

What I have so far:

• Math Library
• Event Handler
• Win32 Framework
• Resource Manager
• DirectX Initialization and Callbacks

What I’m tackling this week:

• GUI Framework
• wxWidgets Integration
• Network Framework
• Console Debugger

After high school I was very frustrated by the core classes that defined the first two years of a regular University. I was becoming even more frustrated by the partying, and lack of vision most of my friends and peers were only concerned about. I don’t remember what conversation made me remember Full Sail but it was a school I had known about since middle school and I truly felt my passion was in game development. I decided that I want two things out of my career. First interesting and challenging work that would keep me ever interested. Second I wanted to work at a fun place that allowed for creativity. So long story made a little shorter, Full Sail University is one of two schools at the time that might hope to provide for the sort of education that really teaches you the internal workings of making a game. I took the plunge. I packed up everything I owned into my car at the time 1998 Nissan Maxima, and drove it from Philadelphia to Winter Park FL. Thankfully my apartment was ready; I choose to stay at Winter Park Pointe apartments because they were the closest and cheapest in the area. I also decided to not have a roommate after a few disappointing attempts. So for the next few months I slept on nothing but a mattress.

The first three months are crucial at Full Sail; they help separate those who can and cannot handle the program. Odd schedules that have classes end at 1am and start again at 9am the next day. It was interesting trying to adapt to it, and many of us became nocturnal. The next month the schedule changed again. Oh yes, a semester is only a month long and classes are 40 hours a week. The pacing was perfect for me and I really dug all the knowledge. I was excited to be there, and I was just amazed at the different types of people I was surrounded by and all of whom held a strong interest in video games. I bought a PS3, and started playing games a lot more than ever before in my life. At some point along the way I think I lost sight of my goal and what was at stake. After the first three months I felt like I had C++ down solid.

The rest of the year we spent learning MFC, Win32, C#, DirectX, and Design Patterns. Along the way we also had a few general education classes needed for accreditation, but they too were all geared towards Game Development. This included an English course that had us write a full game design document. Math in Linear Algebra, Calculus, and Physics all laid out the foundation for what was to come.

The first game making experience was defined by two classes; Software Game Development and Software Game Production. I feel like both experiences deserve a post mortem but the lessons learned cannot be learned from reading this.

After the half way point it felt like we did something really great. We made a game! A great one at that. I, Casey Flach, and Charlie Prouse put together a 3D top down shooter in a roughly five weeks. Who knew that making a game doesn’t take months but weeks? Well we were hungry for more knowledge and the next few months more than helped satisfy that appetite. We took classes in Artificial Intelligence, Networking, Machine Architecture, OpenGL, Optimization, and Engine Development.

And we finally made it … final project… to be continued….

Take a look and I hope you like this Unity3D Particle Demo.

In this tutorial we’ll go straight to the source with the creation of our Maya exporter. We will not be covering Mel, or building our own GUI. Instead we’ll be adopting from the MPxFileTranslator, a maya file exporter. We’ll be saving out our code into an XML file format that can then be used as input for character models, or even levels.

Understanding Maya’s naming convention is key to feeling comfortable and eventually predicting variable names when exploring further feature sets of the Maya API.

Nearly all Maya prefixes begin with the letter M; which of course stands for Maya and defines a Maya wrapper class. Next we have MFn; which stands for Maya Function set. For example MFnMesh, contains specific functions and variables that appropriately define a mesh (a mesh is a collection of vertices, normals and uv coordinates in 3D space) object in Maya. The MFn prefix is not limited to only visible objects in Maya. For instance, MFnDependencyNode is a conceptual object that is used to define a node inside the Maya graph architecture (we’ll cover the Maya architecture shortly, so don’t stress it).

Another important prefix in Maya is the MIt prefix that stands for Maya iterator. An iterator is not a difficult concept for those who are familiar with the STL library. It points towards some position in a data set (in this case a tree) and allows us for easy traversal, going to the next object ( itr.next() ) and looping until done ( while(!itr.isDone()) ).

The last and final prefix to take note of is the MPx. It stands for Maya Proxy object (see proxy). Quite simply it provides us with an interface towards integrating into Maya itself. Common uses of MPx are the MPxFileTranslator which we will be focusing on in this tutorial and the MPxCommand which allows the user to create his or her own custom Maya commands. For more information please reference the Maya Documentation.

Now that we are past the formalities, we can begin to talk about how Maya organizes it’s data, so that we can begin to extract from it. Essentially everything in Maya is stored inside a Directed Acyclic Graph or DAG (this one keyword will be very important so please take note of it now). For those familiar with web design this is equivalent to the HTML DOM object, for those not familiar I will refer to the data structure of a graph. The major difference in definition of a graph data structure and the DAG is that child nodes cannot be their own parents. See picture below.

Step 1 – creating a proxy

Create a new class and derive from MPxFileTranslator.

class CFileTranslator : public MPxFileTranslator

You will need to overload the following functions

static void * creator(void);

MStatus writer(const MFileObject& file, const MString& optionString, FileAccessMode mode);

bool haveWriteMethod(void)const { return true; }

MString defaultExtension() const { return “xml”;}

MString filter() const { return “*.xml”;}

Step 2 – creating a an exporter class

Our Maya exporter will execute after pushing file -> export all or file -> export selection. Our entry point is than inside the writer() function that we have overloaded. In order to check for selection we can perform the simple if check for mode == kExportActiveAccessMode else we export all. Since this is more of a feature than base functionality I won’t cover exporting by selection in any great detail but its implementation is not very different from exporting all.

We now have the simple design decision to write all our code inside the CFileTranslator class we created earlier or simply create a new class that will be specific towards our needs. We will want this new class to contain a few basic functions. Such as ClearAndReset(), ExportVertexData() and WriteToFile(). We will call these in that sequence from within the CFileTranslator’s writer() function.

Step 3 – data structures and data members

Next we’ll create some basic data structures that we’ll fill out during exporting. One thing to note is that we’ll be using Maya’s intrinsic data types such as MFloatPoint which is essentially Maya’s version of a 3-tulupe vector that contains floats for the x, y, and z coordinates.

typedef struct _tVertex

{

MFloatPoint point;

MFloatVector normal;

float uv[2];

}UniqueVertex;

Here we created a new datatype that will contain the vertex position (point), the vertex normal (normal) and the UV texture coordinates (uv[2]). As we export our data we’re looking to optimize Maya’s vertex list by creating avoid duplicate vertices and creating a unique vertex list. We’ll than create our own triangle list that store indices into this our array of unique vertices. For a better idea on how index buffers work, reference Chad Vernon’s website at (http://www.chadvernon.com/blog/tutorials/directx9/vertex-and-index-buffers/). So the last important data structure we’ll need to generate is our triangle.

typedef struct _tTriangle

{

unsigned int verts[3];

}Triangle;

std::vector<UniqueVertex>    m_UniqueVertList;

std::vector<Triangle>    m_TriangleList;

Wrapping the above into a mesh structure would allow us to export more than one mesh at a time. These are further improvements that you may consider making to the base exporter.

Step 4 – the loop

The idea is quite simple, but the work may become a little tedious. Our goal is to go through go through Maya’s DAG , find all the Meshes and export them. The tedious part is that we’ll be doing a very similar traversal for just about each part of the export process since the DAG contains everything from Mesh objects to lights and transforms.

Thankfully the iteration process is quite straightforward. We begin by creating a MItDag. We specify that we’ll be traversing in depth first order, and we’ll be looking for Meshes. The code should look something like this.

MItDag dagIt(MItDag::kDepthFirst, MFn::kMesh);

Next we loop through each element, each time checking if the Mesh is an intermediate object, which simply means it’s something left over in Maya history but is not the current model we continue. Else we begin exporting by calling GetMesh(), our own function that will fill out our data structures from earlier.

for (;!dagIt.isDone(); dagIt.next())

{

MDagPath currPath;

dagIt.getPath(currPath);

MFnMesh currMesh(currPath);

if (currMesh.isIntermediateObject())

continue;

GetMesh(currMesh);

}

Step 5 – Creating a unique vertex list from Maya’s data

We’re now inside the GetMesh() function at which point our prime objective is to fill out our m_UniqueVertList and m_TriangleList for our mesh. This is also a good time to go ahead and pull out things like the mesh transform, or any custom attributes if you so wish. Again we will not focus on these features and move onto the actual data.

We begin by creating a MDagPath object which essentially will contain the directory, or path if you will, of the mesh we are attempting to export.

MDagPath path;

currMesh.getPath(path);

Next we’ll create a new itterator to traverse the polygons of our mesh (aka triangles). We’ll also create a few arrays that we’ll populate with Maya’s vertex positions, vertex normals, and UV coordinates.

MItMeshPolygon polyItr(path);

MFloatPointArray _tPoints;

currMesh.getPoints(_tPoints);

MFloatVectorArray _tNormals;

currMesh.getNormals(_tNormals);

MFloatArray _tVArrays;

MFloatArray _tUArrays;

currMesh.getUVs(_tVArrays,_tUArrays);

Something to take note of now, is that the index of the vertex positions, normals, and UVs will all be unique. Although the index of the U and V coordinates is a 1:1, and will use the same value.

If you have kept up with this tutorial so far, congratulations, we’re now in the final stretch and I will simply go ahead and post up the code for generating the unique vertex list and triangle list per mesh. Remember that this code snippet is my own and your coding style may or may not adhere to it. The important part is that you understand the process involved.

for (; !polyItr.isDone(); polyItr.next())

{

Triangle tmpTriangle;

for (int vertIndex = 0; vertIndex < 3; ++vertIndex)

{

UniqueVertex tmpVertex;

tmpVertex.point = _tPoints[polyItr.vertexIndex(vertIndex)];

tmpVertex.normal = _tNormals[polyItr.normalIndex(vertIndex)];

int uvIndex = -1;

if(polyItr.getUVIndex(vertIndex, uvIndex))

{

tmpVertex.uv[0] = _tVArrays[uvIndex];

tmpVertex.uv[1] = _tUArrays[uvIndex];

}

else

continue; // this is a bad place to be!

bool exists = false;

int i = 0;

int size = m_UniqueVertList.size();

for (; i < size; ++i)

{

if(m_UniqueVertList[i].point == tmpVertex.point && m_UniqueVertList[i].normal == tmpVertex.normal &&

m_UniqueVertList[i].uv[0] == tmpVertex.uv[0] && m_UniqueVertList[i].uv[1] == tmpVertex.uv[1] )

{

exists = true;

break;

}

}

if (exists)

{

tmpTriangle.verts[vertIndex] = i;

continue;

}

tmpTriangle.verts[vertIndex] = m_UniqueVertList.size();

m_UniqueVertList.push_back(tmpVertex);

}

m_TriangleList.push_back(tmpTriangle);

}

Since I didn’t cover everything involved with creating a Maya exporter and assumed some familiarity, or rather ability to use the Maya Documentation, please feel free to post comments and ask questions. I’ll be glad to make clarifications, but at the moment I need to get back to work.

We finally made it to Final Project! The next five months will be the most important months for me at FullSail. They will define all that I’ve learned, they will define all that I’m capable of. These last months will be the last stepping stones towards breaking into my dream job. There’s nothing more to say but this.

No matter what happens, no matter what goes wrong, no matter what challanges lie ahead. Our final project will be amazing, I know it. And with the months to come, I think I’ll convince you!