Probe is a 3d game engine with emphasis on content-oriented game design. It provides support for many important core features such as physics simulation, sounds, models, textures, and shaders. While primarily designed to support top-down style gameplay, it could easily be augmented to support any other kind of 3d game. It also comes with its own content editing tool, the Probe Editing Environment, which allows creation and editing of nearly any aspect of the game as well as importing raw content like 3d models and sprite sheets.

This is a demonstration of a "bullet hell"/"shoot-em-up"-style game created in the engine. In this game, the objective is to make it to the end of the level without dying while dodging dense patterns of bullets launched by enemies. You have weapons of your own as well as armor and a recharging shield to protect you. You can also engage "dodge mode", which will shrink your hitbox and make your movement more precise at the expense of having your shield to absorb damage. The game is over when you have either cleared the level or you die.

The Lambda Engine is a full game engine that supports large dynamic worlds. It is completely proprietary and is optimized using state-of-the-art techniques such as spatial curves, software occlusion culling, hardware intrinsics, and memory management. Some of the features include:

• fully dynamic physically-correct lighting
• physically correct per-pixel materials
• unlimited number of shadow casting dynamic lights
• per-joint,per-object, and camera motion blur
• deferred rendering architecture
• dynamic real-time specular and diffuse reflections
• post processing and rendering chains
• integrated Nvidia PhysX 3.1 physics
• support for FBX, 3ds, Obj, X, and other mesh formats
• real-time World editor with GUI

Thanks to Jordan Gabrielle for 3d modelling and art.

ShootOut Reloaded is a 3D, first person shooter, where the player's goal is to run through various shooting ranges trying to earn a best score or best time. Each level contains shooting targets scattered across the environment, with points awarded to the player when targets are shot based on the criteria such as: target's distance from the player, where the target was shot (e.g. Bullseyes and Headshots), and the number of targets which were hit.

The game includes six unlockable weapons to use with weapon challenges for each gun, which includes Time Trials and Score challenges where players must get above a certain score in order to complete the level. Each level includes a hidden "Golden Grenade" secret item for players to find and collect. The game also includes Achievements (called Metals) for players to unlock, which are simple "meta game" like tasks to complete which include: Shoot X number of Targets, Get a Total Score of X, as well as more challenging tasks such as completing a certain level getting only Headshots.

All of the 3D graphics code is written from scratch, utilizing only lower level system calls provided by the XNA framework. All rendering utilizes custom shaders written in HLSL, which includes features such as: normal mapping, shadow mapping, reflective and refractive water, fog, and volumetric light scattering as a post process.

Teddy Bear Defense is a single-player first person shooter based off of the Commander mode in Battlefield 2. You lead a team of soldiers against an enemy team, attempting to capture and control several points across the map. Controlling more points than the enemy team results in them losing tickets - each team starts with 100 tickets, and the first team to run out loses.

You also have access to a screen that lets you lead your team to victory. Providing you with a large map of the battlefield, it lets you select teammates and tell them where to go. This RTS-style control over your team adds an extra dynamic to the traditional FPS game play.

The enemy soldiers will independently attempt to capture points that you control, and will target you or your teammates if you get too close. Your teammates however, while capable of defending themselves, rely on you for their orders. So a combination of shooting skills and strategic control of the map is necessary to win in TBD.

The engine for TBD was built from the ground up, using OpenGL 4.0 and FreeGlut. The graphics engine supports the .obj and .FBX file formats, and can render textured models with skinned animations. The physics is also from scratch, including the collision/intersection routines, and a terrain traversal algorithm.

Survive is a top-down shooter where the hero battles against swarms of spiders. At his disposal are 13 different weapons and special abilities. The goal of the game is to destroy the spider's lair so that they stop coming after you. However, destroying the lair will spawn a boss which will attack you mercilessly.

