Before I show you how I got this working let me just say this, I’ve no idea what I’m doing, so if stuff breaks then its on you, it happened to work for me, but I’m certain there is a better way to achieve the same result.

Right from within Textmate you go ‘Bundles > Bundle Editor > Show Bundle Editor’, Once that opens look on the left for the JavaScript bundle. Click the plus and select ‘New Command’ from the menu.

In the save type select ‘Current File’, in the Input select ‘Entire Document’, Output set to ‘Show as Tool Tip’, then  down at the bottom Acivation as ‘Key Equivalent’ set this to Command-S and finally set ‘Scope Selector’ to source.js.

With all that fluff done we can move onto the code that does the business, in the Command(s) section paste in the following:

/Users/httpmmo/Nodejs/node/nodelint "$TM_FILEPATH"
--config /Users/httpmmo/Nodejs/node/nodelint.config.js

Replacing the paths with the correct path based on your system. You’ll notice I’ve added a nodelint.config.js into the node install directory, this is just so that I have common place for all my config stuff. The contents of this file is below:

nodelint.config.js

var options = {
    white: true,
    onevar: true,
    undef: true,
    //nomen: true, // nodes __dirname prevents this being used 
    eqeqeq: true,
    plusplus: true,
    bitwise: true,
    regexp: true,
    newcap: true,
    immed: true

    // JSLint expects the "use strict"; declaration to be on the first line
    // of the document, if like me your wrapping your code in an
    // anonymous function then this will likely fail 
    //strict: true
};

With that done we’re most of the way through the process, if go into an existing .js file and try saving it you’ll get the following error:

This is where I got my hack on, as I’m not linux/bash/console/terminal master I just opened up nodelint inside my node install directory and set the absolute path to the active version of node on my system, running the same test again now gives me.

With the corrected version looking like.

The best bit about this whole process is that I can forget about it, I just write code, and hit save, if something is ugly it lets me know, and I fix it, nagging in a good way

My next goal is to get it working in E-Texteditor over on windows, so that’ll be my next post.

I’ve been following the installation process over at codebetter and during the process I ran into a few issues, this post is only concerned with the issues I found, and how I bodged my way to a working install.

The first issue I encountered was during the ./configure set, Cygwin was complaining that it couldn’t find a c compiler, quickly my google-foo found the following like, which fixed that presky issue.

http://www.cygwin.com/ml/cygwin/2003-06/msg01241.html

Next up I ran into an issue with cxx, and it not wanting to work, google found me an artical explaining that mingw wasn’t correctly linked or something, either way the fix can be found in the following link.

http://blog.brev.name/2010/09/nodejs-on-windows-7-under-cygwin.html

Once that was done I just needed to run make and its all good, though I’d forgotten to download OpenSSL when I was downloading Cygwin, so I got an additional error, but that was due to old fashioned incompetance

make took about 4-5 minutes, as it has to do a whole bunch of awesomeness, with make install taking 1-2 seconds.

And with that I have a working node install in windows, now time to start messing with some code that should just execute in a range of browsers, and in the node base command line.

What this has shown me is that using a modern browser it is possible to implement simple flash-esk games using Javascript. Once the concept was proven I began working on a more reusable code base, which I have named Thorny.

You can read more about my hopes and aspiration for thorny here but currently most of that is just me waffling on, in its current state it isn’t much more that a super simple canvas script that draws a pretty shape on the screen and nothing much else.

I’ve been spending my evenings getting myself frustrated with maths I learnt at school 10+ years ago, which has been fun, but its starting to pay off, Thorny as of right now is detecting collisions that occur infront of the moving actor, and is responding in a primitive fashion to there existence. Hopefully by the end of the week I’ll have my collision detection bugs fixed and the collision response working nicely.

Once that is working I’m going to try writing a simple 1 player game, just to show off what the engine does as of then. The game is likely to be a simple maze affair, where our deranged hero/heroin must escape from a cave he/she has gotten lost within.

Once thats working my next goal will be to re-implement Zombie Corridors DOM renderer and see how well everything works by recreating my bench mark, if my FPS stay relatively unscathed then all of this additional fanciness has been relatively cheap in terms of CPU usage, if the more likely occurs and the FPS plummets than I will cry and throw a hissy fit.

After Zombie Corridor has been re-implemented I shall go about implementing mesh based path finding, as this will allow NPC actors to more realistically roam the world, which by now will add some much needed intelligence to Thorny, mindless flesh eating zombies can only do so much to entertain.

Just as a note I intend to release Thorny on an OSS licence, I’ve not really looked into which one I will go with yet, but its likely to be MIT, and once each of the phase of demo is completed, they will be uploaded to one of my many domains.

TTFN

You can download the Kohana module from here its just a matter of dumping that into your modules directory and configuring the init.php file.

