Plan for Melv May

... continued from previous .plan.
... T2D .plans.
... T2D .Discussions.

Wow, November and December have been really busy for me; T2D is absorbing nearly all my free time and I'm so exhausted but I have to say that it's been worth it. T2D is really coming together now and although I know that when it's released, that'll just be the beginning of the journey, it is starting to turn into a great 2D product. Sure, it hasn't got every single feature at the moment you're going to want but it does have a solid core that's easy to expand upon as well as a great scripted interface for every object. Post the initial release, there'll be a push towards improving the support tools such as the particle-editor, tile-map editor and better networking support.

Rather than blurbing about tech, I thought I'd take the time to provide some history leading up to where I am today so that everyone can see where it's come from and where it's ultimately going. Hopefully, you'll see why my plans have been few and far between lately and see that T2D is really surging forwards and I'm working like the devil himself!

To be honest, when I first began T2D, it was only as a distraction from other projects but even then I was seriously interested in creating a method of generating 2D visuals within the TGE. The reason I was so excited was two-fold. The first reason was that working in 2D is so very cool (no really), especially as the algorithms are much easier to deal with and very nostalgic at times! The second reason was that it seemed there was a definate requirement for 2D in this very powerful 3D engine of ours. There are so many people on the forums who desperately want to make games but don't have the basic background knowledge for doing so and perhaps won't admit it! My idea was that folks could use T2D for learning how to write classic games without getting bogged-down with 3D tech or even simply use it to suppliment your 3D game with a cool 2D gui! It could also be used as a stepping-stone to using the TGE itself.

I remember thinking that it wouldn't be too difficult to do and my initial feature set was fairly minimal but I did have a view to future development. I decided to go down the 2D scene-graph route and generate a core object that would be the basis of everything. In short order, I had things whizzing around with basic collision-detection and partial approximated physics. It was really cool that I could get things moving around autonomously with very little effort using the scripts and I did a flurry of plans at the time as I was so hyped.

I finally got to the point where I had a fast scene-graph, multiple window support, basic physics, an image handling standard, both static and animated sprites, a scrolling background object and finally a tile-map object that supported arbitrary rotations, unlimited layers and viewport-panning; mucho coolio. The only thing I had to finish then was the particle-engine so I decided to take what I had planned for the Strategem particle engine and adapt it to meet the requirements for T2D. I went out on a limb and laid-down a pretty huge set of capabilities (why do I do it to myself?). After a full week of design and almost two weeks of solid coding, it was ready and it worked like a dream and again, all driven from the scripts. T2D was getting seriously cool.

At this point, I had a good feature set that was more than capable of making games although there were some problems for anyone wanting to do more sophisticated games. Firstly, the collision detection, although fast, was fairly limited. There were also problems with tile-map collisions. The other problem was that T2D was only an API and didn't have any editor support so although capable, some of the functionality wasn't that intuitive for newbies. I decided to start working on some documentation and spent six evenings writing both a simple tutorial and a reference guide. I made a decision to keep this up to date as I made changes to the API, no easy task I can assure you!

It was around this point that Jeff Tunnell approached me about forming a collaboration so that I could release T2D through GG. After I received Jeffs email, I was honoured to be asked to work on it as a product for GG. With that said, I thought about it for quite a while as I needed to decide if I wanted to dedicate my time to an actual product or simply do some part-time coding. I didn't want to promise something that I couldn't deliver as the GG guys have been so good to me over the last few years. It was then that I realised that T2D could be something special and all it would take was dedication and time, and with GG behind me, how could I go wrong? World domination through collaboration? Yes!

My idea of what T2D could become changed almost overnight when, after Jeffs email, I started thinking about all the possibilities for T2D. My ideas were soon to become almost trivial when I started discussing the possibilities with Jeff/Josh. They had so many ideas on how it could be used by the community and ultimately turned into a 2D game-maker product, something I hadn't considered as it was always going to 'simply' be an API to me. I was convinced that I'd made the correct decision to work with GG at this point. I'm no fan-boy, I mean this sincerely.

IGC'04 was now looming and it became apparent that we needed to show-off something more flashy than the crappy programmer-art demos that I'd done so far. The GG guys didn't have too much time pre-IGC as they were really busy with other preparations but Ben, Pat and Josh did an admirable job getting the stuff together. For my input, I decided all I could really do was get a preliminary particle editor together and that's exactly what I did. It only took just over a weekend but it was capable of accessing nearly all the features of the particle engine. I spent a few days generating effects, some of which were shown at the IGC (maybe you saw them?)

