Ghosts on a Plane
Welcome to “Ghosts on a Plane”, the revolutionary new game from Sparkle Motion Games. In “Ghosts on a Plane”, the goal is to prevent the house in the center of the screen from being haunted by the surrounding ghosts and skeletons. The ghosts will try anything to haunt the house, and they are constantly learning and adapting to your playing style by using rtNEAT. The skeletons are a dumber bunch, and they simply use A* to navigate around rock obstacles towards the house. The only way to stop the army of ghosts and skeletons is by strategically placing your turrets around the house within the red circle. Simply click and drag on a turret to move it around. For each enemy you destroy, you get 10 points. However, every enemy that reaches the house increases the house’s “haunt level”. When that level reaches 100, the house is effectively haunted, and the game is over.
Robust, modular game engine
Robust game world which computes the game logic
Complex AI which adapts to the player using rtNEAT technology
Highly and easily expandable GUI system
Random terrain generation using the fault line algorithm
Simple AI which navigates around obstacles using A*
Random vegetation density based on a file
Audio using OpenAL
B-Splines for smooth, scripted camera movement
Engaging user interaction
Fun and quirky gameplay
(right click save as)
Ghosts on a Plane was created by Sparkle Motion games.
Sparkle Motion is Ryan Cornelius, Michael Chrien, John Sheblak, and Dustin Silverman.
We initially approached the project wanting to make a fast paced, arcade style action game using NEAT for AI. The general design was based around teaching agents in video games to go towards a "gold mine" or certain point on the map using NEAT. NEAT allowed for adaptive AI agents to be created and trained in a relatively short amount of time. This idea makes for a cool looking demo, as the user is able to witness learning in real time and can see the progress of the AI. We decided to improve on this idea by creating a way for the user to interact with the agents. In our case, we wanted the user to protect the "gold mine" by placing turrets around it, with the ultimate goal of the agents learning to avoid the turrets to reach the "gold mine".
In our initial design stages, we argued over what the theme of the game should be. One idea was a literal gold mine that is protected from waves of barbarians. Another was to defend a piece of cake from roaches using flashlights. We finally settled on the idea of using ghosts as the agents. This way we could show off translucent effects, and other cool technical things. The question was now, what are the ghosts attracted to? Why not a house to haunt on a geometric plane? Thus, "Ghosts on a Plane" was born.
Our biggest hurdle was technical stuff. We had a killer design with cool concept art, but how were we to incorporate some of the knowledge we learned from the class into the game? We decided to write our own engine. John wrote all of the rendering engine and most of the object rendering code. He also incorporated a lot of small technical achievements into the game such as different types of splines, a mini map, particle emitters, several model loaders, and a script parser. Ryan wrote all of the game world and logic code. His work allows for objects to be easily added on screen with different types of AI. He also worked hard to get NEAT working in the game. Michael served as the game's designer, but that didn't spare him from technical stuff. He implemented the terrain rendering using the fault line algorithm, variable vegitation, and he incorporated OpenAL into the game. Besides these large accomplishments, he also tied John's, Ryan's, and Dustin's engine code together to create the game. Dustin coded a very robust and easily expandable GUI system. He also created a maze and computed the A* algorithm for the skeletons in the game to follow. We proceeded to make the game and cross technical hurdles as we crossed them.
Our initial milestone was very poor looking. We just wanted to show off our rendering system, so all it did was display a static scene. There was no user interaction, and our texture loading only supported bitmaps, so the overall quality was very poor. While it looked bad, it did show were we were going with our project, and it showed that we had an overall plan in mind.
Our second milestone was designed to show off game logic and progress on major technical things. We included a GUI with skinned buttons, and poor looking terrain rendering. Our simple game logic showed ghosts (represented by prisms) b-lining straight for the house, and the user was able to move turrets around. The turrets fired and could kill ghosts. Also, this version used OpenAL to play "Thriller" in the background. This was a huge hit with the dev team, especially when the game crashed, the song still played. This was the barebones beginning of the build you see today.
Our final build was a huge undertaking. The terrain was vastly improved using the fault line algorithm to perturb the landscape, smoothing to make it look nice, and finally the addition of proper normals and texturing added a realistic effect. Our AI significantly improved. NEAT was added for the ghosts, and A* was implemented for the skeletons (watch them avoid the gravestones). We improved our menus, loading, and other assorted cosmetic things. We also allowed for more user interaction with the game through camera movement and turret placement. One of the coolest things is that the game is fully scriptable. Each wave is determined by a file in the data folder which keeps track of spawn locations, ghost/skeleton numbers, and whether a turret is rewarded.
In conclusion, making this game was a great learning experience for the entire team. We managed to create a fairly nice looking demo with some fun game play and really quirky artwork.
©2006 Sparkle Motion Games