Once you’ve done that you need to make some changes to your Doctrine lib, as you know all models within Kohana need to be prefixed with ‘Model_’ so your User model needs to be called ‘User.php’ but the class within it needs to have ‘Class Model_User extends…’ the problem here is that ‘Doctrine::createTablesFromModels’ only looks at the filename when creating a list of tables to make, so we need to tweak Doctrine to allow us to parse in the ‘Model_’.

If you open ‘Doctrine1/lib/Doctrine/Core.php’ and goto line 902 you’ll see this:

public static function createTablesFromModels($directory = null)
{
return Doctrine_Manager::connection()->export->exportSchema($directory);
}


If you replace that with:

public static function createTablesFromModels($directory = null, $classPrefix = null)
{
return Doctrine_Manager::connection()->export->exportSchema($directory, $classPrefix);
}


Basically this lets up parse a classPrefix into the exportSchema, which is needed for Kohana.

Next go to line 666 where you will see the following:

if ($classPrefix) {
$className = $classPrefix . $className;
}


Replace that with:

if ($classPrefix) {
$blah = explode('/', trim(str_replace($directory, '', $file->getPath()), '/'));

if (count($blah) >= 2 AND $classPrefix == 'Model_') {
if ($blah[0] == 'Generated')
continue;
$className = strtolower($classPrefix.implode('_', $blah).'_'.$className);
} else {
$className = $classPrefix . $className;
}
}

Next open up ‘Doctrine1/lib/Doctrine/Export.php’ and goto line 1092 you’ll see this:

public function exportSchema($directory = null)
{
if ($directory !== null) {
$models = Doctrine_Core::filterInvalidModels(Doctrine_Core::loadModels($directory));
} else {
$models = Doctrine_Core::getLoadedModels();
}

$this->exportClasses($models);
}


And replace it with:

public function exportSchema($directory = null, $classPrefix = null)
{
if ($directory !== null) {
$models = Doctrine_Core::filterInvalidModels(Doctrine_Core::loadModels($directory, null, $classPrefix));
} else {
$models = Doctrine_Core::getLoadedModels();
}

$this->exportClasses($models);
}


Finally if you edit ‘Doctrine1/lib/Doctrine/Import/Builder.php’ and goto line 349 you’ll see this:

if (isset($definition['tableName']) && !empty($definition['tableName'])) {
$ret[$i] = " ".'$this->setTableName(\''. $definition['tableName'].'\');';
$i++;
}


You need to wrap the $definition['tableName'] in a str_replace like:

if (isset($definition['tableName']) && !empty($definition['tableName'])) {
$ret[$i] = " ".'$this->setTableName(\''. str_replace('__', '_', $definition['tableName']).'\');';
$i++;
}


Now you should be able pop schema.yml and data.yml files into your model directories for all active modules and your main application and navigating to ‘http://www.example.com/doctrine/generate’ should with any luck generate all of your models and populate any data you need.

And I am proud to share Cool Tree with you all, developed in-house at Sync Studios we have designed and developed a pretty cool iPhone application.

Cool Tree is a real-time game, where you have to look after your tree and keep it safe while it grows big and strong. Over the course of a week your tree will grow from a tiny sapling to an impressive 30 meter tree.

Right now the PR’esk bit is done this was a super fun project to work on, and it just goes to show, you can write a pretty cool application what works on the iPhone and have no knowledge of Objective-C. Yes thats right Cool Tree is written entirely in Java-Script using the amazing jQuery library and PhoneGap to allow the magic to happen.

And remember buying the app saves a real tree in the rain forest

I have to say I am really impressed by what is possible using this development environment, to write a pretty simple business class application would possibly take only a week or so to complete. And the implications for browser games is pretty significant. In the vast majority of games you need to be on a PC/Mac and using a browser to respond to the changing game state. But by adding an iPhone client allows your user base interact with the game while miles away from a computer.
I really do think this kind of portable interface if implemented correctly would vastly improve the PBBG landscape.

Basically the idea behind Mappy was to make content creation super easy, and quick. Therefore I decided to implement a heightmap based map generator, where by I upload a black and white heightmap and Mappy generates me a ton of content. The problem with this was that any image larger than 20px-20px would take minutes to process, which is totally unrealistic for a PBBG, so I hear you asking how did I solve this tiny issue.

Well I took the processed tile information and processed it into serialized php arrays, and json objects, these are then stored on disk in blocks of 20×20 tiles or 400 cells. This data is then either unserialized or served directly to the client. Once the content is active on either the server or client it is then rendered out into HTML. Great now I have a system that takes a simple black and white image and builds me nice a complex 2d map, only problem now is that its not  very usable, because of the amount of DOM manipulation going on scrolling around the work takes a good deal of processing, so I had to come up with an optimisation that would allow suppoerting browsers such as Firefox, Chrome and Safari to render the mapping data into a Canvas element. As moving 10-20 large images is much less problematic than moving 1000s of div tags.

So now I have a system that lets me automatically generate and view complex mapping content, all at the click of a button, great, now I need to start building a game, right… wrong still tons of backend hackery that is required.