The game is written completely in C++, OpenGL and GLUT. Levels and artwork were drawn by hand in gimp using the color cyan as a transparency color (and as wall for the levels). Textures are loaded dynamically so that when a texture is needed, it is referenced by a filename. If that filename is not loaded, it is then loaded. From the start, the code was written to be adaptable. For example all of the normal weapons use the same class with different parameters.

The weapon code is highly versatile and adding a large number of weapons would be possible with very little code. There are three types of weapons, normal weapons (shotgun, pistol, etc...), grenades (land mines, Molotovs etc,..) and special weapons (shield, turret, etc...). The special weapons require focus which is only gained when killing spiders.

Spiders both adhere to a flocking mechanic, but also are influenced by pathing to the hero. This is accomplished by setting up a grid which tracks all spiders within. Each cell in the grid contains a list of visible nearby cells as well as pathing information. Each spider only checks nearby cells for influences (allowing for thousands of spiders to exist). Similar to the weapons, spiders also can spawn other spiders, both periodically and on death. This makes the bosses much more difficult as they can shoot out projectiles and even other spiders. Levels become increasingly difficult with more spiders spawning and harder bosses. However, the hero gets more and more weapons to make his job easier.

Earn Your Wings is a flying game in which the goal is to learn how to fly. Programmed in Python and using the Panda3D game engine, the game simulates training with challenge levels where the player must fly through rings to test their proficiency. For easy navigation, the game has a HUD (heads up display) element that will always guide the player to the next ring to be approached. In addition to flying through the rings, the player may try to beat their previous time with the displayed timer and, of course, avoid the ground. There is no penalty for taking a long time, everyone is a beginner at some point, but hitting the ground will result in a game over.

The ground was generated using the free version of L3DT (Large 3D Terrain Generator). This software generates a realistic looking terrain model which undergoes several levels of transformation, such as erosion. It additionally includes a high quality texture which puts plant life and water in natural places in the above mentioned model.Unfortunately, as of this release, the texture is left low-resolution to maintain an adequate frame rate.

The game currently has a few levels to play but many ways to play them. First, there are six different planes that can be chosen from at the main menu, all of which were designed, rendered, and textured using Blender modeling software. In addition, the game supports multiple input devices including keyboard, joysticks, and Xbox 360 controllers. All controls are customizable with configuration files.

Get Alice out of Wonderland. As Alice walks, she may encounter rabbits and cats and play games to get the ability to walk through the trees for 5 seconds.

• ColorGame. Encounter with rabbit, and remember the sequence of colors flash as the rabbit jumps on the stumps. Choose the right sequence by clicking on the stumbs afterwards.
• CupGame. Encounter with cat, and guess which cup has the cat. Choose with the arrow, and press 'x' on the right one.

Alice could also find the red mushroom. Go close to the mushroom and press 'x', and she'll grow big for couple of seconds. Then, she gets to see the top view of the wonderland.

Vertical Flip is a puzzle platformer where you play as a lovely bear exploring a forest while eating as many delicious desserts as you can find. Unfortunately, the bear mistakenly eats a mysterious round device, which causes the entire world to flip upside down whenever the bear jumps. The bear must then make it through a variety of levels while the world flips around her.

The most interesting feature is that the world flips upside down whenever the bear jumps. This was implemented by storing the levels as a series of tiles (each level is 64 x 36 tiles). Every time the bear jumps these tiles move to the opposite end of the screen vertically. Additionally, any objects on the screen, such as the desserts must reorient as well. The tiles are also use for hit detection. If the bear's hitbox coincides with a tile's hitbox, the game determines if the bear should land, fall, die, etc. The way the tiles for the levels were created is in Microsoft Excel. I made a function for importing the data from the excel file and representing it internally in the game as tiles. Some other features include several texture mappings (in High Definition 1080p), animations of the bear, multiple paths through certain levels, and some features within the title screen. There is also a pause functionality, fullscreen mode, checkpoints, backtracking, and collectibles.

