Moving Forward

The semester has come to an end. It has been a challenging and rewarding few months. Attraction made it to alpha and is in a very good place as we attempt to relax and replenish our brain meats over the winter break.

As a team we will be ramping up heavily on the PR side of things. Our website, Facebook, and Twitter will be seeing more and more activity. We have also just started our XBox account, giving us the ability to play and review other indie games. This will be essential to our becoming a part of the community. The feedback and support of our peers will be invaluable to our game's success.

We hope to have a code-cleanup session where we will get rid of unnecessary files and code. We will also refactor here and there in order to be ready for next semester.

We've come a long way but have a long road ahead of us before release. We need to develop all of the levels, enemies, scripted events and triggers that will make up the overall gameplay experience. Fortunately, we have equipped ourselves with the tools necessary to make it there. Our level editor, particularly, will allow us to rapidly create new content for the game. Thanks Andrew!

That, along with debugging, optimizing and polishing for release will keep us busy next semester. But for now, time to kick back with a mug of hot cocoa and play some Steam games...oh and XBLIG games, of course.

Why do all the images I used have animals? Whatever.

EAE Opens its House

The EAE Masters Game Studio hosted their annual EAE open house last Thursday. It was a huge success and the house was packed. We were able to commandeer two iMacs to demo our fledgling game, Attraction, in its alpha phase of development. Typically, the senior capstone students don't demo their games at this event because they've only had mere 7 weeks of development time. We felt like we were  ready. The promise of real player feedback left us drooling and we couldn't pass up the opportunity.

The feedback was almost unanimously positive. People love the mechanic and are excited to see the full game this Spring. There was a plethora of helpful criticism and suggestions. A personal favorite comment: "Isn't this the game that was released a year or two ago?" No, Billy, it's a puny 7 weeks old. But it sure doesn't look like it. Great job artists!

A word to all game devs out there: Get your game play tested early and get it play tested often. The feedback is worth a school-bus-full-of-children's weight in gold.

The U of U's press release is here.

Checkout our gameplay trailer:

The Title Screen

A map overview

It's Official!

We are officially incorporated. Tripleslash LLC is alive and kicking. You can check out our website at http://www.tripleslashstudios.com/ and on Facebook at facebook.com/tripleslashstudios.

Keep checking for udpates on development progress and news!

AlphaTest + Stencil Masking in XNA

Our team decided we want a smooth and consistent look for the environment and terrain in Attraction. At the time we were developing our level editor which uses a tile-based system similar to many 2D games. We were looking at ways to avoid a really "repeated" look due to each tile being used over and over to generate a level. Becky suggested we try to "mask" the tiles with a larger, repeating texture. The following explains the process.

The basic idea is as follows, we want this effect:

Here, the purple part is at 50% opacity. The green circle texture is repeatable. The "grass" on the purple tiles still shows through in the final result. Here's how it's done.

First and foremost, set the graphics format like so:

graphics.PreferredDepthStencilFormat = DepthFormat.Depth24Stencil8;

We are going to utilize XNA's stencil masking capabilities. The following are the two stencil masks we need to use.

//This is a stencil. It keeps track of pixels. But only the ones we tell it to.
//In this case, every pixel we pass to this stencil will be written to the buffer because we are using CompareFunction.Always
public static DepthStencilState AlwaysStencilState = new DepthStencilState()
{

       StencilEnable = true,
       StencilFunction = CompareFunction.Always,
       StencilPass = StencilOperation.Replace,
       ReferenceStencil = 1,
       DepthBufferEnable = false,
};


//This one will check what stuff was written to the stencil buffer and will help us to know what pixels to mask.
public static DepthStencilState EqualStencilState = new DepthStencilState()
{
       StencilEnable = true,
       StencilFunction = CompareFunction.Equal,
       StencilPass = StencilOperation.Keep,
       ReferenceStencil = 1,
       DepthBufferEnable = false,
};

These masks will help us "slice out" the portions of a texture that we wish to mask. The AlwaysStencilState will pass every pixel of the texture-to-be-masked to the buffer we are using. The EqualStencilState will then check the pixels that were written and see if their alpha channel passes the alpha test; in this case, if they have an alpha of 127 out of 255 (50%). Great, we have some stencils set up. But how do we use them?

First, we make a buildMask method:

