We Have A Game

We now how a playable game. Gameplay consists of getting from Edward's classroom to the school exit by jumping on platforms and battling enemies. This week we worked on bugs so that the game could be more polished. We managed to eliminate all of the bugs that we created the week prior from retrofitting our code to be more object-oriented. Our game now consists of clearly defined states and substates. For example, at any given time the game is in a state based on what level it is in (or if it is at the menu screen) and every enemy and player has a substate which specifies what attack they are performing.

There are 9 substates:

• Still
• Jump
• Run
• StillAttack
• JumpAttack
• RunAttack
• StillDamaged
• JumpDamaged
• RunDamaged

When a player or enemy is in a "Damaged" state, they take damage and flash for a half of a second. If the player takes too much damage, it exits to the menu screen. If an enemy takes too much damage from Edward's slap (which is his one Attack state at the moment) they fall to the ground then disappear.

The level editor can be accessed at:
http://www.tstechonline.com/edward/tiles/EdwardLevelEditor.html

Entire levels can be designed, from placing the background tiles to placing the platforms! You can also load levels to edit ones that you have already made. Still left undone: placing state locations of enemies and players and triggers.

Level One

Here is an image that gives you an idea of what level one looks like. The black spots are replaced by platforms in the actual game. This image doesn't show enemies or floating platforms.

Spring Break WOOHOO!

Progress this week:

This week we completed level 1, the high school. There are two types of enemies, death pits and wolfmen. The wolfmen have random movement (2D) and death pits are those ever so dangerous holes in the floor of the high school. The high school appropriately has techno music playing over its audio system the whole time.

We spent a large amount of time working on game play mechanics. Although we did not add a lot of functionality this week, we completely reworked our framework so that adding more functionality is easy and modular. We did add in our first attack, a slap, which will kill a wolfman within 50 pixels of Ed's hand. The slap comes with a nice sound effect. We also added an improved damage animation that can be done on the ground, while running, and while jumping. The hp indicator is now on a top layer and typed in red so that the player can easily view his hp.

Overall Progress:

So to summarize, we now have a completed 1st level of our game. There are some bugs we need to work out, but all of the framework is there and the game is definitely playable and enjoyable now. We are getting closer and closer to the stage when all we do is churn out more content.

Looking Forward:

Our immediate goal is to fix the parts of the 1st level that aren't perfect because we believe the quality of the game is more important than the quantity of gameplay. However, after finishing that we aim to add more attacks for Edward and make more enemies who are also more sophisticated. Due to our improved Character framework, after working out bugs this process should be relatively straightforward. Then we will look towards the artistic side of our game by adding cut scenes and voice overs.

The side-scroller appears!

This week we developed the framework for level creation and utilization. We have an editor which creates a map of which tiles to use for the background. The objects are temporarily coded with arbitrary coordinates. The game is nearing the playable and enjoyable stage.

We added substantial artwork this week including all the tiles, an animation cycle for the enemy, and a shotty damage taking animation for Edward.

In terms of gameplay mechanics, we added the concept of health points and damage. You know can lose the game by getting hit by the enemy a few times. The enemy also 'chases' you now (moves and jumps randomly).

It's Looking Like a Platformer!

This week we implemented jumping and basic platform collisions. Edward can now hop around the level gleefully while his werewolf enemies bounce around the screen randomly. The platform collision scheme we used for this assignment is a little too simple for our plans so it will likely be replaced by an all-encompassing boundary detection system. This will allow us to make much more dynamic levels than rectangular grids. We still plan to have sloping ground much like in Braid.

Programming the jump sequence has given us an idea for how we will have to use states to control all of Edward's abilities. It has also given us an idea for how miserable collision detection can be. Our implementation at the moment is pretty good, but there exists some flaws that a cunning player could abuse. In typical gameplay, however, these problems should never come up.

Our next assignment will likely be to implement the first level with or without a level editor. This is another big leap for us, because it will then allow Edward to move outside the bounds of the screen.