Grey: The Lost Technology

About the Game

Grey: The Lost Technology is the first project for Team Aurora, the independent game studio a few friends and I co-founded. Grey was successfully Kick-started in May of 2012. We were able to travel to PAX East and meet with a lot of fellow developers and met some really cool people. The game is an action RPG that explores the possibility of an overpopulated Earth and the humans who leave to find a new planet to call home.

Development

The game is programmed in C# using the XNA Framework. The game does not use external libraries, and instead uses the game engine we have programmed called “Aurora2D”.

Game

The game is primarily Quest/Narrative driven. What this means is that you need to speak to someone, who will give you a quest. Once this quest is completed you will be awarded with another quest, or you will tasked to talk to a person who will give you quest. The dialogue system is something that I spent some time working on to make sure it functioned just right. Imagine the dialogue mechanic like any RPG, or text-based action game: The text shows up in a box and then continues to show up in chunks until a response is required. Each response can link to certain objects in the game. Talking to someone can give you:

  • Quests
  • Money
  • Health
  • Experience
  • Items

Alternatively, it can direct you to more dialog. Implementing this is primarily about a good structure and design of the dialogue objects themselves. A Talker, when spoken to, evaluates each dialogue that is tied to them. They accept commands and react accordingly.

Another large contribution of mine is the design and implementation of the map system. A map is designed like so:

  • Map
    • Levels (Can be viewed as subsections of a map)
      • Layers
        • Tiles
      • Group Objects
      • Spawners
      • In-location markers
      • Characters

A map is broken down into levels (read: sections), then a level is broken down to handle each component that is drawable from the tabs in the editor (See below). So the structure is simple, each type of object has their own list, and when the maps are saved, they are serialized in an overridden XmlWrite that structures each object list as a group. However the most revolutionary part about the serialization is about saving the tiles. When serializing the tiles, there is a dictionary that holds a dictionary, kind of like this: Dictionary<int, Dictionary<int, Tile>>. This can be seen as [x][y] = tile. You might be thinking that it should be stored as an array, but when saving an array it saves all the empty positions, and we don’t want that. So I wrote a loop that writes out each tile within an <X> element and a <Y> element. The <Y> element holds the tile position in the texture, and then also holds an index to a texture that it uses. The ending result looks kind of like this:

<Level>
  <ScreenWidth>20</ScreenWidth>
  <ScreenHeight>12</ScreenHeight>
  <Position>0,0</Position>
  <Textures>Content/Textures/Tiles/Sand_01.png</Textures>
  <Layer>
    <Name>Sand</Name>
    <Priority>-15</Priority>
    <CollisionType>0</CollisionType>
    <X0>
      <Y1>0,1</Y1>
      <Y2>0,2</Y2>
      <Y3>0,3</Y3>
      <Y4>0,4</Y4>
      <Y0>0,0</Y0>
      <Y5>0,0</Y5>
      <Y6>0,1</Y6>
      <Y7>0,2</Y7>
      <Y8>0,3</Y8>
      <Y9>0,4</Y9>
      <Y10>0,0</Y10>
      <Y11>0,1</Y11>
    </X0>
  <Layer>
<Level>

This saves us a tremendous amount of space and is a lifesaver in terms of distribution of the final product (because there are less files to transfer, it’s much easier to share). To read more about my theory and logic behind this serialization concept, check it out here: Problems of Storing Maps

Editor

Since we created the game with a framework, and did not use an existing game engine, we needed to create a game editor. The game editor is something of my own creation with the exception of the Navigation Mesh Editor written by our other programmer, Jacob Jackson. The editor is an XNA project that is supplemented by Windows Forms. When the game launches is creates the Control Panel that the designers will be using to manage game assets and map textures.

Control Panel

Grey Editor: Control Panel
Grey Editor: Control Panel

The control panel offers all the flexibility and options that a game designer needs to fill in a level and create everything that is going to be in the level. On the surface you can see that you have the ability to manage:

  • Texture Placement/Selection
    • Animated
    • Static
  • Objects
    • Map Links
    • Characters
    • Enemy Spawners
    • Location Marker/Zones
  • Particles
  • In-Game Items

By adjusting the Edit Mode, you will have access to different functionality offered by the editor. For example switching from TILE (which allows you to place all of the items offered in the tabs) to PATROL_EDITOR, you will be able to draw patrol path lists that and have the ability to customize them. There is also an Edit Mode for drawing the Navigation Mesh on a map. Lastly, there is another edit mode for drawing world-space collision geometry.

The Draw Mode combo box allows a designer to change between:

  • Drawing – Draw an object in the scene
  • Deleting – Delete an object in the scene
  • Editing – If drawing collision, use to add vertices to a shape
  • Transforming – If drawing collision, use to grab and move vertices of a shape

Tools

Collision Editor

