Platform Hack

Whats next for Platform Hack?

2012-01-25T10:36:00.001-08:00

This site has been quiet for a while, but it doesn't mean Platform Hack development has ceased. An update of the game is in the works!

With Platform Hack 2.0, we're looking to make some big improvements to the game. Lots of the frustration with the later levels will be cut down. Some of the abilities will be tweaked and re-balanced. No more dead-end advancement (you'll be able to beat every level with any set of skills). Tons of little bugs will be fixed. And best of all, we'll be releasing for both PC and XBox Live!

Stay tuned for more updates in the near future!

Tough Jumps!

2011-10-24T14:43:00.000-07:00

Some people have mentioned they got frustrated with various jumps in the game. I decided to put up a video that shows how to beat these jumps, with a various mix of skills. In general, Wall Jump + Grapple Hook is all you need to get around the game world. Triple Jump makes things a bit easier. You don't ever actually need Power Jump, though it makes both of these keys trivial.

Reviews

2011-10-24T14:38:00.000-07:00

Reviews are coming in for Platform Hack. Not all are glowing, or even positive, but hey, that's what you get for releasing something out into the wide world! Thanks for spending your time to review my game!

I was surprised by how hard most people found the game. Although I was happy that at least two reviewers completed the game before posting their writeups. For those who got frustrated on tough jumps, maybe I'll post some videos on how to beat those spots. I assure, the entire game can be beaten, although certain skills may be necessary.

"As with most of my Indie purchases, this was an impulse buy. After all, priced at a dollar, even if it’s bad, you’re still getting your money’s worth. Thankfully, Platform Hack is not bad, it’s actually pretty fun. It has a good mix of RPG, action and platforming. It’s a decent length, with a wide variety of levels and enemies. Overall, it’s a pretty dang good deal for 80 Microsoft points."
-Gamepads Down

"'Platform Hack' is a 2D hack 'n slash RPG platformer. It has it's own unique look with hand drawn artwork/features as wells as a some very involved gameplay mechanics... I actually found myself cussing a times due to the difficulty of the levels, and the boss battles. It is all managable, but it definitely got a bit nerve racking at times."
-OtakuDante's Gaming Inferno

"So when a title pops up offering platforming, shooting/fighting all in one package my brain says give it a try and spend the MS Points"
-Eff Bee Eye

"The craziest thing about this review is that I can’t answer why I played all the way through it. I could name many better games that I didn’t put this much time into. There is at least some quality to [Platform] Hack, but I am a pretty big sucker for level-ups."
-Extra Guy

"Once you get to the actual game, it’s a hacky-slashy platformer. I never would have guessed by the name."
-Indie Gamer Chick

Platform Hack Released!

2011-10-19T07:59:00.000-07:00

Platform Hack is out on XBox Live!

http://marketplace.xbox.com/en-US/Product/Platform-Hack

Check it out now!

Free Trail

$1 for the Full Game

Platform Hack Trailer

2011-09-26T15:59:00.000-07:00

Cover Art!

2011-09-06T18:55:00.000-07:00

The cover art for Platform Hack is complete and it looks great!

Thanks to Mike D and Ena M for the great work!

In other (related) news, there have been some holdups with the playtest. Some of the new features I built (namely the Dragon Breath) run much too slowly on the XBox. So its back to the drawing board to increase the optimization.

It's a pretty busy month for me with other things going on, but I still hope to get the playtest out soon!

Last Boss Woot Woot

2011-08-18T20:35:00.000-07:00

Scripting done. Just need to tune him now ;)

Powers Preview

2011-08-14T21:57:00.000-07:00

Power-Ups are coming together! The powers are selected when a player gains a new level, and are split into three "trees" - Attack, Defend, Explore. Here's the menu to select the powers:

Attack will contain upgrades to the sword and gun, as well as a new attack called "Power Beam". This shoots out a beam of pure power in a short player-directed burst.

Defend contains upgrades to health (double health, quad health), as well as a spherical Shield that will protect the player from attacks. At higher levels, the shield will even do damage to enemies in range!

The Explore tree contains all the jump upgrades (double, triple, wall), the grappling hook and a new ability, called "Power Jump". This is basically a jet pack, that lets the player "fly" anywhere in the map for short bursts.

All powers are limited by a "mana" meter that will slowly refill over time. Stronger powers (Power Jump, Power Beam), will drain the mana meter faster, so watch out.

I'm thinking the powers will be a lot of fun, an the three different trees will give players different ways to play the game. Of course, by the end game you'll have all the powers. One of the keys will be tuning the enemies and maps so the game is still a challenge with the full arsenal!

Still some more backend coding to wrap up, one last boss fight, then putting it all together. Hoping to have a playtest available for both PC and XBox AppHub first week of September!

Script and Maps and Such

2011-08-04T20:55:00.000-07:00

Added two new features.

1. Scripting window. This is for conveying story to the player. When the player runs over a trigger, it pops up a "dialog" window that can be read (press A) or bypassed (press B). Poor man's cut-scene!

2. World Map. The map will be used to select the level as you progress through the game world. I found some great brushes on deviantart that were used to make the map: http://calthyechild.deviantart.com/art/Tolkien-style-Map-Brushes-138796530

The game is coming together quickly. One more boss and the level-up / power system.

Then its on to fleshing out all the levels and polishing till it shines!

Boss Fights Delivered

2011-07-30T20:01:00.000-07:00

End result of a day of programming, two new boss fights!

The mummy boss chases after the player and melees them on the ground. If the player is off the ground, the mummy will cast a spell which will launch the player into the air.

The dragon boss emerges from a random side of the screen and breathes fire. Afterwards, he's vulnerable for a short time. In between attacks, fire blocks fall from the ceiling to crush the player.

Lots of fun programming behind these guys, mostly abstracting all the code written for the spider boss, and cleaning up code for "beams" - which are basically a list of vectors that can be used for collision or "drawing" lines with particle effects.

Next steps - a world map, and some scripting for dialog/story!

New Boss Design

2011-07-29T15:23:00.001-07:00

The design doc for two new bosses! Dragon and Mummy!

New Worlds!

2011-07-21T23:17:00.000-07:00

Desert:

Mountain:

Wasteland:

New Baddies

2011-07-20T22:16:00.000-07:00

Acknowledgements

2011-06-14T14:54:00.000-07:00

People:

Ena M - http://behindtheveil.deviantart.com/
Ena is an amazing artist and she dashed off the character sprites in Platform Hack without breaking a sweat.

JoeRoh - http://seedroh.blogspot.com/
Joe came in at the 11th hour and saved my butt - adding polish to a ton of art assets, as well as some great playtest advice. Joe is an aspiring game designer with his own blog as well.

Anna D - http://www.annadonlan.com/
Anna drew some phenomenal logos for both Daydalus Studio and Platform Hack. She's also a talented photographer.

Visual:

Spiral Graphics Forest Tileset - http://blog.spiralgraphics.biz/2011/01/mystery-forest-tile-set.html
The tileset used in game was modified from a sample tileset found here.

Spriters Resource - http://www.spriters-resource.com/
Didn't directly use any of these assets, but the various animations in the spritesheets of classic games were big inspiration.

Steampunk Font - http://hannarb.deviantart.com/art/Steampunk-Font-148871949
Font used on the menus and popups.

Sound:

nosoap radio - http://www.nosoapradio.us/
Some great video game music available here, completly free.

bfxr - http://www.bfxr.net/
Generate 8-bit sounds in the browser, then save to WAV.

soundbible - http://soundbible.com/
Lots of public domain and "open source" sound files here to use. Anything from gun shots to bird calls.