Blockdown is a block-sliding based puzzle game, similar to the popular game Bejewelled. In the traditional Bejewelled (and its many clones), players swap adjacent blocks (which are represented as jewels and gems in Bejewelled) either vertically or horizontally in an attempt to form a 3+ line of matching gems. By doing so, that line of gems is removed from play, the gems above fall down into the empty spaces, new gems fill in from the top, and the user gains points. The major difference between our game is that instead of swapping 2 gems with each other, the player will slide across an entire row or column of blocks (with blocks that slide off the edge resurfacing on the other side of said row/column). In the same way, forming a 3+ line will remove blocks from play and cause new blocks to fill in from the outside edges of the play area.

The metric for score in this game is instead time, so the longer the user can survive, the higher their "score." Every few seconds, random blocks will lock in place, preventing that row and column from sliding. To remove this lock, the user will need to shift into place matching colors to form a 3+ combo that includes this locked block. This will remove the lock, allowing the player to slide that row and column again. As the time increases, the frequency of locks appearing will increase, until ultimately the player cannot keep up with the pace and eventually loses. The player will then have the option to submit this score to an online leaderboard to compare his/her performance against others.

Interesting Features: All of the art and music for our game was made by our team. We use a "flood-fill" algorithm for finding matches that includes not only the 3+ line of blocks, but also any attached adjacent blocks that have the same color. Our game runs on desktop and Android devices through the use of LibGDX's multi-platform abstraction.

A puzzle platformer in 3D with minimalistic graphics, Tri(t)angular is a game about discovery and exploration. Equipped with the ability to "entangle" two objects, the protagonist must find a way through the monolithic buildings that stand between them and the unknown, while uncovering the secrets of those that came before.

This game was programmed using C# and Microsoft's XNA game engine, integrating the Jitter physics engine. All content was generated with Blender, Photoshop, and/or Illustrator.

Interesting implementation features include a (naive) implementation of Variance Shadow Mapping, along with a prelighting scheme to avoid drawing the scene multiple times for every light. The entanglement mechanic is an implementation of a constraint in the Jitter physics engine propagating the animation of one object to the motion of the other, with selection using the ray casting functionality of Jitter.

Labyrinth is a horror game, the player is thrown into a dark maze with only a lantern to light their way. They navigate in first person view through the maze, stumbling upon doors with notes attached left by previous adventurers trying to get out. Behind these doors a monster may lurk, if the player opens it and he appears and catches them, then they are disoriented and transported to a different location in the maze. If he catches the player 10 times... they never make it out.

The game was developed using GLUT, C++, GLSL, and OpenGL 4.0. We used Eric Krokos's video game engine that he re-wrote for the purposes of the class from scratch. The game used instanced models along with all the animation and lighting done in shaders. We used OpenAL for the audio and Bullet Physics for the physics engine components. The light in the game represents the player's lantern; it is implemented as a point light in the system. The walls of the maze use Bump Mapping to give the brick texture and a more 3D feel rather than just regular normal mapping. The maze itself is generated procedurally and is completely customizable giving a different experience each time the game is played. The monster model was downloaded from TurboSquid and the audio is from various license free audio websites.

This proof-of-concept application simulates a crowd of people milling around in an enclosed area. It uses velocity obstacles to avoid collisions and footstep planning and inverse dynamics to simulate and animate the walk cycle. A visual representation of the velocity obstacles can be toggled on and off, and the timescale used for the amount of lookahead can be adjusted to test different collision detection.

The simulation uses an implementation of Velocity Obstacles to help each agent decide how to adjust its velocity to avoid collisions with other agents. The Velocity Obstacles are stored as a position and radius for a circle, two vectors for the tangents to the circle, and a vector for the velocity to shift the obstacle. Collisions with a Velocity Obstacle are found by checking the circle first; then finding the distance from a point to the bisection of the Velocity Obstacle, if it is greater than the radius of the circle and less than distance to the tangents, then it is considered colliding. If there is a collision, the closest tangent becomes a candidate for the target velocity. Then, the best candidate that doesn't collide with any other obstacle is chosen. Some work still needs to be done; by drawing the goal velocity, target velocity, and velocity obstacles, it can be seen that the target velocity can change even though the goal velocity is not colliding with any obstacles.