With IGC over and lots of good feedback, it was time to start getting things together and making plans on what we could do and what we couldn't. It was about now that the roadmap for T2D was taking shape and plans for release started emerging. This is when the real stress began. The realisation that people may be actually purchasing this thing! If I was selling the fxReplicator, it wouldn't be anything like it is; it'd be faster, more configurable and well documented. This is where T2D had to go.

The final features for T2D were nearly complete and "Game in a day" was now looming (isn't something always looming?) T2D, as it was then, was made available to the nice GID#7 folks. The timing wasn't that great and so people didn't really have the time to get to grips with it but on the whole, the feedback was very good with most people saying that it was easy to simply "get stuff working". One thing that taking part in the GID#7 did was that it identified things in T2D that could be better and things that would be nice to have.

I knew for certain in my mind that I wasn't happy with one thing, the collision system, particularly when it came to more complicated objects such as the tile-maps. If you speak to anyone about 2D collisions, they'll probably brush it aside as "easy" but to actually implement it in such a manner as to make it not only intuitive but fast and extendible, is definitely not "easy". My other concern, although not as much, was that the physics was pretty basic although it was enough for a wide variety of games.

At this point I was talking heavily with Josh Williams (a fantastic sounding-board) and, after plenty of discussions and agreements on the collision system, I decided to take another leap of software tech and implement something special. I must admit that Josh had reservations about what I wanted to achieve but I promised that I could do it and in short order. After the chat I thought to myself, "why did I commit myself to this!!!!"

I organised a long weekend so that I could commit to this new code which was a completely new and sophisticated physics and collision system. I'd be happy if I could do this and sleep better at night!

My goals were to have a collision system that could do a swept polygon-polygon check and provide information on both overlaps as well as disjoint collisions in forward-time. I wanted the system to be able to solve overlaps and provide solutions as well as do something extra special, feed into the new physics system. The new physics system was also a big leap; I wanted to do proper rigid-body physics where the mass and inertia were calculated from the collision polygon area based upon initial parameters such as density. I wanted to be able to define a collision material that could be applied to any T2D object and the physics system would respond accordingly. Properties such as density, restitution, relaxation, static/dynamic friction needed to be there. This is all great but I wanted this to be configurable with minimal script-calls and not impede games that didn't explicitly require fancy physics! I also needed to ensure that it didn't break everything that went before! Hmmmm.....

Now there's only one thing worse than doing such a system at pace; doing it at pace on a code-base that already has an approximate system! I had to remove all existing traces of physics/collisions and rework many of the internals. This is one of the reasons why Josh (quite correctly) was worried about me doing the work. My wife Sarah had put aside the stuff we were originally going to do so that I could work Fri, Sat, Sun and Mon solid on it. I did lots of homework on both subjects prior to development and spent many an hour chatting online with some folks I met on 'GameDev.net' as well as reading a few chapters of a book on calculus! I had very little sleep over four days, waking early, sleeping late but I must say, I enjoyed it immensely but I did deplete the house of coffee. I was in my element; difficult problem, short-time span, big reward!

By mid-afternoon Monday, I had gotten so far that I was amazed at it all (pre-planning is all good!) I had achieved everything I set out to do and more. The collision system was working perfectly and was really fast and the rigid-body physics worked like a dream. I had objects hitting each other causing linear and angular changes. I had gravity causing objects to stack and things sliding down ramps and bumping into each other ... totally sweet! I was really happy! I put together a basic demo for the GG guys and they were really, really happy with it but no-one could be as pleased as I was with it!

The question now was whether to release T2D with the "old" code or the new. The problem here being that we'd need to change the existing tools, albeit preliminary ones. Finally, it was decided that we should bring the very best to the community that we can so the decision was made to go with the new code. This meant that I had to dedicate another long weekend to correctly integrate the new system. Sure, the new system was ready, but it didn't have all the capabilities exposed via scripts so I needed to do that. That was the 12-13th Dec weekend for me! I don't remember what freetime is now!!

Well that's the story so far! When T2D is finally released, it'll have only preliminary network support and editors but it will have a 2D engine with huge potential. Want a 2D game where you can knock objects around and they respond correctly to collisions? No problem! Want to generate your own 2D objects quickly? No problem. Get the Early Adopter version and I can guarantee you that whilst all the editor support is preliminary, it'll have everything else and soon after the initial release, focus will shift to editors as well as additional objects such as internal text support etc. You'll also be able to feedback into what kind of features go into it and be part of the design process. T2D will be designed by the community, developed by a community member and GG will make this happen!

- Melv.
T2D Slave.


For those who like development shots, here you go! Oh yes, there's only one thing better than T2D and that's baby Jessica (now 15lb 8oz) at nearly 4 months. Look at those chubby cheeks, I want to pinch them. :)