private void buildMask()
{
        _bounds = _camera.Viewport.Bounds;
        _projection = Matrix.CreateOrthographicOffCenter(
             0,
             _spriteBatch.GraphicsDevice.PresentationParameters.BackBufferWidth,
             _spriteBatch.GraphicsDevice.PresentationParameters.BackBufferHeight,
             0,
             0,
             1);
}

This defines a couple of member variables for us. _bounds is for the size of the buffer we will be writing to. Not used in this particular example. _projection sets up the correct view matrix for our masking needs.

Now set up a couple of alpha tests. One to check for 50% opacity and the other to check for more solid values.

       //Create Alpha Test Effect
        _alphaEffect = new AlphaTestEffect(_spriteBatch.GraphicsDevice);
        _alphaEffect.AlphaFunction = CompareFunction.Equal;
        //This value can be 127, 128 or 129 depending on the program used to create the tile. We're shooting for 50% opacity

        //Apparently GIMP gives us 127
        _alphaEffect.ReferenceAlpha = 127;

        //Create next Alpha Test Effect for grass
        _alphaEffect2 = new AlphaTestEffect(_spriteBatch.GraphicsDevice);
        _alphaEffect2.AlphaFunction = CompareFunction.Greater; //Use the "greater than" comparison, the alpha value of the pixel must be greater than the ReferenceAlpha
        _alphaEffect2.ReferenceAlpha = 130;              //The value to test against is 130 out of 255

        //Give the alpha test the correct projection matrix
        _alphaEffect.Projection = _projection;
        _alphaEffect2.Projection = _projection;

Once all that is set up, we can simply draw. Draw in this order 50% opacity parts, opaque parts, mask.

protected override void Draw(GameTime gameTime)
{
        GraphicsDevice.Clear(Color.Transparent);

        //Clear the stencil's buffer
        GraphicsDevice.Clear(ClearOptions.Stencil, Color.Black, 0, 0);

        //Paint the layer to the stencil buffer
        _spriteBatch.Begin(SpriteSortMode.Deferred, null, SamplerState.PointClamp, AlwaysStencilState, null, _alphaEffect);

        //Draw the tile
        _spriteBatch.Draw(_tile, new Vector2(200,200), null, Color.White, 0f, Vector2.Zero, 1f, SpriteEffects.None, 0);

        //End
        _spriteBatch.End();

        //Now we draw the "grass" part of each tile. It is the only part that gets drawn to the rendertarget because of alphaEffect2
        //which says, if you have over 130/255 opacity, get drawn son! We don't use a stencil here because we don't need to keep track
        //of these pixels because we aren't masking them later.

       _spriteBatch.Begin(SpriteSortMode.Immediate, null, SamplerState.PointClamp, null, null, _alphaEffect2);

        //Draw me some grass!
        _spriteBatch.Draw(_tile, new Vector2(200, 200), null, Color.White, 0f, Vector2.Zero, 1f, SpriteEffects.None, 0);
        //Done with grass!
        _spriteBatch.End();

        //Now we paint the mask texture
       _spriteBatch.Begin(SpriteSortMode.Immediate, null, SamplerState.PointClamp, EqualStencilState, null, null);

        //Draw the mask
        _spriteBatch.Draw(_maskTex, new Vector2(200, 200), null, Color.White, 0f, Vector2.Zero, 1f, SpriteEffects.None, 0);

        //End
        _spriteBatch.End();

        base.Draw(gameTime);
}

Take a look at the linked project to see a fully working example. Feel free to use the code however you please but please give me credit somewhere. Thanks!

Click here to download sample project.

Project Management

In deciding which method to use for project management, we settled easily on an Agile process. Most of us have had experience with Agile and it seems to work very well.We are using 1-week long sprints and slicing up tasks into smaller tasks which can reasonably be completed within one sprint.

Our team has decided to use Asana for project and sprint management. It is a great web-based software that is absolutely free!

Asana in action

Asana has greatly helped us organize tasks and responsibilities as well as communicate quickly about important issues. Using a project management software is much more effective than simply using email or trying to keep track of things by hand.

Attraction Update:
Things are rolling along quite well and we just completed our first sprint! The following were done during sprint 1:

• Menu system
• Level XML serialization/deserialization
• Basic level editor