In order to realistically simulate the individual agents motion, we implemented footstep planning and used inverse dynamics to draw the figure in the correct position. In order to minimize cases of the legs passing through each other, the entire path of each foot had to be planned out before and during each step, and constraints had to be placed on the leg movement during strafing and turning. Although more work could definitely be done to further polish this animation, what results is a walk cycle in which each foot placed down on a spot on the ground and doesn't move until it lifts up again for the next step.

Dig! is a game thought up by Jeffrey Ackerman and Rachel Crawford. It works in a manner similar to some mini-games present in several games (such as some Zelda games and Harvest Moon games) where your goal as Doug, the miner, is to dig up items present in the ground while avoiding dangerous monsters. The game takes place entirely in a grid-based mine environment and all grid cells have a random chance to contain an item, a rock, nothing, or a monster.

Monsters move in accordance to Doug's movements; each time Doug takes a step, turns, or digs, every monster on the floor will also take a step towards Doug or attack him if they are close enough. When attacked, Doug takes damage to his stamina, which results in the death of the character (and a game over) when this reaches 0. Stamina is replenished by a small amount when progressing through the game.

There are several items in the game able to be dug up, such as iron ore, gold ore, diamond, etc., and each item has a monetary value associated with it (which is added to your score). There is also a key hidden on each floor to be used to enter the next level of the mine, which may be hidden under rock obstacles. Rocks take multiple hits of the shovel to break up (which, in turn, decreases your stamina). The rocks are somewhat beneficial, though, as they provide obstacles for the monsters to navigate around, which provides you time to dig up more treasure.

It was written in C++ and OpenGL, with all of the art made by Rachel using MS Paint.

This is a tower defense variant called Virus Towers. The objective of the game is to survive as long as possible, by destroying viruses that hackers are sending your way.

Features:

• Unlike normal tower defense you lives and money are just one unit.
• Viruses have a health vector [RED, GREEN, BLUE], as reflected by their color.
• You need a red tower to do red damage and lower the red health. Same for green and blue.
• There are 4 different tower types:
  • bomb : deals AOE damage
  • arrow : attacks a single virus at a time
  • slow : slows down viruses
  • stun : temporarily stuns the viruses
• Press "n" to generate a new virus path, and start a new game mode. In this mode new paths are generated on every square level (1,4,9,...) You gain money as the level progresses.

Essentially a clone of the 2005 Xbox Live Arcade Game, Geometry Wars: Retro Evolved, the object of the game is to survive for as long as possible against an ever-increasing number of enemies in a rectangular play area while earning as high of a score as possible. The player controls a triangle shaped ship which can be moved around in any direction using the WASD keys, and can aim and shoot in any direction using the mouse. The player can also use a "bomb" feature by pressing the SPACE bar to clear the screen of enemies. The player can press 'P' to pause the game and 'Q' or 'ESC' to exit.

Other Design Notes: Coded using C++, OpenGL, GLUT, and Visual Studio 2012 to run on Windows PCs. The world and entities use primitive OpenGL and GLUT objects. The game detects collisions between the player, enemies, and bullets, and uses a particle system to represent enemies and bullets "exploding" upon a collision. The game also uses similar techniques from the particle system to show the score earned and/or the multiplier earned on screen at the spot where an enemy was killed. Enemy AI is basic and consists of moving towards the player's position. Enemies also exhibit some clustering/collision prevention (or rather some aspects of flocking behavior). It does allow for some overlapping of enemy entities because no overlap looked unnatural. The game has 1 main enemy spawning mode (random) and 3 special spawning modes (4 corners at once, 4 corners continuous, surrounding circle at once). Enemies have a 1-2 second spawn timer in which they are stationary and growing bigger and smaller to represent that they are spawning and that the player will not be killed running into them. With more time, future additions included high score actually being saved, more enemy types (only 1 right now), power ups, improved gameplay balance / difficulty scaling, improved visuals, and audio.