Code:

MRPAS - http://www.umbrarumregnum.net/downloads/mrpas
Algorithm used for the Fog of War in minimaps

Platformer Starter Kit - http://create.msdn.com/en-US/education/catalog/sample/platformer

Game State Management - http://create.msdn.com/en-US/education/catalog/sample/game_state_management

Particle Effects - http://create.msdn.com/en-US/education/catalog/sample/particle

Collision Detection with Rotation - http://create.msdn.com/en-US/education/catalog/tutorial/collision_2d_perpixel_transformed

Tools:

Audacity - http://audacity.sourceforge.net
Audacity is an open source sound editing suite. It can be used to record and edit sound, and export to WAV or MP3. I used this to record various sound effects, change the pitch or length of others, and noise.

Gimp - http://www.gimp.org/
Open source Photoshop. Used to edit pretty much all visual assets in the game, from the sprites, in-game objects, HUD and background art. The two biggest features are the ability to work with the Alpha (transparent) layer, and split images into Grids (which is essential for lining up textures in spritesheets / animations)

Camstudio - http://camstudio.org/
Similar to FRAPs, used to record video for playtests and trailer.

Platform Hack Post-Mortem

2011-06-14T11:59:00.000-07:00

Things That Worked

Stick with the Design

A clear design for Platform hack was laid out at the beginning: a mash-up of Metroid (platform jumping, exploratory powerups) with dynamic world creation of Roguelikes. This was followed through from the start. It helped to not have to change genres or styles halfway through, and the core gameplay feels very similar to what I had in mind.

Prototype, Prototype, Prototype

Breaking the challenges of the game into smaller problems, and then getting those working in isolated environments was key. The main issues - grappling hook, double/wall jump, traps, melee / ranged combat, level design - were all handled in a "sandbox" project. This way I didn't have to worry about breaking the game to try out a new feature, I could hardcode physics constants or whatever until the feature worked how I wanted it. *then* port it over to the game project.

Don't Reinvent the Wheel

Platform Hack borrowed from a lot of great sources, both for code and art. The samples on App Hub were essential, especially the Platformer starter kit, which included the core code for tile-based levels, basic physics (jumping, gravity), sprite-based animation, and collision detection. Other samples were useful as well - Game State Management, Pixel-Based collision with rotation. For the sprites, I ended up using sample spritesheets and having my artist base all the animations (run, jump, attack, die) on those models.

Limit Features...For Now

The original plan for platform hack had dozens of procedurally generated levels, 4 huge boss fights, an overarching story, and a leveling system that let the player specialize in different types of powers. Those plans are still on the table for the final release, but about a month out from the deadline, I realized I wasn't going to hit all those marks, and set my sights for a much smaller goal - a stable game with polished art and gameplay. In the end, I was able to deliver by the deadline.

Things that Caused Problems

Collision Detection

Pixel based collision detection can make you want to tear your eyes out. When it doesn't work, it’s very hard to figure out why (you can't step into and iterate through the 10000 item color array to see a certain pixel isn't set to alpha), especially if you are using matrix math for rotation and translation. One thing I ended up doing was creating a TestPixel object, which would basically flip on if it was "collided" with. This let me see a path of where swords, bullets and enemies passed through. Unfortunately, this was very slow (1 fps) and didn't always work. At the end of the day, I removed most of the per-pixel collision, and only used it where absolutely necessary.

Procedural Level Generation

I created a project that would use the Angband algorithms to generate a map, and throw in various enemies, traps and platforms. However, I still had to manually go through the text files and make sure there were no inescapable dead ends or unreachable keys. The tough part of procedural level generation is making sure the "maze" can be beaten, once you start adding in locked doors. The early levels also needed additional manual intervention, to give the whole thing a bit more flow and gradually increase the learning curve. As soon as the player uncovers a new trick (jumping boots, grappling hook), you want to give them the opportunity to use it, which you have to manually design. this is why I'm thinking, even in the final game, the procedural levels will only end up being 50%. Stages where you uncover a new item, or fight a scripted boss fight, will need to be hand-crafted.

Loading Assets on Xbox

The scripted boss fight was fun to put together, but not the most elegant solution. The first build I ended up with dozens of 1500x1500 images that not only had to be loaded into Texture2D objects, but also read into Color arrays for pixel-based collision. Needless to say, this caused some OutOfMemory exceptions when attempted on the XBox. The solution was reduce the size of the image files (to 800 x 600), and then build a manifest loader that would reuse certain textures for various animation frames (the idle frame is used in almost every animation), and also only generate the Color[] on frames that needed collision.

Animation State Machines

This is something I'm still dealing with. Animation is one big state machine - trying to map both the player input + the world controls into a believable animation for the player to be in. For instance, if the player is swinging his sword and then jumps, do you continue to play the first ground swing animation? or switch over mid-swing to the jump-swing animation? What if you can't transition halfway between animations and have to start at the beginning? This "transition" issue was a headache to get right. In the end, I decided that animations must be played from start to finish, and you can't start a new action while you are in the middle of one (aka start shooting while rolling, roll while swinging, etc). Of course, the button press will usually still be registered once the animation is over and you'd start the new action immediately. The more complex your animation state machine, the harder this problem becomes.

Lessons Learned

Get It Working First

Work on the hard items early rather than low hanging fruit. You never know how long it will take to figure out an architecture problem (loading assets, collision detection, etc). But its usually more predictable how long it will take to import new art, or tweak small cosmetic bugs. Leave that polish for the end, get the hard stuff working as early as possible.

Art / Sound = Morale boost

It's a huge morale boost when you see your crappy programmer art "skinned" with graphics that look good.

80/20 rule

There's always that last 20 percent you want to get done. But leave 20% of your time for pure polish, not dev.

Lots of builds / releases.

Don't leave stuff in an uncompelled / untested state at the end of the day. During crunch time, do a daily play test. make a list of everything wrong. fix what you can. increment the build number. repeat.

Make what you can / borrow what you can't.

I knew I'd never be able to make original music or draw convincing sprites, so I either found good assets online (free music) or got a friend to draw me sprites. Other stuff that was less important (sound effects, in-game items) I mocked up myself using various free tools.

What's next for Platform Hack?

2011-06-13T07:24:00.000-07:00

The game has been submitted to Dream Build Play! It should be showing up on the list of entries shortly.

So what's next for Platform Hack? The build submitted to DBP was a subset of what I originally envisioned. What I'd like to do is continue working on the game, primarily creating content, for the rest of the summer. The game would go into Peer Review late summer, and hopefully be released on XBox Live in September.

Here are the features I'd like to complete for the full release:

4 Total worlds, with unique tilesets, enemies and boss fights (Forest, Mountain, Desert, Wasteland/Factory)
Leveling skill-tree and powers (Attack, Defend, Explore)
Procedural level generation (for 50% of levels)
Some form of narrative story that links the "quest" together
Infinite mode (similar to roguelikes, where you can continue to "dig" down into the dungeon, and everything scales accordingly)
Overall polish of menus, HUD, etc

The only tough programming challenge is getting the procedural levels dynamic and toned enough that they can be used. Right now I can randomly place enemies and traps, but they aren't set up in a way that makes the overall map feel both coherent and challenging. We'll see if it's doable.

Everything else is mostly content generation, which is slow and steady, but is well within reach for the summer.

Next, I'll be doing a post-mortem of the DBP process, a list of acknowledgements for the game, and a breakdown of the various tools used during development.

Testing...

2011-06-11T04:53:00.001-07:00

New build up on App Hub! Give it a go -

Platform Hack Trailer