The next task was to workout where the user had clicked in normal 2d space, then translate that coordinate into isometric space, then poll the server to see if that location is available for building, if it is then it returns some json informing the client that it may indeed build at the selected location. Once I had the ability to click of specific tiles it was time to start thinking about what Mappy could be used for, this for me was and still is the hardest bit of the project.

Having grown up playing games like Command and Conquer it was the natural choice, but as far as I am aware no one out there in internet land has created a PBBG implementation akin to Real-Time-Strategy games, the closest I could find were people implementing games that work on real time, as in it takes 10 minutes to build a hut, and 3 hours to walk over to an opposing village and lay siege, all happening in a textual manor, now I dont know about you, but as a kid I got board of DnD, and got hooked on Warhammer, I think it was due to the whole visual aspect. Either way games that are “real-time” but none-visual in my mind fall short.

So wanting to make a RTS, but not wanting to compromise on the visual aspect of the game I needed to come-up with some solutions to how I can build buildings, move units around the map, and do it fast enough to be usable. Luckily I have Mappy that does the whole visual thing, and allows the building of buildings, but what to do about the moving units around issue.

Looking back though this blog, and my old code folders I found my pathfinding code, and even though it was designed for a different kind of environment (the path finder was for a real-time server system, so it would load the pathing data once) I started to port it over to the Mappy paradigm, this took about 4-6 hours to port, and once complete I was left with a block of code that took about 50 seconds to generate me a ton of paths, this obviously was not suitable for a PBBG so I dropped the data into a database, resulting in about 2k records that returns optimised paths in 0.0005 seconds, Win.

So now I can path-find from any one area in poly space to any other area, the problem now is that Mappy isn’t polygon based, its just a bunch of 2d tiles positioned using css, I need a way to build a polygon version of my 2d tile based world, luckily again my bag of failed programming projects came through again, a prior attempt left me with a pretty handy bit of Javascript that lets me draw polygones on a canvas, this will do nicely, another evenings worth of work and it was alive, and that brings you up-to tonight, right now in fact

I’ve uploaded a video of Mappy inaction to youtube, take a look and post a comment letting me know what you think.

Right hope you enjoyed that, my next task is to link up the polygon drawing code to the pathfinding backend and then I’ll have the ability to build complex 2d maps, and allow pretty much instant pathfinding from any location to any other location for close to zero CPU load. Once that is all working I’ll need to implement a unit type into Mappy, so I can test all this is actually working correctly and once thats done start thinking about how multiple units will attack one-and-another.

I’m just hoping because I’ve been able to get this far without any major issues I can pull off a real RTS, and not join the ranks of people with real-time textual gameplay, not that I dislike textbased games, I just feel most things should be visual.

Iain out.

The idea is that I will post a tweet or two about what I am currently working on with regards to my PBBG experiments, then when I have something final to show for all the time I spend tapping away on my laptop I will make a more complete post with screen-shots and videos etc.

A tweet feed can be found to your right, and the direct link is https://twitter.com/httpmmo

Having a four month break let me realize I was being overly ambitious, the editor I was working on was overly complex, and to be honest easily replaceable using one of the excellent map editors available on the market. Therefore I will be using an editor and rendering off the tiles, which will then be cut into 256×256 tiles.

Seeing as the map editor just got massively more simple I have started working on my map handling objects, hopefully in a few days I will have another video to upload demoing the map loader.

Just an update for you all today, got basic version of my level editor up and running over the weekend, and though that I should blog about it a little, as its quite interesting I think, that or I’m crazy

I’ll let you see it in action before I bore you with details…

Still here, good

Right I have written a HTML based interface, using the Canvas tag to render the application, and jQuery to manage all the nasty AJAX stuff. Basically what happens is you place a number of vertacies and join them up to make faces, once a face has been created a command is fired off to the server, which in turn renders that information into a png, which is then downloaded by the client and displayed within the editor.

There is a bit more validation going on in the back ground, for example every vertex placement, movement etc is logged on the server, this allows you to close the browser at any time and know that you will not lose any data.

My next goal is to improce the placement of tiles, and hopfully allow different faces to be painted with a different tile set, hopfully allowing smoothish blends between grass and mud, after that is working correctly I may look into collaberative editing, as its cool and very Web2.0

As per dont expect to see anything mentioned in the next goal section for a good few months, because basically I suck at time management, and I can only ever spend 4-5 hours a week on this stuff.

/me out

I took a break from working on my path finding stuff to do some work on a fuzzy logic state machine, there was a discussion over on Browser-Based Game Zone about the use of a FuSM within a PBBG.

Having some quite a lot of work with FuSM’s during my degree I decided to work on implementing an abstract system, which can have custom inputs, outputs and rules written simply by adding additional strategy objects into the system.

I am pleased with the overall outcome of the mini project, and it was fun to work on something other than pathfinding for a while, you can find a more indepth overview by clicking on the FuSM page to your right.