animationeditorSome of the coolest parts of the editor are in the Tools Menu. The tools menu provide a designer with the ability to add collision geometry to each and every character model/animation that exists in the game. Using the Collision editor is simple. A list is populated with all the animations from the spritesheets and then the selected spritesheet is drawn and all that is required is to click and drag to draw a collision box. Rotating the collision box is done by holding space after you dragged the box out to it’s appropriate size.

Data Editor

The Data Editor gets into the nitty gritty of the actual game itself and allows the designer to

  • Create all items in the game
  • Create all the quests of the game
  • Create magic effects
  • Alter “New Game” configuration options

questeditorThe quest creation system is a portion of the editor that I had a lot of fun working with and was able to really break down a solid questing architecture.  The quest system is broken down like so:

  • Quest
    • Quest Steps
      • Continue Requirements
      • Failure Conditions
      • Rewards
      • Items to Remove
    • Rewards
    • Items to Remove

A quest must have steps to be completable. Think of a game like The Elder Scrolls: Skyrim where a quest often times has a few parts that must be completed to complete the overall goal. To evaluate each of the Continue Requirements, I hook events for each running quest and then when anything in the game happens and fires an event, each quest you are completing will be updated concurrently. This event driven implementation is the core of the quest system. As a supplement, I created what I like to call an action list. The action list is a rolling list of every action that our hero, Oren, performs in the game, whether it’s killing an enemy, clearing a spawner, or changing maps, it all gets recorded as separate actions. This implementation solves the problem of a player exploring the map and killing a boss or character that spawns once in a game, then getting the quest tells you to defeat him, and not being able to complete it. A quest checks the action list in parallel to the events that it handles.

createitemThe Item Editor is also really cool because to complete this I implemented a class parser using C# reflection to handle populating the editor. There is a main recursive function that handles the population aspect. This function takes the object and uses reflection to evaluate each public property and generate a component that best fits the type of property it’s evaluating.

Engine

The engine is a set of utility classes and objects that offer a full suite of functionality and easily pluggable into different situations. Some of the tools offered include:

  • Texture Parsing for Animations
    • Texture Atlases
    • Grouped Textures
    • Single sprite sheets
  • XML Serialization
  • Quad Trees
  • Separating Axis Theorem (SAT) Collision Detection
  • Baseline Menu Creation
    • Including Buttons and Sliders
  • Lots of Extensions for Primitive Classes
  • Input Management
  • Resolution Management
  • Event Management

The library is fully featured and provides us with a very solid base to build Grey with.

Graphical Solar System in C++

Weeks Spent
4
Team Size
2

Information

For Graphics/Game Engine Programming II, our final assignment was to take all of the knowledge we have learned about graphics programming, and lighting models and create a solar system from it. There were two parts to this project:

  • Joint Based Animation
  • Graphics

The assignment was a team project, and I took the graphics side, and my partner took the animation side. We were given about 4 weeks to create this, and I wanted to do some really awesome effects for this, and bring the project to the next level.

Screenshots

SS_01  RockIcePlanetSolarSystem

Development

Real Time Glow

The multiple stars in the scene have a real time glow applied to them. This effect is based on a rendering technique outlined in GPU Gems: Real Time Glow. The technique in GPU Gems focuses on technique that includes multiple rescaling operations on the render texture, scaling it down by small amouts a set amount of times, then rescaling it back up to take some of the work of the blur effect.

This sounded like a costly operation, copying and resizing a texture multiple times per frame for every frame. Instead, I opted to scale it down only once, and then back up. This reduced the amount of memory needed for render textures, and hardly effected render time. On each rendertarget resize, we perform a blur to get the glow texture.

The glow texture is a multicolor texture that is alpha blended on top of the scene to create the effect. It is important to remember to render each object that doesn’t have glow as a blacked out object so that we can block certain objects that will glow. This prevents the glow effect from appearing above objects in the scene.

Shaders

The lighting model used in this solar system is a simple phong implementation. Each type of shader we wanted is available as it’s own HLSL .fx file. So a file that has diffuse and specular is available as a simple fx file, and each permutation that can be made.

You will notice that some of the planets have a lot of texture. As in they look very bumpy or mountainous. I used a heigh map to perform this, and the displace is performed in the vertex buffer using

tex2Dlod

by using this we are able to displace each vertex by a given amount represented by the height map.

Captain Crash

Plays
2,832,824
Hosts
2,427
Days Spent
34
Team Size
2

Information

Full Game: [Play at FlashChaz.com]
Sponsor: ArcadeBomb
Genre: Side-Scroller/Launcher
Release Date: September 25, 2009

Description:

Send Captain Crash flying in this awesome side-scrolling launcher game! Look out for obstacles, some of them can send you flying and others will stop you dead. Rack up enough cash to upgrade your cannon, or hook up Captain Crash with some awesome apparel! Shoot for the stars and get each badge in the game!

Development Details

Captain Crash is a collaboration with Chaz, an amazing artist and game designer. For Captain Crash we wanted to create a throwback to the classic “Kitten Cannon” from our younger years and pay tribute to the game that entertained us so much. Captain Crash was the result.

Tools:

adobe-flash-cs3