2011-06-09T13:06:00.001-07:00

The finishing touches are being put in place! Here's the trailer for the game. A new playtest will be up this evening on App Hub. I'll also be laying out the plan for the game post-DBP.

Taking Shape...

2011-06-05T14:57:00.000-07:00

Latest build - beta 1.1. A new playtest is out on App Hub: App Hub Playtest - Platform Hack

Big thanks to everyone who has helped out so far. Anna D, Ena M, and Joe Roh! Without you guys this thing would not be possible!

Only 9 days left and still lots left to do -

Playtest!

2011-06-02T22:10:00.000-07:00

We are in playtest!

App Hub Playtest - Platform Hack

Crunch Time

2011-05-29T18:02:00.000-07:00

Things are coming together. I've built some full levels with enemies, keys, locked doors and chests.

The XP system is also in place, so killing enemies will get XP for both the main player (HitPoints) as well as weapon (Sword, Gun) power.

The game still needs tons of balance, not only with the XP and advancement system, but also the level design.

And of course the graphics are pretty blugh.

Hopefully I can have a playable build (that works on the XBox) in App Hub playtest by the first of June!

We have HUD!

2011-05-26T07:39:00.000-07:00

We have a rough HUD, with Health and XP Bar, Items, and Mini Map!

Now just need to wire up everything in the game to the HUD (character level, leveling up weapons, etc).

New Enemies, Miniboss

2011-05-19T21:00:00.000-07:00

The latest build has some new enemies. In the forest, there will be 5 standard enemies:

1. Spider - paces back and forth between walls / ledges. Hits with touch.
2. Jumping Spider - Moves towards player, constantly jumping. Like the flying turtles in mario.
3. Throwing Bandit - Paces. Throws a dagger.
4. Slashing Bandit - Paces. Slashes his sword if you get too close.
5. Flying Birds. These "home" in on the player. I'm thinking of having these continually spawn from "nests" that must be destroyed.

I also added the miniboss that was alluded to in the previous post. The mini boss is the bandit king, and will "drop" the pistol when he's killed (probably early on in the game, lvl 2 or 3).

Basically, he'll try to maximize his distance between himself and the player, and if he has an open shot for half a second he'll start firing. The only way to beat him is to corner him and bash him down with a sword.

Next step is designing the HUD!

I'm still unsure whether I'll get the lvl/power up system working for DBP. Procedural levels are also looking doubtful for the DBP build, especially since the worst case scenario would be if the judges got a non-functional map and couldn't play. It's probably better to invest dev time in polishing the pure gameplay, animations and graphics.

Thats it for now!

Update - Boss Fight

2011-05-14T20:21:00.000-07:00

So the goal for today was to get a basic boss fight up and running. Here was the "design document":

Here's the end result:

Lots of work still to do polishing everything up, but the boss can kill the player...and the player can kill the boss.

Also, got 4 directional parallax scrolling working, and locked doors with collectible keys.

The mini-boss (Bandit King) will be next.

Only 1 month left!!

Platform Hack Alpha Progress

2011-05-09T07:20:00.000-07:00

The build is coming together. Here's a quick playthrough I put together that shows the latest features.

Grapple Hook Revisited

2011-04-13T13:37:00.000-07:00

There was a request to go into some more detail for the grapple hook. Original Post

So what I've done is taken a fresh copy of the Platformer 4.0 solution and added only the Grapple Hook stuff. The ZIP of the solution is attached below.

Basically, there are 3 new classes and some changes to Player.cs

The three new classes are in the GrappleHook Folder:

Collision.cs - This contains the core functions used "under the hood".
DrawPrimitives.cs - This class contains some functions used to draw various shapes. The main method used is DrawLine2.
Grapple.cs - This class contains the guts of the grapple hook logic outlined in the initial blog post

Changes to Player.cs:
There are some new member variables and a few methods. I tried to comment everything that was new with "GRAPPLE HOOK"

I also added WhitePixel.bmp to the Content/Sprites/Test folder. This is used to draw the line. (Also removed the music to cut down the size of the zip)

A few changes to the logic and style of the Grapple Hook:
1. The grapple hook "rope" will now shoot out 500 pixels at a rate of 2000, which is pretty much instant.

2. The grapple hook will stay extended as long as you hold the button (instead of collapsing back to 0). This makes it easier to attach.

3. You can't shoot the grapple hook if isOnGround = true. This makes use a little more natural and prevents the odd bug where you would attach and then the grapple curve would force you under the world or the tile below you.

4. The swing itself is slightly slower (using 2000 as the gravity constant).

Places for Improvement:
1. Some games have the grapple hook continually "shrink" while it is attached (Hook Champ, etc). This gives the player the feel that the grapple is "elastic". You could implement this by moving the player slighly "up" the rope every tick, and then re-calculating the Swing Curve. The hard part is getting the velocities right so the swing is smooth, since we're not using actual angular velocities / momentum, but the path of the pendulum curve.

2. Prevent the Grapple hook from attaching to horizontal walls. This would require a change to the GrappleCollision function (and the getLineCollision function), to only attach if the Grapple "hook" is colliding through the lower X plane, instead of the Y plane.

3. Better formulas for angular velocities entering and exiting the swing. Right now I'm using some cheap hacks (delta position -> velocity) to determine the initial and launch velocities when starting or exiting the grapple swing. Some real physics might make it feel a little smoother.

Download: GrappleExample.zip

Playtest

2011-04-11T21:31:00.000-07:00

A new version of Zombie Bash is in playtest.

I was hoping to get it to market sooner, but I figured you might as well do the thing right the first time, even if it takes a long time (The Blizzard philosophy). And its amazing how time consuming it is programming High Score screens to work just right...

Zombie Bash Playtest

It's a Trap!

2011-04-07T10:29:00.000-07:00

Traps are essential for 2D games. They present a challenge for a player that can only be defeated by timing and patience, rather than reliance on gunpower.

I decided to build 3 different types of traps for Platform Hack. Moving Blocks, Spinning Blades, and Flame Turrets. Each of these uses slightly different technology to work, but since they were similar enough I crammed all the functionality into a single class, called Trap.

The Moving Block is the simplest type. Its basically just a moving tile that hurts the player on collision. Some games have blocks that "crush" the player, and can also provide solid collision from the other directions (top, sides). I decided against this type of falling block, since it would require implement a "crushing" system of player damage. Instead, if you touch the block from any direction, the player will be damaged. Good level design (encasing the falling block inside Impassible tiles) can be used in conjunction with the trap type to good effect.

The Collision is pretty simple:

The Update function contains the only interesting piece of logic, using Linear Interpolation to smoothly move up and then slam down as a funtion of the entire TrapTimer

The Spinning Blade is the next type of trap.

This uses slightly more advanced collision and update logic. Given the same TrapTimer, we do a full rotation of both the texture, and the Rotation Matrix thats use for pixel-based collision detection:

Update:

Collision:

Draw:

One of the "gotchas" of Translation matrices in XNA (or I guess any graphics framework), is being sure to multiple by a translation of the negative origin. Matrix.CreateTranslation(new Vector3(-p.Origin, 0.0f)) This is needed whenever the texture is rendered using an origin. You need to adjust the Translation Matrix in the same way, so that the collision detection is "synched" with the drawn texture.

The collision detection with rotation is right out of the XNA tutorial found here

Lastly, the most complex type of trap is the Flame Turret.

The Flame Turret is using both Beam collision and the particle system for effect.

Beam Collision:

The benefit of using beam collision is if you have something like bullets that travel quickly. If the bullet moves 30 pixels in a single update, is has the chance to pass right through an enemy without causing collision. a Beam object can be used to represent a "line segment" in order to do collision. Of course, you can always Draw the single dot as the bullet, it just uses the Beam object to do the collision.

Here's my Beam struct:

There are two vectors, A and B. There is also a list of coordinates between the beams, which can be calculated with the following method. Note: this may not be an optimal method, comments welcome.

A beam can represent either a bullet moving quickly across the screen, or a burst of flame shooting out of a trap turret.

We can determine if the beam hits a player (or enemy) using the following collision detection method (again, possibly not optimal):

The last piece of the puzzle is a method to get a bounding rectangle around the beam. You *always* need to do bounding rectangle collision before pixel-based collision.

We can check for collision between the player and the beam in the following way:

Finally, we want our Flame Turret to look cool. This can be done using Particle Effects.

The particle engine I've used is heavily modified from the Particle Sample. The details are a topic for another post.

But briefly, we spawn fire particles along the length of the beam:

That's pretty much it for simple traps. With good art and creative level design, you can turn these three features into some pretty dastardly challenges for the player.

Web 2.0 Stuff

2011-03-21T11:51:00.000-07:00

My game - Zombie Bash - is currently in Playtest for XBox Live Indie Games: http://forums.create.msdn.com/forums/t/78185.aspx

Also, I caved and created a twitter account. I figure its really the only way to spread the news about the games I'm building outside the small group of people I know in RL who would care ;)

Follow me at @daydalus!

Our Hero!

2011-03-04T11:45:00.001-08:00

We have the first test sprites of our hero in action!

Optimization!

2011-02-24T12:28:00.000-08:00

I finally got around to purchasing the Creators Club Membership.

The main benefit is I can deploy the games I make to XBox 360, and after Peer Review, have them show up on the XBox Live Indie Games channel.

The set-up and deployment process was pretty painless, but once I loaded up Zombie Bash, I noticed something bad.

The game was incredibly slow! I'd be surprised if I was getting 1 frame per second, especially when the level first started and a bunch of enemies spawned.

The game ran fine on the computer, but the XBox has much weaker hardware. Also, the way XBox environment works under the hood (like disk IO) is different as well.

After doing some research and reading the forums, I came away with some suggestions to try:

1. Run the Xbox Remote Performance Monitor when the game is running on Xbox.
This is provided with the XNA Game Studio under Tools. I was able to get it up and running and look at some of the results in real-time. Unfortunately, the specifics that are profiled were a bit too low level to be of much help. I could tell that the Garbage Collection on the XBox wasn't keeping up with all the objects I was spawning, but why?

2. Run a .NET CLR profiler as you run the game on the computer.
I was able to download the Open Source tool SlimTune and configure it to profile my game. This turned out to be a lot of help. SlimTune actually attached to the CLR and uses Reflection to determine which methods are using the most processing time. This quickly points out the functions and calls that are slowing down the game. (Note: This program can often crash when testing XNA games, however it will still save the profiling to a file).

Which leads us to point number 3 -

3. Look for instances in the code where expensive operations are being done in real-time.
The number one difference between programming games and regular business apps - the same game code runs dozens (hopefully 60+) times a second. If there are any expensive operation in any of the loops, even if they occur once or twice (aka - loading assets), they can slow the entire thing down and lead to a bad gaming experience.

This was the culprit. Every time a new Enemy spawned, I was loading all its sprite textures from disk. This had been fine in the sample code, because the enemies were spawned once when the level was loaded. But Zombie Bash has Enemy Spawners, and dozens of enemies can pop out every few seconds. While the computer can easily handle that kind of disk IO, the XBox was choking.

There were a few other objects (weapons, particles) where the same thing was being done - realtime loading of texture assets into the newly instantiated object.

What I did was create a Loader class that is run once when the game first starts. This goes through and reads all the textures, and also calculates the required bounding boxes and Color arrays needed for collision. It then holds on to them in memory for whatever object needs them down the line (Enemies, Weapons, etc). It remains to be seen if this will lead to issues if the game gets sufficiently large (hundreds of enemies, etc)

Load them (textures and animations) once and save them for later!

A similar approach was taken for the particle system. Each individual particle was calculating its own Sin and Cos curves when initialized in order to follow curved paths. By moving those calculations to the parent class, and simply passing in a pre-initialized Curve object to each individual particle, the particle system was greatly improved!

This is incredibly expensive to do 50 times at once!

To sum up:

-The XBox is much weaker than a computer
-Make sure you don't load or calculate anything expensive during the game loop. Do it before!

For the Love Of...

2011-01-25T07:33:00.000-08:00

Great write-up on the appeal of Rogue-likes: http://www.gearfuse.com/unevenly-distributed-how-i-learned-to-stop-worrying-and-love-the/

Mini-Maps

2011-01-18T16:55:00.000-08:00

For games with complex level design, mini-maps are essential. Especially in games like Super Metroid where the focus of the gameplay is more on backtracking and using your new abilities than pure exploration, the many map is very important tool.

For Platform Hack, I'm planning on two different "mini" maps. One map will be accessible from the pause menu, and will show the entire level, along with special icons for the player, doors, chests, etc. The other map will be a true mini-map, in the upper-right corner of the HUD, showing only a tiny portion of the current level.

Originally I intended to draw a pixel directly on the screen to correspond with each tile in the level, but that turned out to be too slow.

Instead, what we can do it create a Texture2D object on the fly and display it on the screen. If we need to crop (for the small mini-map in the corner), we can calculate coordinates to center on the player, and then specify the sourceRectange parameter of SpriteBatch.Draw.

To build a Texture2D in XNA, we first have to set the size. Then we load in an Color array to specify the individual color of the pixels:

Drawing the full map is pretty straightforward:

spriteBatch.Draw(MapTexture,TopLeftPixel, null, Color.White,0,new Vector2(0,0),this.scale,SpriteEffects.None,0);

If we want to have a cropped version of the mini-map, we can use a function to determine the cropping rectangle, centered on the player position:

Then we can draw with these params in the Draw function:

spriteBatch.Draw(MapTexture, TopLeftPixel, getPlayerCenteredMapRec(this.scale), Color.White, 0, new Vector2(0, 0), this.scale,SpriteEffects.None, 0);

One important feature of mini-maps is the Fog of War. We don't want to reveal the entire map to the player from the beginning. Instead, we want to hide parts of it and reveal more as the player explores. Uncovering new sections of the map is one of the fun parts of games with complex level design.

To implement Fog of War, we store an extra 2D character array that determines which tiles in the map have been revealed. As shown above in the GetColorArray() function, sections that are not yet revealed (char '?') are drawn Gray.

The Fog of War char[,] array starts out completely filled with "unknown" tiles - '?'. Each time we draw, we make a call to update the Fog Of War, determine what tiles the player can see, and switch those tiles over to '.'.

I'm using an open source algorithm called MRPAS to determine what the player can see from his position. Full source available here: http://www.umbrarumregnum.net/downloads/mrpas

The code itself is somewhat complex, but essentially it draws lines out from the player until it hits an obstacle. One nice feature of the algorithm is you can specify to "light walls", which means the wall tiles themselves will be revealed in the Fog Of War, and therefore show up in the minimap.

I was a little worried that the whole thing would run slow, since we're doing a dozen nested loops on nxn mazes every Draw cycle, as well as running the MRPAS algorithm. However, it runs without hiccup. If performance started to become an issue (potentially on massive maps), you could simply keep track of which tiles the player has occupied. If we've already been to this tile, don't run the Fog of War / MRPAS algorithm. Similarly, only recalculate the Color[] for the actual mini-map tile if the player changes tiles.