Enter a fully intractable world of dragons as one of four different types of baby dragon yourself. Enjoy the fully functional physics in the world while watching your back because no one in this world is your friend. Attempt to kill other dragons by firing bolts at them and collect there essence that drops from their corpse to grow in power. Watch as you and your enemies grow over time! The game includes three camera modes, each that came be varied independently to the players personal preference. Choice between three different attacks. Watch out for all the different kinds of enemy AI dragons that are very protective of their home locations. They will all continuously move back and fourth from their home location at random angle, firing and flying up and down in random intervals. Each type of dragon has a different personalities and unique attacks. All code is in C++ with Opengl and bullet physics engine.

MegaMan is a 2D platformer with shooter elements. The idea is you control your hero and navigate through the level destroying (or dodging) enemies, jumping through cliffs, or climbing up walls in order to reach the boss room. Once in you reach the boss room, you have to defeat the boss in order to clear the stage. Each boss has a weakness, so the strategy is to use a weapon that is more effective than the default weapons.

X has a variety of moves such as dash and the ability to charge his x-buster in order to give him more viable in the game. Using these abilities will allow you to defeat enemies more easily and travel to places not reachable with normal run jump actions. X also has the ability to "climb" walls. When you jump into a wall he immediately sets up into a position where he begins to slide down a wall. He moves down slower than a drop (say from a jump) allowing the player to keep jumping higher and higher along the wall. The on the training level we implemented is Zero, he is X's best friend and partner. He will test your abilities to control X by challenging you to a battle. He is equipped with a saber and his own Z buster.

Music/SFX: The game uses unique sound effects to give more realism to the actions performed by the hero. Each attack also has a unique sound effect. The music also sets the mood for the level or situation the character is in. Each stage has specific music with it, and when a boss is reached the music will change. The music and sound effects were found online by someone who ripped the music from the actual game "Megaman X5." We implemented the music and sound through a very useful and easy to use sound engine called "Irrklang."

Texture: The level texture was obtained by taking specific parts of another level (in Megaman X5) and putting it together. A few changes were made in order to make it look like the pieces fit together. We used SOIL in order to read the PNG files from our system into OpenGL.

Sprites/Animation: In order to make the animation for the game, we needed the sprite sheet for each character. Once the sprite sheet was found, mini sprite sheets were made by take the sprites that were needed for a particular animation and putting it into a new PNG file with transparency. Sprites were also read by SOIL.

Interrene is a motion-centric first-person shooter, set in an zero-gravity environment containing asteroids, miniature stars, and a colorful warp point, which servers as the exit point of the level. The object of the game is to reach this exit point while avoiding contact with the stars (which cause instant death) or being set adrift into space. The player's only tool to accomplish this feat is a grenade launcher, which can be fired at the asteroids, causing explosions that propel the player around the game world.

To help guide the player in the somewhat-disorienting environment with limited reference points, the player's crosshair changes color to indicate whether they are looking along their current path of travel. If they look up or down by more than several degrees, the horizontal line will change color to red, while looking left or right will cause the vertical line to do the same. Generally, shots fired with the "dead zone" on either plane will not cause the player's velocity in that direction to be altered -- this is to prevent minuscule variations in mouse motion from sending the player far off course.

The game was built for Windows using C++ with OpenGL/GLU/GLUT and OpenAL. Sounds were created with sfxr, and textures either created myself in GIMP or sourced from freely provided textures.

Some of the major features of the engine include:

• A custom physics system which can simulate forces on massive game objects and detect collisions with each other and the world. Collisions with world objects result in an object's velocity being modified appropriately, e.g. it will rebound depending on the angle, and lose a larger amount of speed when impacting at steeper angles.
• An external game world format that can be easily edited in a text editor, allowing anyone to quickly design their own levels.
• Reusable for populating texture and sound libraries; an extendable and reusable game object system, allowing quick creation of new static objects, moving entities, and weapons; threaded game logic and visual rendering.

