Ludum Dare 18 – Final Update

I finished!

Here is the submission page: http://www.ludumdare.com/compo/ludum-dare-18/?action=preview&uid=2236
And the direct download link: http://dl.dropbox.com/u/10424774/BikersRebellion (2).zip

I met the minimal goals I set for myself, which pretty much consisted of creating a ‘finished game’. It may seem vague, but I had a clear idea in my head:

• All hand drawn images
• Somewhat dynamic
• Simple AI

Which were all met in my eyes. The game lacks the depth I wanted, but is certainly challenging in getting higher scores. I come away with a lot of valuable information about the next Ludum Dare:

• If I’m not using Unity, GameMaker, RPGMaker, etc. then I really need to prepare my engine (XNA, pygame) a lot better. I thought I could just use an engine for another XNA game I had been working on, but didn’t spend enough time clearing out the extra biogenesis code so it was very convoluted. It forced me to spend way to much time figuring out and clearing away overly complicated code. Like collision!
• Hand drawing assets is a lot of fun and gives the game a look and atmosphere I enjoy. I hope to experiment with more complex implementations of this in the future.
• Planning early is key! Plan your work, work you plan helped out a lot.

Ludum Dare 18 – Update #6

Well, there may only be around 7 hours to finish, but that won’t prevent me from enjoying a favorite lunch of mine – smart dogs fried with sauerkraut and onions, topped with relish and ketchup:

Things are going… slowly still. I keep getting caught up on code I should have had prepared. What a learning process though! I’m already excited about 19.
I have most of the images created, the sounds generated, and basic mechanics. The rest of the day will be creating the minimal decent submission I can muster up, and then tweaking the hell out of movement and AI. I’m aiming for a 3 level, increasing difficulty, one map, somewhat dynamic (as in randomly selected content at a given point in time) game that resembles Spy Hunter.

Ludum Dare – Update #5

So I wanted to take a break from coding and got some actual content done!

• Debris has been added
• SpawnManager has been tweaked a bit, but needs more
• Most of the art content is done; everything except an extra car design and all the buildings is finished

In the following picture, everything is scrolling, generated somewhat based on a level difficulty which means scrolling speed and car speed\ acceleration. The only behavior right now is ‘GoStraight’ but that will be changed soon (although some cars will still use that, not all are going to be enraged drivers!)

Ludum Dare – Update #4

Above is my more concise ‘TODO’ for today. I’m giving myself about 6-7 hours, which hopes of getting to be before 2am, only so I am able to wake up before 8am and begin again. I got more caught up on collision, but finally implemented the masking collision (I was so used to line and circle collision algorithms) so now collision is down to simple tweaking. I still haven’t made any actual content, just placeholders. Sunday is hopefully going to be content day. If I get most of this finished, I’ll spend the better part of Sunday morning designing and implementing hand drawn sprites, then move to feature creep. There is a lot I want to do once I get the game playing in simple modes with regular content. Most of today’s recent work has been behind the scenes, but a newer screenshot nonetheless:

The buildings are scrolling, the cars are beginning to sense (the numbers around the car are it’s sensors debug output), and the player is the ‘biker’ in the middle. Here’s to hoping!

Oh, and the obligatory food post – I made channa masala for dinner! I made a whole lot 2 days ago and it’s been serving me well:

Ludum Dare – Update #3

So I’m a little rusty. It’s taken me an extraordinary amount of time to implement the skeleton of AI, Spawnmanager, player movement, and some other functionality. The good news is that most of this is finished so I can begin creating the skeleton of the entire game with simple AI for cars, tweaking the movement, adding buildings, and finally, correct scrolling. Here is a small screenshot of what’s finished, in action:

Game in action with a biker and two cars on the road.

The code is really sloppy, but I’m just hoping for a finished product at this point!

Tentative schedule:

• Sat (Today):
  • Get most of the simple AI completed
  • Get scrolling and movement lined up
  • Create variability of speed, acceleration, etc.
  • Get collision working
  • Have a simple level created and playable