Next time I'm going to look into everything related to enemies - path finding, line of sight, rudimentary AI, attacking, etc.

Building Mazes

2011-01-10T21:53:00.000-08:00

Happy New Year!

From NetHack to Civilization to Diablo to MineCraft, lots of games have used procedural algorithms to generate semi-randomized levels. For a one man shop like myself, its a way to generate lots of gameplay without a ton of gruntwork.

So how to go you about building mazes?

One site that really helped me out was PCG.Wikidog.com - Procedural Content Generation. It contains algorithms for some of the classic roguelikes, including Angband.

A maze itself can be generated with a pretty simple iterative or recursive algorithm. The psuedocode is as follows:

1. Start out with a 2D array of size nxn.

2. Fill each cell in the grid with character '?' (undefined)

3. Carve out a random cell.
   a. Define function Carve: make the input cell empty '.'
   b. Make the surrounding four cells "maybe" ','.
   c. Add these surrounding cells to a coordinate list called Frontier

4. Iterate or Recurse through the Frontier list until it is empty.
   a. pick a random cell from Frontier. You can use weighted algorithms to pick near the front or back of the list, which lead to different styles of maze (tight and claustrophic vs long empty passages)
   b. Run function Check on the random cell. Define check (Note, this is the most complex part of the algorithm, so you may need to follow along the actual code below)
     i. get the EdgeState of the cell - sum up the cells surroundind the current cell. Empty to the north = 1, south = 2, west = 4, east = 8.
     ii. If we're not up against the side of the map, set the diagonal spaces adjacent to the input space as empty, and return false. Otherwise return true. This basically makes the maze have corners.
   c. If Check was true, Cave out the cell. Otherwise Harden the cell - turn it into a wall '#'
   d. Remove this cell from the Frontier list.

5. Once the Frontier list is emtpy, go through the entire map and change "maybe" cells ',' into empty cells '.' . Turn unknown '?' cells into walls '#'

Full Code:

private char[,] maze; //field
private List frontier;

private int height;
private int width;