The game is built with the Unity Game engine. All 3d models and textures were found online free for any type of use. The ground was created in unity and the select red box was created in unity. The character model and spider models came with animations.

Krov third person role playing game. The camera can move 45 degrees left and right on the x axis and 30 degrees top and down on the y axis. The character has animations for the following: jumping, running, walking, crouching. The character is able to shoot rock textured projectiles at enemies which push them back. The rocks are effected by physics but not by gravity. The enemies are affected by physics and gravity but not rotations on its x axis and z axis to prevent them from tipping over since their physics is based on a box around the model. The character is not affected by physics but gravity is simulated in the code to allow jumping to be realistic.

The game is a top down shooter game. The character rotates around its axis following the mouse and shooting in the direction trying to take out enemies and getting to his destination while avoiding getting shot. The game was used using the Ogre3d game engine. Some models come from the engine, other were created. Animations for the main character where imported from Quake. All AI and physics were created on own.

Inspired by Ender's Game, fly though the field and find the tunnel of your opponent(s)! Place alarms to alert you when you are found and eliminate your opponent(s). Play with as many of your friends as you like, but be wary because as the number of players increases, the larger the playing field gets.

Features: Networked game that keeps track of bullets, player paths, and alarms. Bounded game environment that expands with number of players.

The game is pretty much an indefinite racer. You control a red car and have to dodge all the purple cars. As time goes by, the cars get faster, 10MPH every 10 seconds. You can also use the W key to engage your turbo, which boosts your speed by 30MPH as long as it is held. The faster you go, the faster your score accumulates. There is no real way to win, you simply try to score as high as possible. Press B for a cool debug camera view. It is simple yet addicting.

Bomb Battle is a fairly straightforward clone of the popular Bomberman game series. It features between 2 and 4 players facing off in a 2-dimensional grid. The grid is populated by steel blocks and brick blocks, in addition to open spaces where the players can move. Each player has the ability to place bombs on the map, which upon detonation will destroy any brick blocks or players in its path. Unlike brick blocks, steel blocks cannot be destroyed. Initially, each player can only drop one bomb at a time, meaning they will be unable to place another bomb until the first one explodes. These bombs have a range of one cell, and the explosions only extends in straight paths (i.e. up, down, left, and right, but not diagonally). The goal of the game is to be the last player standing.

As players begin to destroy bricks, they may find powerups. Once collected (by walking over them), the player can become stronger for the remainder of the match. There are three types of powerups: extra bombs, larger range, and increased speed. An extra bomb powerup, denoted by the image of a bomb, will allow the player to drop an additional bomb without waiting for a previous one to explode. A larger range powerup, denoted by the image of fire, will extend the reach of their explosions by an additional cell. An increased speed powerup, denoted by the image of a roller-skate allows the player to move faster. These powerups can stack, so if a player picks up two extra bomb powerups and three larger range powerups, they can then place three bombs at a time, which will extends four cells in each direction.

Bomb Battle was created primarily using Unity. Textures for the blocks, the ground, and the powerups were drawn pixel-by-pixel in Microsoft Paint. All sound effects were created using a combination of Microsoft Sound Recorder and my own vocal chords.

A tetris-like game which modifies the Tetris formula by adding a dual use block which can act as either a normal block when horizontal or an "eraser" block when vertical. The game is created entirely with OpenGL/GLUT/C++.

You control a character that can run along any surface (e.g. walls, ceilings, floor, etc.). Your objective is to eliminate each of the enemies in the environment (by moving close and attacking them). Enemies move around randomly and occasionally scan for you. If you are detected, then the enemies will begin shooting at you. If hit, you will fall off whatever surface you are on. Given that the enemies avoid being on the floor, this makes it somewhat more difficult to complete the objective. If detected however, you can also hide behind objects until the enemy has resumed searching.