• Sunday:
  • Create the actual content of bikers, cars, building, pedestrians, and debris
  • Tweak scrolling, movement
  • Finish complex AI and integrate difficulty into it and the Spawn Manager
  • Tweak Spawn Manager
  • HOPEFULLY Feature creep
  • SUBMIT A FINISHED PRODUCT

Not too ambitious, I hope. Things are only slightly behind schedule.

The End of Summer

A disappointing end, but an end. I’ve only come so far with my Diet ambitions. I mapped out a lot on paper, but only got as far as creating the first draft of the house map. I found a couple free tilesets that allowed me to create something above the minimal amount of pixel art standards I have for the first phase of Diet (traditional RPG knock off). Here is a screenshot of the initial map:

As far as biogenesis work I have been diligently trying to improve the trainer. The fundamental problems of behavioral complexity lie in two places: the limitations of the current version of NEAT, and the lack of interaction organisms have with the environment. This splits up the work evenly, so the former problem has driven me to isolate the training system and work on it’s own screen allowing me to try all kinds of crazy ideas:

• “plug and play” training scenarios
• formally defining ‘serial’ and ‘parallel’ training scenarios
• using CPPNs and HyperNEAT
• threading out genome training batches, since no genome training depends on another
• defining high level goals and have ANNs only access those functions
• indirect encoding

Only a few of these have been tested since my updates to all the sensors (optimization, improvement). The good news is that, by the time the environment and event systems are in place the new training system will be able to utilize them to their potential.

Lastly, my first attempt at a Ludum Dare will be this weekend. The only thing I have to prepare is what engine I’m going to use. It’s looking like GameMaker, but I’m hoping to gather up the courage and determination to use a more coded approach like pygame or XNA. Results\updates will be posted.

biogenesis – New Training System

Most of my time has resided in biogenesis. I created a branch of our first version, gutted the behavior manager, sensors, and training thread to start from scratch. I got rid of NEAT’s INetworkEvaluators and implemented my own similar interface that I think will allow for the type of training I have in mind.

The population evaluator now runs in ‘Passes’, where a Pass defines two objects: a system of evaluation, and a space in which training takes place. These were designed under the ‘design by contract’ paradigm which I’m exploring heavily with this new system.

The problem I hope this solves is setting up a system where the following training methods are easily implemented with my updated TrainingManager class:

• Remedial Training
• Small goal oriented training
• Simultaneous and Sequential sets of above goals
• Dynamic input\output neurons depending on the trainee
• ‘Plug and Play’ training systems

This method was designed to reinforce our original design which included remedial training and training in sequences of small goals, but done in a much more abstract, robust, and well defined way. The idea to continue and strengthen\revisit this design includes several reasons:

• The organisms were training quickly and had potential but anything past basic field navigation, evasion, and food gathering never showed. Complex networks also had trouble showing up.
• The ideas described in http://www.pnas.org/content/102/39/13773.abstract formally addressed our approach.

The aforementioned paper details how spontaneous modularity in evolved networks arise in evaluation that include frequent sub goal changes (where sub goals have some underlying similarity). This is one approach to the problem of having a population be stuck in a local maxima “because the fitness landscape changes each time that the goal changes, modularly varying goals can help move the population from these local traps.” It is my hope that by creating an abstracted implementation of the TrainingManager that furthers these ideas, when we get to the point of greatly varying organisms the training will naturally develop unique behavior based on the organism’s abilities.

My tests are currently running correctly without sensors, so my current goal is to finish the sensor and behavior management systems and integrate them with the trainer.

General Updates – Diet

So Diet has been put on hold for a little bit. I might explore the game in several different engines. The reason it got put on hold is due to some bugs in the map editor and engine that need tweaking so I’m waiting on those. My new approach might be:

• a heavily coded approach using my original engine choice (Valkyrie) where the tradeoff has been more flexibility for longer coding time
• a ‘drag and drop’ engine (e.g. GameMaker or even RPG maker) for focus on the simple design and possibly dialogue depth
• a fancy 3d approach using Unity

It’s a big commitment, but this way the game ideas I have will be fully explored from several “angles” and perhaps a trilogy of games will be interesting as a small packages.

Technical plans include implementing a game state manager for possible events in the game. I am following the example of Grow Island and Grow Tower (link) where an impressive amount of complexity can come from a small set of choices (namely, 2^n states and for any state requiring m (of total n) actions there are potentially n! / (n – m)! paths to it – so I don’t think I”ll run out of options for state paths). I’ll plan out a small set of ‘actions’ which trigger events and also toggle it’s bit in the state set. Actions could then require states to be activated, and different states could trigger different sets of events, etc. A simple bitset could handle all of this, so I will just be implementing a simple way to define actions, objects, and events the character knows about and the paths of events\states that lead to them.

Lastly, I’ll be meeting with DJ to develop some dialogue scenes\paths. Perhaps I’ll use Valkyrie to implement the gamestate idea, Game- or RPGmaker for a dialogue intense experience, and Unity to explore lighting and environment.

Diet overview

Diet is my first attempt at following some different trends in independent game design, mostly focused on creating unique and emotional responses through interesting literary elements, or even a general storyline. Recent major inspirations include Dear Esther (the Chinese Room), Today I Die (Daniel Benmergui), and Ceramic Shooter (Theta Games). All these games are vastly different, but what is interesting about them isn’t necessarily any game mechanics but a clear attempt to inject interesting literature into interactive media. I feel this trend is new (at least in reaching the indie mainstream) and a good show of maturity and progress (yes, I enjoyed Heather Chaplin’s GDC rant) for games.

Diet is a story focused on body image and the absurdity in schemes to get people feeling bad enough about themselves to hurt their bodies in the name of losing weight (e.g. harmful dieting, anorexia, bulimia). The first thing that struck me about the story (to be posted) was that it was a simple concept, interesting, and even included some, albeit small, cultural commentary. Body image and the advertising industries attack on it affects everyone, but it certainly hurts women more than men, which is important. It’s important because men still dominate the gaming industry and demographic. Creating games and content directed even slightly towards women (without sexualizing and\or patronizing them) is an essential step the industry will have to take to continue it’s stride to be culturally relevant.

Development-wise I’ve just started setting up the Valkyrie engine (XNA) to get ready for a simple, topdown pixel 2d  project. I’ve temporarily hijacked pokemon-ish pixel art until I find content suitable for the game.

Summer Project Overview

With no current job I’ve taken on several game projects I’m very excited about. I’ll likely be providing development-like updates sporadically throughout this summer about each one.

biogenesis
deadline: August 16th, 2010
platform: XNA
David and I will be revamping and revisiting most of the different aspects of the project including, but not limited to:

• threading management\communication
• neuroevolution (NEAT)
• population dynamics
• fluid dynamics
• environment interaction (small and large scale)

I will post the original version we made for class soon.

prolium
deadline: ?
platform: XNA
I plan on implementing the AI system for this game still in early development. It will be a simple FSM design, but robust and abstract enough to be easily ported. I may also revisit their collision code and implement more efficient collision (it is currently a somewhat inefficient bounding box O(n^2) design).

Diet
deadline: June 7th
platform: XNA
A 2-3 week project I started with a friend and creative writing grad to explore quick story\game development and also different ways to make the story and game mechanics mesh together to create unique gaming experiences. More on this to come. I will be using the same engine Prolium will us, Valkyrie, developed by my friend Jason Spafford.

I didn’t plan on all of these to be in XNA, in fact I really wanted to focus on cross platform and open source development, but it just so happens that XNA worked out for these projects, but upcoming ideas will be implemented in Unity most likely. I may be doing some crash GameMaker designs as well!