private void BuildMaze()
{
 maze = new char[height, width];

 //traverse the maze and fill in unknown blocks
 for (int i = 0; i < height; i++)
 {
  for (int j = 0; j < width; j++)
  {
   maze[i, j] = '?';
  }
 }
 //carve out a random spot
 Carve(r.Next(width-1),r.Next(height-1));

 while (frontier.Count > 0)
 {
  double pos = Math.Pow(r.NextDouble(), Math.Pow(Math.E, branchrate));
  int index = (int)(pos * frontier.Count);
  Coord c = frontier[index];
  if (Check(c.x, c.y))
   Carve(c.x, c.y);
  else
   Harden(c.x, c.y);
  frontier.Remove(c);
    
 }

 for (int i = 0; i < height; i++)
 {
  for (int j = 0; j   {

   if (maze[i, j] == ',')
    maze[i, j] = '.';

   if (maze[i, j] == '?')
    maze[i, j] = '#';
  }
 }

}

 // make the x,y space open, and add the surrounding spaces to the frontier list
private void Carve(int x, int y)
{
 
 maze[y,x] = '.';
 if (y > 0)
 {
  if (maze[y - 1,x ] == '?')
  {
   maze[ y - 1,x] = ',';
   frontier.Add(new Coord(x, y - 1));
  }   
 }
 if (y < height - 1)
 {
  if (maze[y + 1,x] == '?')
  {
   maze[y+ 1,x ] = ',';
   frontier.Add(new Coord(x, y + 1));
  }
 }
 if (x > 0)
 {
  if (maze[y,x - 1] == '?')
  {
   maze[y,x - 1] = ',';
   frontier.Add(new Coord(x - 1, y));
  }
 }
 if (x < width - 1)
 {
  if (maze[y,x + 1] == '?')
  {
   maze[y,x + 1] = ',';
   frontier.Add(new Coord(x + 1, y));
  }
 }
 //shuffle frontier?
 
}

private void Harden(int x, int y)
{
 maze[y,x] = '#';

}

private bool Check(int x, int y)
{
 int edgestate = 0;
 if (y > 0)
 {
  if (maze[y - 1,x ] == '.')
   edgestate += 1;
 }
 if (y < height - 1)
 {
  if (maze[ y + 1,x] == '.')
   edgestate += 2;
 }
 if (x > 0)
 {
  if (maze[y,x - 1] == '.')
   edgestate += 4;
 }
 if (x < width - 1)
 {
  if (maze[y,x + 1] == '.')
   edgestate += 8;
 }

 if (this.noDiagonals)
 {
  if (edgestate == 1)
  {
   if (y < height - 1)
   {
    if (x > 0)
    {
     if (maze[ y + 1,x - 1] == '.')
      return false;
    }
    if (x < width - 1)
    {
     if (maze[y + 1,x + 1 ] == '.')
      return false;
    }

   }
   return true;
  }
  else if (edgestate == 2)
  {
   if (y > 0)
   {
    if (x > 0)
    {
     if (maze[y - 1,x - 1 ] == '.')
      return false;
    }
    if (x < width - 1)
    {
     if (maze[ y - 1,x + 1] == '.')
      return false;
    }
   }
   return true;
  }
  else if (edgestate == 4)
  {
   if (x < width - 1)
   {
    if (y > 0)
    {
     if (maze[y - 1,x + 1 ] == '.')
      return false;
    }
    if (y < height - 1)
    {
     if (maze[ y + 1,x + 1] == '.')
      return false;
    }
   }
   return true;
  }
  else if (edgestate == 8)
  {
   if (x > 0)
   {
    if (y > 0)
    {
     if (maze[y - 1,x - 1 ] == '.')
      return false;
    }
    if (y < height - 1)
    {
     if (maze[y + 1,x - 1 ] == '.')
      return false;
    }
   }
   return true;

  }
  return false;
 }
 else
 {
  if (edgestate == 1 || edgestate == 2 || edgestate == 4 || edgestate == 8)
   return true;
  else
   return false;
 }

}

And that's it.You end up with something like this:

.#.##.#.#.#....#.#.#
....#.#.#.#.##.#....
###.#...#...####.###
#...###...#..#.#.#..
..#.#.##.#####.....#
###.#.#........###..
.#..#.##.#####...###
.#.##..#.....#.####.
....#.##.#######..#.
#.###.#...#...###...

The trouble is that the passageways are only a single tile wide or tall, which would make it very hard for our hero to navigate the game world, since he's two tiles tall! So we can scale the maze, simply by take a tile and copying it to 3 tiles to the east, south and south east. This doubles the size of the board. We can continue to double until the maze feels right - for my game it's a factor of 2, which is 4 times the size.You end up with something like this:

....########....####........####....####........########....####....########....
....########....####........####....####........########....####....########....
....########....####........####....####........########....####....########....
....########....####........####....####........########....####....########....
........................########....########........####....####........####....
........................########....########........####....####........####....
........................########....########........####....####........####....
........................########....########........####....####........####....
####################....................########............########....####....
####################....................########............########....####....
####################....................########............########....####....
####################....................########............########....####....
........................################################....########............
........................################################....########............
........................################################....########............
........................################################....########............
################....########....####....####....####............####....########
################....########....####....####....####............####....########
################....########....####....####....####............####....########
################....########....####....####....####............####....########

The world is still pretty boring, so one thing we can do is generate "rooms". These are large areas of empty space that we can later populate with platforms, elevators, traps and enemies. Generating rooms is pretty easy. Prior to building the map, select a few cells and expand them by random dimensions, changing them to type the "maybe" type ',' We don't want to completely empty them out, so the maze algorithm will still work.So now we have something like this. Better, but still not a game world:

....................########............########....####....####....####....####
########....####................############........................####........
########....####................############........................####........
########....####................############........................####........
########....####................############........................####........
....####....####....####....########............################............####
....####....####....####....########............################............####
....####....####....####....########............################............####
....####....####....####....########............################............####
....####################....################................####....####........
....####################....################................####....####........
....####################....################................####....####........
....####################....################................####....####........
....########............................####....................................
....########............................####....................................
....########............................####....................................
....########............................####....................................
........########....########....############....................................
........########....########....############....................................
........########....########....############....................................
........########....########....############....................................

The next step is to place special characters. These are tiles that will represent platforms, traps, enemies, elevators, items, powerups, etc. Once we have our fully scaled map, we can traverse through and check for certain patterns in which to place our special tile. For example, to place a platform '-', we want to be in a large empty room. So before we place a platform, check to see that the 5 spaces above and below are empty:

........................####............
........................####............
........................####............
........................####.......A....
....####................####....########
....####..............-.####....########
....####................####....########
....####................####....########
############............####............
############........-...####............
############...-........####............
############............####............
......................-.........####....
................................####..-.
................................####....
..A......A...-..................####....
############....-...........########....
############................########....
############................########....
############................########....

Lastly, we want to add some challenge and progression to our maps. We can do this with locked doors and keys. The easiest way is to generate lots of smaller maps, place a random key 'K' inside, enclose the entire thing with a wall and a single locked door as the exit 'D'. Connect all the smaller maps together, and we have a maze that requires some thinking to complete!

############################################################
#..................#............####...#............####...#
#....K.............#.....K......####...#.....K......####...#
#.A........A.......#..A.........####...#..A.........####...#
################...#########...........#########...........#
################.-.#########...........#########...........#
################...#########.-.........#########.-.........#
################...#########...........#########...........#
#..................D............####...D............####...#
#..................#............####...#............####...#
#..................#............####...#............####...#
#.A.............A..#...A........####...#...A........####...#
########....################....################....########
########....################....################....########
########....################.-..################.-..########
########....################....################....########
#..................#...................#...................#
#..................#...................#...................#
#..................#...................#...................#
############################################################

The fun thing about maze generation is that the possibilities are endless. You can instantly generate a new world to explore and jump around in.

Next time I'm going to look into minimaps, and "fog of war". We don't want to be able to spoil the entire maze in one glance!

Platform Physics: Grapple Hook

2010-12-29T08:30:00.000-08:00

One of the best upgrades in Super Metroid is the grapple beam. It gives you the ability the explore much more of the world, and avoid dozens of annoying enemies on the way. It's even useful for shocking to death a boss. So I knew I wanted a swinging grapple hook in Platform Hack.

Not only is the grapple hook fun to use in game, its an interesting challenge to implement in code. There are essentially three main parts:

1. The "rope" needs to shoot out from the player and catch on some surface of the world. This can either be special tiles, or any sort of tile, though in some games this may lead to exploits.
2. Once attached, the player swings in motion similar to a pendulum.
3. When you release, you swing in the direction you were traveling, potentially covering gaps. The player can also re-attach the grapple, and swing horizontally ala Tarzan.

Similar to the jump logic, the first thing I did was create a data structure to hold all the variables we need to keep track of during the grapple swing:

public struct GrappleStruct
{
 public int mode;   //0=shooting, 1=attached
 public SwingCurveStruct swingCurve;
 public Vector2 position; //position of "hook"
 public TimeSpan GrappleTimer;

 public Vector2 launchVector;
 public Vector2 FireVector;
 public float RopeLength;
 public float fireSpeed;
 public Vector2 aimVector;
}
 
public struct SwingCurveStruct
{
 public Curve YCurve;
 public Curve XCurve;
}

SwingCurveStruct is also a data type that comes in handy - it holds two Curve objects. The Curve class allows you to interpolate over a curve given a set of discrete points. So instead of defining complex movement purely by physics formulas, you can numerically determine a few key points along the curve, plug them into a Curve class and then approximate the curve easily. We use a SwingCurveStruct to hold the points in the swing itself.

GrappleTimer tracks how much time the player has been "attached" to the grapple, so we can evaluate the correct position in the swing.

launchVector defines the vector when the player releases from the grapple hook, and lets the player "fling" up in the air.

FireVector is the direction the player is shooting the grapple hook. Right now the "rope" only goes in an upward 45 degrees for ease of use, however this value could be set by the player.

The RopeLength and fireSpeed define how far and how fast the rope itself can shoot out. These values are set when the grapple struct is first created. Longer and faster ropes make it much easier to attach to surfaces, and vice-versa.

The bulk of the logic for the grapple is done in the DoGrapple function:

public bool DoGrapple(bool artifactPushed, GameTime gameTime, ref Vector2 position, ref Vector2 Force1Vector, ref Vector2 velocity, Level level, SpriteEffects flip)
{
 float elapsed = (float)gameTime.ElapsedGameTime.TotalSeconds;
 bool isSwinging = false;

 if (artifactPushed)
 {
  if (playerGrappleStruct.mode == 0)
  {
   if (playerGrappleStruct.FireVector.X == 0 && playerGrappleStruct.FireVector.Y == 0)
   {
    if (playerGrappleStruct.aimVector.X == 0 && playerGrappleStruct.aimVector.Y == 0)
    {

     if (flip == SpriteEffects.FlipHorizontally)
     {
      playerGrappleStruct.FireVector = new Vector2(1f, -1f);
     }
     else
     {
      playerGrappleStruct.FireVector = new Vector2(-1f, -1f);
     }
    }
    else
    {
     playerGrappleStruct.FireVector = new Vector2(playerGrappleStruct.aimVector.X, playerGrappleStruct.aimVector.Y);
    }
   }
   playerGrappleStruct.position += (playerGrappleStruct.FireVector * elapsed * playerGrappleStruct.fireSpeed) + (velocity * elapsed);
   if (Helper.getDistance(position, playerGrappleStruct.position) > playerGrappleStruct.RopeLength)
   {
    playerGrappleStruct.position = position + new Vector2(0, -25);
   }
   GrappleCollision(level,position,velocity);

   isSwinging = false;
  }
  if (playerGrappleStruct.mode == 1)
  {
   playerGrappleStruct.GrappleTimer += gameTime.ElapsedGameTime;
   float maxTime = playerGrappleStruct.swingCurve.XCurve.Keys[playerGrappleStruct.swingCurve.XCurve.Keys.Count - 1].Position;
   float newPositionX = playerGrappleStruct.swingCurve.XCurve.Evaluate((float)playerGrappleStruct.GrappleTimer.TotalSeconds % maxTime);
   float newPositionY = playerGrappleStruct.swingCurve.YCurve.Evaluate((float)playerGrappleStruct.GrappleTimer.TotalSeconds % maxTime);
   playerGrappleStruct.launchVector = setSwingVelocity(new Vector2(newPositionX, newPositionY), position, (float)gameTime.ElapsedGameTime.TotalSeconds);

   playerGrappleStruct.LaunchTimer = TimeSpan.FromSeconds(1);
   playerGrappleStruct.launchCurve = setLaunchCurveStruct(playerGrappleStruct.launchVector);
   position.X = newPositionX;
   position.Y = newPositionY;
   isSwinging = true;
  }
 }
 else
 {
  if (playerGrappleStruct.mode == 1)
  {
   playerGrappleStruct.mode = 0;
   Force1Vector = playerGrappleStruct.launchVector;
  }

  //reset the rope;
  playerGrappleStruct.position = position + new Vector2(0, -25);
  playerGrappleStruct.FireVector = new Vector2(0f, 0f);

  isSwinging = false;
 }
 return isSwinging;
}

The function has three main sections, corresponding to the three parts listed above.

1. If we're shooting the grapple hook (artifactPressed) and in mode 0, then increment the location of the "hook" and check if we've collided with any surfaces.

We use the GrappleCollide function to check:

private void GrappleCollision(Level level, Vector2 position, Vector2 velocity)
{
 Vector2 temp;

 if (Collision.getLineCollision(position + new Vector2(0, -25), playerGrappleStruct.position, level, out temp))
 {
  if ((position.Y - 25) > temp.Y && Math.Abs(position.X - temp.X) > 50) //make sure we only grappling to points above us
  {
   playerGrappleStruct.position = temp;
   playerGrappleStruct.mode = 1;
   playerGrappleStruct.swingCurve = setGrappleSwingCurve(playerGrappleStruct.position, position + new Vector2(0, -25), velocity);
   playerGrappleStruct.GrappleTimer = TimeSpan.FromSeconds(0f);
  }
 }
}

getLineCollision essentially gets a list of all tiles that are overlapped by a line connecting the player to the hook. We then traverse this list, moving outward from the player, and if we hit an Impassable or Platform tile, we return true, we're connected.

Once we're connected, we change to mode 1 and we have to calculate the swing curve:

 /*
 * given the initial force vector (x, y), and the angle of attachment, calculate the swing curve of the grapple, using pendulum physics
 * pendulum forumula
 *
 * O'' = -g/R sin O
 * angular acceleration = - gravity / length of rope * sin angle
 * angle (O=vertical)
 * */
private  SwingCurveStruct setGrappleSwingCurve(Vector2 origin, Vector2 playerPosition, Vector2 initVelocity)
{
 //length of rope
 float length = (float)Math.Sqrt(Math.Pow((origin.X - playerPosition.X), 2) + Math.Pow((origin.Y - playerPosition.Y), 2));

 Vector2 slope = (playerPosition - origin);
 slope.Normalize();
 slope = new Vector2(slope.X, slope.Y * -1);

 //get start angle
 float angleStart = (float)(Math.Atan2((double)slope.Y, (double)slope.X));

 float initVelocityRadians = getInitVelocity(length, origin, playerPosition, initVelocity);

 float time = 0f;
 float angleAcc = 0f;
 float angleVel = initVelocityRadians;
 float curAngle = angleStart;

 SwingCurveStruct retval = new SwingCurveStruct();
 retval.XCurve = new Curve();
 retval.YCurve = new Curve();
 retval = addCurvePosition(retval, time, origin, length, curAngle);

 //iterate through and set curve keys
 for (float f = time; f < 20f; f += .1f)
 {
  angleAcc = -(GravityAcceleration / length) * (float)Math.Sin(curAngle + (float)Math.PI / 2);
  angleVel += angleAcc * .1f;
  curAngle += angleVel * .1f;
  retval = addCurvePosition(retval, f, origin, length, curAngle);
 }

 return retval;
}

This function uses the formula for a pendulum to create Curve objects that the player will move on while attached. Here's a great site that walked me through pendulum physics: http://www.myphysicslab.com/pendulum1.html
First, we have to determine the initial angle the player is attached:

float angleStart = (float)(Math.Atan2((double)slope.Y, (double)slope.X));

Next, we set an initial velocity. This basically gives the player a little more momentum in the swing if they are moving when they attach, and makes "Tarzan" swings a little more powerful.

 private float getInitVelocity(float length, Vector2 origin, Vector2 playerPosition, Vector2 initVelocity)
{
 //pythagorean?
 float velocityDist = (float)Math.Sqrt((initVelocity.X * initVelocity.X) + (initVelocity.Y * initVelocity.Y));
 float cosx = Math.Abs((length * length + length * length - velocityDist * velocityDist) / (2 * length * length));
 float initVelocityRadians = (float)Math.Acos(cosx);
 if (float.IsNaN(initVelocityRadians))
  initVelocityRadians = 0f;

 //unit circle goes counter clockwise, so if we are swinging the otherway, then multiple by -1
 if (initVelocity.X < 0)
  initVelocityRadians *= -1;

 return initVelocityRadians;
}

Last, we just need to iterate the points of a pendulum into the Curve structs, The pendulum takes the following forumla:

angleAcc = -(GravityAcceleration / length) * (float)Math.Sin(curAngle + (float)Math.PI / 2);

Once we have the angular acceleration, we can determine the angular velocity, and thus the current position in radians. From there, we can easily calculate the current position along the circumference of a circle (the "hook" being the origin).

//gets the x,y vector at the end of the pendulum, given origin, length and radians
private Vector2 getCurvePosition(Vector2 origin, float length, float radians)
{

 return new Vector2((float)(origin.X + length * Math.Cos(radians)), (float)(origin.Y + length * (float)Math.Sin(radians) * -1));
}

Note: the swing algorithm breaks down if the player attaches to a surface at less than the horizontal plane. This is because the swing follows the path of a pendulum, and if the angle is greater than the horizontal, the rope will be "stiff", and the player could even use it as a sort of stilt. If you want full elastic grapple hooks, some different physics logic is needed
2. Once we are attached, we just need to determine our current position on the swing curve.

float newPositionX = playerGrappleStruct.swingCurve.XCurve.Evaluate((float)playerGrappleStruct.GrappleTimer.TotalSeconds % maxTime);
float newPositionY = playerGrappleStruct.swingCurve.YCurve.Evaluate((float)playerGrappleStruct.GrappleTimer.TotalSeconds % maxTime);

Note: We're also doing a special collision check at this point to make sure the player can't swing through walls. Because we aren't adjusting the player velocity, and instead directly updating the player position, there is the chance that the player could move so fast they could warp through walls (given a long enough rope, or a strong enough GravityAcceleration). So lots of tweaking/testing is needed to find the right balance.
3. Once the player lets go (artifactPushed == false), we need to apply the launch velocity. We actually set the launch velocity while we are connected with the following function:

private Vector2 setSwingVelocity(Vector2 position1, Vector2 position2, float timeDiff)
{
 return (position1 - position2) * (float)(1.0 / timeDiff) * 20;
}

We find the difference in position during the swing, then multiply by 20. The 20 is an arbitrary value, and can be adjusted to set how much the player "flings" after they release the grapple hook. This is another case where if you use realistic physics, the gameplay isn't as fun as using exaggerated calculations.

Last, we apply gravity as normal. The launch vector is saved in Force1Vector, and is applied along with the other vectors.

So that's the basic grapple hook, probably the most difficult "movement tool" being implement in Platform Hack. Next time, it's onto something completely different - procedural maze generation!

Platform Physics: Jumping

2010-12-28T06:48:00.000-08:00

Ever since Super Mario Brothers (and perhaps Donkey Kong before that), the jump has been iconic of Platform games. At first glance, it seems like it would be pretty easy to implement a jump using classic physics - apply an upward force to the player and then have gravity act as a constant downward acceleration. This can be done, however, it leads to pretty punishing gameplay.

Platform games don't follow the laws of physics. Here's a few reasons.

1. We want the player to be able to move horizontally in the air. This lets the player tweak movement and land much more difficult jumps. This breaks the 1st law of Thermodynamics.
2. We want the jump (and the pull of gravity) to be limited by a max velocity. There are a few reasons for this. One, it makes the gameplay a bit more manageable to not be flying all over the place. Second, the algorithms of collision detection start to break down if the player (or any other object) moves faster than the height of a tile in a single update of the game loop.
3. We want the jump to have a constant upward motion, instead of a large initial velocity immediately starting to taper off by gravity. As long as a player presses the jump key (within limits), we want the player to jump upwards.

So let's look at the pieces needed to implement a jump:

For Platform Hack, I wanted jumps to be pretty versatile. Which means there will be double (and even triple) jumps, wall jumps and upgrades to jump power. So I needed a data type that could store and abstract away the details of the jump:

  
    public struct JumpStruct
    {
        public int curNumJump;
        public int totalNumJump;

        public bool isJumping;
        public bool wasJumping;

        public float jumpTime;
        public TimeSpan jumpTimer;
    }

In the struct we have curNumJump and totalNumJump. This is used to keep track of double and triple jumps.

isJumping is a boolean thats mapped to the player jump key. wasJumping is a boolean that specifies whether the player was pressing jump *the previous update*. This is important for making sure the player presses the jump key for each jump instead of just holding it down.

jumpTime is the total amount of time the player can jump. Increasing this number allows the player to press down the jump key longer, and have larger jumps. jumpTimer is the actual timer that counts down as soon as the jump starts.

During each game loop, we must run the update on the player physics:

   
GravityVector.Y = MathHelper.Clamp(velocity.Y + GravityAcceleration * elapsed, -MaxFallSpeed, MaxFallSpeed);
PlayerVector.Y = DoJump(PlayerVector.Y, gameTime);
PlayerVector.X += MathHelper.Clamp(movement * MoveAcceleration * elapsed, -MaxMoveSpeed, MaxMoveSpeed);
velocity = GravityVector + PlayerVector + Force1Vector + Force2Vector;
velocity.X = MathHelper.Clamp(velocity.X, -MaxMoveSpeed, MaxMoveSpeed);
velocity.Y = MathHelper.Clamp(velocity.Y, -MaxMoveSpeed, MaxMoveSpeed);
Position += velocity * elapsed;
Position = new Vector2((float)Math.Round(Position.X), (float)Math.Round(Position.Y));

One thing I've done is kept the various velocities (GravityVector, PlayerVector) seperate, and then combined them before applying to the player movement. However, when I update gravity, it draws from the full velocity. This little tweak helps smooth out the upward curve of the player jump, or if they fall off a ledge. Gravity is also "clamped" at MaxFallSpeed, which acts as a sort of terminal velocity. Clamp is important for reason #2 above.

The Player.X velocity (horizontal movement) is updated by player control - the movement variable is set with the left and right buttons. This allows the player to move horizontally even if they are in the air.

The Player.X veloctiy is set with the DoJump function:

  
private float DoJump(float VelocityY, GameTime gametime)
{
 VelocityY = 0;
 if (JumpCheck(gametime, IsOnGround))
 {
  if ((IsOnGround) || playerJumpStruct.jumpTimer > TimeSpan.Zero)
  {
   if (playerJumpStruct.jumpTimer.TotalSeconds == playerJumpStruct.jumpTime)
   {
    level.thisPlatformerGame.gameAudio.playSound("PlayerJump");
   }
  }

  // if we are in the ascent of the jump
  if (TimeSpan.Zero < playerJumpStruct.jumpTimer && playerJumpStruct.jumpTimer <= TimeSpan.FromSeconds(playerJumpStruct.jumpTime))
  {

   GravityVector.Y = 0;
   // fully override the vertical velocity with a power curve that gives players more control over the top of the jump
   VelocityY = JumpLaunchVelocity * (1.0f - (float)Math.Pow((playerJumpStruct.jumpTime-playerJumpStruct.jumpTimer.TotalSeconds) / playerJumpStruct.jumpTime, JumpControlPower));
  }
 }
 return VelocityY;
}

Essentially, this function first checks if we can jump. JumpCheck returns true if the player is on the ground, or the curNumJumps is less than totalNumJumps.

If we're on the ground, or the jump timer is less than the total jump time, then set the Player.Y velocity. We're using a power function to give the player a sort of exponential curve to upward velocity, starting with the most power and decreasing as we reach the top. We also are setting Gravity to 0 to give the jump a bit more "floatiness".

Once the DoJump returns, we have to calculate the player's new position. Velocity (and acceleration values - JumpAcceleration, GravityAcceleration) is stored in terms of seconds (500 pixels / second). Each update function only takes a fraction of a second, so we need to multiple the velocity by elapsed, which will give the appropriate amount to move the player.

Lastly, we round the player position to the nearest round number, so the sprite is positioned cleanly on the pixels. This is essential for player collision - otherwise the player can get stuck in floors and walls due to a fraction of a pixel overlapping.

The *feel* of the jump is essential to how the game plays. Stronger gravity and less precision of player movement can make the game much more difficult. Conversely, if gravity is too weak and the player is too floaty, the game can feel slow, frustrating or boring. Tweaking the GravityAcceleration, JumpAcceleration and Clamp values can drastically change the feel of the jump.

Next: I'll go into the details of the infamous grappling hook!

Note on Code samples: I'm more interested exploring algorithms and general concepts on this blog rather than complete code samples. The codebase I'm working with is a bit messy to upload for each example. If you want to follow along, start with the Platformer Starter Kit for XNA and go from there.

Where I'm At Now

2010-12-23T09:45:00.000-08:00

Right now I have a pretty good idea of what I want Platform Hack to be in regards to gameplay. The original inspiration was actually Super Metroid, one of the best platformers of all time.

Super Metroid has all the standard action-platformer elements of jumping and attacking enemies, but what really set the game apart were the RPG elements, weapons and boss fights. As you make your way through the maze-world, you unlock upgrades to health and weapons. There are also tools you acquire that allow you to traverse the world more easily, including the the grapple beam and the space jump. The boss fights were also extremely polished, with animations to match, finding that great balance between challenge and cakewalk.

I'd like Platform Hack to borrow a lot of those elements, including the "movement" upgrades like the double jump and the grapple hook. Because the world in Platform Hack will be procedurally generated, there's the possibility of having super high vertical walls and cliffs, which could potentially post a problem for the standard jump. Of course, I'll have to tweak those maze-generation algorithms to limit the cliffs on the easier levels. But one of the goals of the game will be to acquire these "movement tools" in addition to more powerful weapons.

As far as development, I see the project in three stages:

1. Core Engine Development. This includes algorithms for collision detection, physics, player control, HUD, enemy movement and attacks, and boss scripting.

2. Game World Development. This is the world generation using procedural maze algorithms, different "features" like elevators, springs, doors, traps, as well as the more specific enemy and boss instances.

3. Asset Creation. This is where the game finally gets it's look - includes drawing and importing all the player, enemy and boss sprites, particle effects, tile and background images, HUD font and icons, sounds and music. Hopefully I have some help on board for this stage. But it's still a ways off.

Right now I'm still deep in stage 1, trying to work out the tweaks in collision detection for various movement tools, including the Grapple Hook and Jump Jets. But that's for another post -

Fire it up

2010-12-23T08:16:00.001-08:00

So I've started this blog to track progress and explore ideas for the game I'm building: Platform Hack.

Platform Hack is a combination platform-jumper / rogue-like (NetHack)

The game is being built in XNA 4.0 using a heavily modified Platformer starter kit. I'll also be using some open source maze generation algorithms that come from Angband and other rougelikes.

The "engine" was already used for a simple game I released called Zombie Bash, which was basically an experiment to figure out the collision detection and intricacies of drawing / displaying assets in XNA.

There's still a lot to go, and the next few blogs will go over the goals I have for the game, as well as some challenges of building it -