Not bad for one week! This shows the power of dedicated team members and a good use of the Agile process.

For sprint 2 look forward to some actual level development and gameplay! Happy Halloween everyone!

Entity System Architecture

Things are rolling along smoothly and in our team meetings we are pinning down a lot of important aspects of the game. One of those is the architecture we will be using for development in XNA. We will still be using the Farseer Physics engine but instead of an object-oriented approach, we will be using an entity-system approach. This seems to be the standard in most game shops and I am excited to become more proficient at it. Here are some links that illustrate ES:

Evolve Your Hierarchy
Entity System vs. OO Game Engine

Andrew has experience with this architecture and is helping to bring the rest of us up to speed.

For version control we are using git and TortoiseGit.

Things to watch for that are being worked on this week

• Level Editor
• Tool for modifying game constants during run time and see changes in real time
• Menu System
• Improved controls

After being sick all of fall break, I am ready to get to work. 

We Have Been Chosen

Yesterday Professors Bob and Roger announced the three games that were chosen for production. They shared some feedback from the panel of industry professionals and it was rather insightful. Apparently none of the games piqued their collective interest enough to warrant a stamp of approval. I seem to remember that one of the panel members announced to Bob and Roger, "You shouldn't make any of these games." Well, thus we observe one of the benefits of indie development: we get to make a game that, at first glance, isn't appealing to AAA pros.

Cutting to the chase, our game, Attraction, was chosen! Along with Heroes of Rock and Ninja Royale, we received various team members from the other now-disbanded groups. Maybe I'm biased, but I feel we received the cream of the crop. We received some amazing talent and have a solid dev team. The following makes up our roster for the newly expanded Team Salty:

Kyle Chittenden - Team Lead
Becky Pennock - Art Lead
Jon Humphries - Design Lead
Brendan Wanlass - Engineering Lead
Tyson Anderson - Engineer
Paige Ashlynn - Engineer
David Hurst - Engineer
Andrew Jones - Engineer
Cory Haltinner - Artist
Evan Munro - Artist
Diana Ngo - Artist

We have a solid gameplay mechanic and are now designing theme, narrative and artistic style. I have no doubt that we will make a game that will surprise some of the nay-sayers and garner some interest in the indie community.

Out of our Hands

Yesterday all 8 teams presented their games to a panel of industry professionals. All 8 teams did a great job and I honestly have no idea which games will get picked. I have a few in mind that I think won't get picked, but then again, I'm not so sure. I would, of course, love for our game to be picked. If that doesn't happen, however, there are a couple other games which I believe have great potential and would be happy to work on.

We find out tomorrow which 2 or 3 games will actually be developed. We meet our new teams and begin jamming on ideas. This is huge. I will be working on this game and with these people for countless hours over the next ~8 months. I trust Bob and Roger's judgement and I'm sure all the teams will have a chance to make a great game.

Keep your fingers crossed!

Prototype Progress

Our team has made great progress on the prototype and we are feeling pretty confident in our game. We have settled on naming the game "Attraction." Who says puns can't be fun? Between the magnetic mayhem and relationship narrative, we feel it's a pretty fitting name.

Controls are tightening up, mechanics are improving and becoming more robust and we are almost completely finished with the level we are building for the prototype. Using Farseer Physics was a great idea and things are rolling smoothly. We hope the professors, students and other judges will be impressed!

Here are some screenshots of the game in its current state:

Launching yourself through the air with a Repel Magnet

A tricky puzzle that requires pulling yourself up then launching to the right

Swinging across a gap with an Attract Magnet

All loaded up in a bucket and ready to Repel yourself to safety

Using your sidekick's head to launch to new heights

Inspiration

After a couple of "jam sessions," where we, as a group, discuss the game and come up with ideas for various elements, we have come up with a pretty solid concept and hook. The gameplay should be unique and the narrative should be interesting and fun.

Here are five titles from which I will be drawing inspiration:

Donkey Kong Country 1-3

These games are fantastic. They were created by Rare for the Super Nintendo. Based on the original arcade game Donkey Kong, these games take Kong's story to a whole new level. Fast paced gameplay with excellent graphics, story, sound and controls make for a very solid platformer. I will examine the clever puzzles and tight controls found in the Kong series in order to bring some of these elements into our own game.