Captain Crash was developed fully in the Flash IDE. All art and assets were drawn in Flash by Chaz.

Features:

Captain Crash is a simple game, it involves a cannon that points to your mouse, and a charge amount. We wanted to create a way that was quick and easy to launch out character. What we did was allowed the user to have the ability to see the charge bar what holding the mouse button down and be able to move the mouse around. Sometimes it’s hard to tell what the launch vector will be for Captain Crash until the charge bar is drawn and gives a better idea of where Captain Crash will go.

For the collision, there was no reason to recreate the wheel here, so I opted to use ActionScript 3.0’s built-in collision tester, hitTestPoint. Since the game moves rather quickly, performing really precise collision didn’t make much sense, and was unnecessary.  Checking for ground collision is just a simple if statement and flipping the velocity with a damping amount (to eventually slow him to a stop).

Sponsorship:

We wanted to make some money off of this game, so we put the game on FlashGameLicense and waited to see if we could get any offers for sponsorship. We had a few people contact us about the game, but they weren’t impressive at all. We waited longer, and sure enough, we had an offer that was just right. We ended up making a deal for a Primary License of the game to ArcadeBomb.com.

ArcadeBomb had a request for us, it was to implement their highscore board, which we did, because highscores are awesome! Otherwise, Chaz and I went 50/50 on the initial sponsorship amount, and we still had the ability to sell non-exclusive licenses to other websites.

Crate Crash 2

Plays
330,235
Hosts
417
Weeks Spent
94
Team Size
1

Information

Full Game: [Play at RIPI]
Genre: Physics/Action
Release Date: March 30, 2013

Description:

In Crate Crash 2 the amazing sequel to Crate Crash, use explosions and slingshot-like force to clear all the crates off the screen. Walls and floors around the crates make this more difficult than it sounds. Each level gives you a different configuration of crates and barriers, making you come up with new strategies. Shoot a crate at just the right angle with the perfect amount of force to send it in the right direction and keep it from bouncing back. See how fast you can clear a level, and once you succeed, try to do it again in fewer moves, or move on to the next level.

Screen Shots

crate-crash-2-p2 pIT4I6GYLS5RF

Development Details

Tools:

adobe-flash-cs3
b2d_icon

Crate Crash 2, like Crate Crash, was developed fully in the Flash IDE and uses the Box2D engine.

Features:

The game was developed in the Flash IDE with Actionscript 3.

The game focuses on a simple concept, “Get all the crates off the screen.” To perform this task you are given the ability to click anywhere in a level to apply an impulse with a 4 unit radius. The impulse is applied as a linear strength based on distance. Clicking far away applies little force and a closer click applies a larger force. Alternatively you can click a crate and drag to create a launch vector then launch that specific crate.

With this simple mechanic in mind, I was able to design a final 52 levels that a user could play. This task was made easy by the use of a level editor. The level editor is simple, it allowed me to change obstacles in the level and place them anywhere I wanted. I could save the level as a my own fileformat and then pass that into the game and parse it.

The game also features new obstacles such as Ropes, Exploding Barrels, and Springs. This adds more variety to each level and opens opportunities for more unique level design. The game also features and in-game Level Editor.

editor

The level editor is fully featured with all the tools that would be expected in a usable level editor such as:

  • Object placement, deletion, translation, and duplication
  • Control points for scaling objects
  • Ability to adjust initial properties (rotation speed, etc)
  • Saving and Loading
  • Submitting the levels to the developer

Post Mortem:

Crate Crash 2 & The Future of Crate Crash

Crate Crash

Plays
3,215,029
Hosts
2,245
Days Spent
165
Team Size
1

Information

Full Game: [Play at The Orange Day]
Genre: Physics/Action
Start Date: August 27, 2009
Release Date: February 08, 2010

Description:

Welcome to CRATE Crash! With over 70 levels, your goal is to EXPLODE all the crates off the screen by applying impulses near the crates and other objects to get them off the screen. Press R to restart the level. Also, right-click to disable the audio, and background.

Good Luck!
Danish translation thanks to Frederik Hermund.

Development Details

Tools:

adobe-flash-cs3
b2d_icon

Crate Crash was developed fully in the Flash IDE and uses the Box2D engine.

Features:

The game was developed in the Flash IDE with Actionscript 3.

The game focuses on a simple concept, “Get all the crates off the screen.” To perform this task you are given the ability to click anywhere in a level to apply an impulse with a 4 unit radius. The impulse is applied as a linear strength based on distance. Clicking far away applies little force and a closer click applies a larger force.

With this simple mechanic in mind, I was able to design a final 72 levels that a user could play. This task was made easy by the use of a level editor. The level editor is simple, it allowed me to change obstacles in the level and place them anywhere I wanted. I could save the level as a my own fileformat and then pass that into the game and parse it.

Praise

The game itself has received a ton of attention getting over 3.2 million plays worldwide. Crate Crash has received attention from large companies such as AddictingGames.com, BigFish Games, and King.