For me, much of the challenge was figuring out how to use Unity as well as what kind of gameplay I wanted to create.

• Ability to walk on any surface
• Implementing jump controls
• Basic lighting implementation
• Enemy AI

Overall, I learned a lot about how to use Unity and uncovered/resolved issues in my original design.

A very basic copy of the Donkey Kong Country Super Nintendo game, including one level and one boss. In this version, the user can perform moves from the classic game including jumping over lava and avoiding cannonballs.

In this game you play the role of a green car in a rush to get where he needs to go. The idea is to traverse the highway for as far as possible before crashing. Every few seconds the car accelerates slowing down is not an option!

Interesting features:

• Usage of the orientation features of the phone to calculate the location of the car on the screen
• Usage of the touchscreen to manipulate the position of the car
• Original music by Adrian Francisco
• Implementation of OpenGL ES 1.0 on an Android device in order to produce a video game (First mobile game for UMD CMSC 425, so I'm told)
• Programmed on a Mac, using Eclipse, Java, and the Android SDK - designed for the Motorola Atrix HD (Though it should run on most android smartphone handsets running Android 3.0 Honeycomb API Level 11)
• Much of this application would not be possible without the guidance and reference of google's Android Developer website. (Honestly. For real.)

A 2D side-scrolling puzzle game inspired by the 1980s game Lode Runner. The player is controlled using the arrow keys and spacebar. Developed in LibGDX and Scala, which runs in the Java Virtual Machine. LibGDX allows for the design of games in a high level language with a great set of tools that perform much of the OpenGL "dirty work". In addition, LibGDX allows the same source code to be deployed to a variety of platforms, including Desktop (Java), Android, iOS, and Web (HTML5).

Gameplay involves moving the player through a set of obstacles such as floating blocks, ladders, and doors while collecting coins to accumulate points. Moving through a door takes you to the next level, which is contains an entirely new environment/layout.

All physics in the game is written from scratch and characters/models are sprites generated by hand in Adobe Illustrator. The player is animated using the LibGDX Animation class which allows for a timed loop through a set of static images of player movements.

A basic bullet hell game where you must dodge enemy fire and outlast the barrage. Features 4 waves of enemies with increasing difficulty, as well as a final boss with a special attack.

An aerial view turn-based shooter built from scratch. The AI is kind of interesting because it ended up being the hardest part, but there's definitely a long way to go. The next steps include cleaning up the data structures to speed up performance/make the game more expandable, and improving the AI to incorporate different strategies. Better graphics would obviously be nice too, but it's not a pressing concern.

This is for two players game. One player plays with black stone. The other player plays with white stone. Two players make a turn to play. Players try to hit opponent's stone and make it outbound. In addition, try to keep his own stone on the board. The last one stands on the board wins. There are some special tools on the board. After stone hits tools, it can have special skills. Red circle means a wheel, so the stone can have more power. Red arrow can let stone shoot the ball without moving itself.

Epic Farm is a farming simulator with a two-dimensional isometric view. You are given a plot of farmland and a variety of crops to choose from. You can plant your crops anywhere you choose to on your farm, giving you the freedom to customize your farm however you like. You can earn money by harvesting the crops that you plant, and reinvest your earnings into your farm. You'll have to manage your resources wisely, as buying crops costs money, and harvesting crops costs energy.

I developed a custom isometric engine for this game. This involved writing a set of functions to translate between the screen coordinate system and the isometric coordinate system. A notable feature is the collision-detection routine that I created to check for overlaps in isometric space. Another aspect of my isometric engine is the depth-sorting function that ensures that all objects are drawn on the screen in the correct order, depending on their isometric coordinates. I also developed a system for panning and zooming in the viewport. My zoom function compensates for any panning that the player has done, so that the zoom is always relative to the center of the viewport. I created a UI overlay for the game, including a store where the player can buy crops, score and resource displays, and buttons to access the various features of the game. The resource displays are dynamic and will gradually increment and decrement whenever there is a change in the resource values.