Portal 1 and 2

Portal 1 and 2 are excellent examples of thinking outside the box. Throughout the entire first person experience, you never once wield a machine gun or rocket launcher. Yet, you are faced with enemies, challenges and puzzles that keep you on the edge of your seat. Using only your portal gun, you must navigate puzzles and outsmart the bad guys. The fantastic narrative seals the deal in this must-play series. I chose these games as a source of inspiration for gripping narrative, witty dialogue and clever non-combat gameplay.

Give Up, Robot

This is a simple browser flash game that I just can't get enough of. Essentially, you are given an mobile game-style puzzle-by-puzzle experience in which you must pass through puzzle-levels one at a time. You are a dinky robot blessed with the ability to jump and use a grappling hook. That's it. You will find yourself flying over games and swinging around lava chunks and before you know it, you've died 553 times and passed 42 levels. I will try to learn what makes a game addictive and captivating from Give Up, Robot.

The Legend of Zelda: Ocarina of Time

Zelda games are typically amazing and this one is no exception. I could go on and on about everything that makes this game great. However, I will limit myself to one of the most-loved gameplay mechanics of all time. The Hookshot. Our game will feature a similar mechanic in that, you can pull yourself toward objects or pull objects toward you. On top of that you will be able to push yourself away from things. This mechanic will make up the core of our gameplay experience and our puzzles will be based almost entirely around the idea. For this reason, I am taking Ocarina of Time as an example of how to do the mechanic right.


Limbo

Limbo is indie game development at its best. This 2D platformer does everything in its own way and holds surprises at every turn. The art is beautiful and the gameplay is simple and engaging. The puzzles are extremely well done and did I mention that this game is just plain creepy? The simplicity seems to enhance the weirdness of this game. Limbo uses a physics-based approach that we will be pursuing in our own game. I will use this game as a source of inspiration for technical and creative ideas.

I believe that if we take some great games as examples of how to do things right, we can save ourselves the time and headache of trial and error in various areas of development. Even though we only have 8 or 9 months and limited experience, I'm sure we can bring a great experience to the table by paying attention to what makes a game fun and keeps people coming back for more.

Time To Get My Hands Dirty

The eight games that are to be prototyped have been selected. There were quite a few exciting game ideas presented last week and there are several that I would be happy to work on. I was placed on a team assigned with creating a prototype for a game we will refer to as Magnet Bot. YES!

The basic premise of this game is, a robot's girlfriend (yes, robots date each other) has been stolen and dissembled. Your job is to find her, put her back together and take down the baddies who stole her. Luckily, you have some nifty tricks up your robot sleeves that will help you do just that. Using your abilities to magnetically push and pull on metal you will be able to navigate various clever puzzles and hair raising challenges and find your long lost love.

I was immediately interested in the concept of this 2D puzzle platformer. It has potential to be a very clever game that will find a perfect home in the XBLIG market. We have a solid team of two artists and two programmers. Myself and my buddy Dave Hurst will tackle the code and our artists Jon Humphries and Cory Haltinner will take up the artistic content.

We have 4 weeks to create a catchy prototype that presents the game's potential and solidifies the fun factor.  Time to dive into XNA and see what we can do!

And So It Begins...

Dramatic, right? I will admit, there were a lot of emotions flowing as I sat through the first class of what will be a two-semester senior capstone course. Over the next nine months I will be working with a cross-disciplinary team of students to create a video game from the ground up. If all goes well, this game will be released on the XBox Live Indie Market. This is the kind of opportunity that could be an enormous springboard into an exciting career in the entertainment industry - something I have dreamed of since I was a kid. Realizing that all my efforts over the years of my academic career  have led me to this point has me very excited--and a bit anxious. This is it. The big one. The course that will show what I'm made of. The course that will either provide me with amazing experiences and valuable portfolio pieces or the course that will be an epic 9 month failure.

I can' t wait to dig in and start. Each student has been tasked with providing an individual game pitch. From these pitches, 10 or so games will be selected as finalists from which two or three games will finally be selected for production. It's surreal to think that one of all those crazy game ideas I've had over the years could actually become a reality. Regardless of which title I will end up working on, I hope to be a valuable asset to my team and hope that my team shares the same enthusiasm I do.

So, as Mario would say, "Here we goooooo!"