Projects
an in depth look at all of my projects
Home is where the acorn is (unity, c#, maya, zbrush)
Home Is Where The Acorn Is is an action platformer where Rudy the squirrel defends the lands surrounding his home from slimes using his trusty stick. The idea was born from the Global Game Jam this year and was created by myself and Alex Stewart with music by Sam Power. The game itself consists of a hub level featuring Rudy's home and a growing stack of acorns that scales with the amount the player has collected, 9 levels with seasonal and time of day changes, and 3 simple varients of slimes.
Implemented mechanics:Character Movement: Transferring the inputs to a given rotation and moving the character forward in said direction.
Character Attack: When the given input is called trigger the attack animation and enable a collider in front of the player that accesses and lowers the enemy health if entered. Health: Scripts that store and lower/raise health as needed when the player and enemies enter corresponding triggers. Spawning Acorns: When an enemy dies, place an acorn at the death location. If the area of death doesn't pass a spherecast for being clear, then move the spawn location up and try again. If successful, add an upward force to the newly placed acorn. Object Pooling: While loading the first level, create a pool of acorns to pull from. These will exist for the duration of the game but require no additional acorns to ever be created. Whenever any of these acorns are picked up return them to the pool. Game Progression: Using a public static class to store and access the current level progress and amount of acorns the player has collected. This is called upon when the player returns to the hub after finishing a set of three levels to either unlock the next set, or to trigger the end screen. Level Progression: Calling the next intended level (whether in sequence or returning to the hub level) and updating the static DataHandler. Mobile Movement: Using the distance the touchpad has moved from the default position, determine whether the player should be moving slowly, normal, or quickly. Mobile Attack: When the button is pressed, attempt an attack. |
Created models:Rudy: Quickly sculpted using zBrush, then exported to be imported into Maya for cleanup and rigging. Idle, attack, and movement animations were all created within Unity.
Home: A small log cabin for Rudy to return to throughout the game. Featuring a deck, window, and chimney. Spruce Tree: Simple 3 stack pyramid tree with a small base. Fence: Repeatable fence and fence post composed of 3 slightly modified cubes. Boulder: Used to gate off the end of a level or hub exit. Created from a largely modified cube using Maya. |
mINT'S ADVENTURE (UNITY, C#, ILLUSTRATOR, Photoshop)
Mint's Adventure is a single player mobile adventure game where Mint the snow fox will explore "Hometown" and attempt to save the holidays. Gameplay will primarily consist of talking to other characters and exploring the surrounding areas. All assets have been created using a mix of Illustrator and Photoshop, and exist within a 3D world.
Implemented mECHANICS:Character Movement: Based upon where the player is holding the d-pad the character will animate and move in the correlating direction by setting the particular axis value and calling move using a character contoller. If the player is between two directions it simply uses a value of .6 in the diagonal. The character will also re-arrange its sprites based on the given inputs.
Create A Character: The player at any point can visit the dresser and change the color of each element of their clothing, change the sweater design, and the character's name! This is all stored and can be saved and called upon. These choices also modify the color of the bulk of the UI. Interactables: The player when hitting a trigger area can choose to interact with or speak to an object/character. Which of these is determined through a check on the interactable script. Object interaction: When the player interacts with a stationary object their character will exclaim something about the object or something they're feeling by pushing the text into a dialogue box with only the player as a participant. Dialogue: When interacting with a character the player will enter a series of dialogue. These are predetermined and updated based on inputs such as the character's name, if they have battled a character, and if they have rematched a character. Save/Load: The game keeps track of various things such as the character name, attire, health, spirit, money, and battle progress. Whenever the game is rebooted this data is displayed on the main menu and will be used when playing unless the character chooses to reset on the menu prior. The game is saved at a save block where the temporary data is transferred to a serialized file which overwrites any previous save. Store: The player starts with a small amount of money and can gain more through battling. This money can be exchanged for items that can be used in or out of battle to regain health and spirit. Inventory: The player can store up to 10 items at any one time, when acquiring an item it actually changes the values of a "blank" item to that of an existing item type. Reverting it back once the item is used. If the player attempts to gain more than 10 items at any point the game will simply prompt that they're unable to do so. Battling: When speaking to specific individuals the player can be prompted to initiate in a battle. These battles consist primarily of throwing snowballs back and forth, where the player must tap and drag on the snowball to modify the trajectory before releasing to launch. The player can alternatively use an item on their turn. |
aRT ASSETS:Characters:
Mint: A small character based on a snow fox of which is very exicted for the Christmas season. Rudy: The squirrel owner of the café in Hometown.
Salem: A cat who feels as though Christmas is overrated and prefers really any other holliday, but especially Halloween.
Various Penguins: The main inhabitants of Hometown.
|
fACTORY RESET (unity, c#, MAYA)
Factory Reset is a puzzle platformer created during a 48 hour game jam about a small robot who awakes stuck within an abandoned factory. You must use your battery to transfer charge throughout the levels to progress in hope of escaping. The game features 3 levels and a main menu.
implemented Mechanics:Movement: Tank controls, move forward or backward based on the vertical input, rotate left and right based on the horizontal input.
Battery Power: Ability to store, transmit, and regain power. Trigger player death upon depletion. Level Transitions: When the player reaches the end of a level, transition to the next. Save/Load: Any time the player completes a level autosave their progress. Upon rebooting the game give the option to either continue or start a new game. Moving Platforms: When powered allow a platform to move from one position to another, after a set duration return it to the original location. Push Platforms: Upon interaction, transition from one position to another permanently. |
created Models:Main Character: A small cylindrical robot with small glowing eyes, treads to move, two arms, and a battery strapped to its back.
Charging Stations: Simply based off of a large battery with an open power transmitter in the front. Environment Pieces: Several beams, pipes, platforms, and windows. |
Super Cool Penguin Racer (unity, c#, maya)
Super Cool Penguin Racer is a two player racing game based around two penguins in boxes trying to acquire the most points by the end of the level, these points can be acquired three ways. Each penguin starts the race with 3 fish which can be lost upon falling into the water throughout the map. If a penguin reaches the finish with any fish they are given additional points for each fish remaining. During the race penguins can also collect presents which are a worth a static value of one point. And finally, the first penguin to finish the level gets 3 additional points.
implemented MECHANICS :Local Multiplayer: Movements and inputs applied to each penguin racer separately. Also having independent cameras and UI.
Movement: Movement is handled a little differently in this game than many of my other projects, where the base is more akin to tank controls. The vertical axis handles going forward/backward where as the horizontal rotates the penguin in the given direction (also causing the penguin model to lean said direction). Points: Each player can acquire points from racing and the end goal is to reach the finish line with the highest cumlative total points. These can be acquired through presents, reaching the finish line first, and reaching the finish line with your fish. Fish: Each penguin starts with 3 fish, if they penguin reaches the end of the course with any fish they gain an additional 2 points for each. If a penguin falls in the water at any point and has fish remaining they will lose one. |
created MODELS :Box Penguin: A simple penguin sitting in a box, all set for racing.
Stone Pillar: A stacked stone pillar, many of these are placed along the course to mark boundries and present obstacles. Bridge: A plank bridge used to bridge gaps and create ramps for racing penguins. Pine Tree: A fairly simple tree used to flesh out the surrounding area of the race course. Various Presents: Three separate present models to fit the Christmas theme. String of Lights: A curve of multicolored customizable lights. |
Orbs (unity, c#, maya)
Orbs is a small 3rd person puzzle platformer created to further expand my own capabilities with game development and production. The game has 3 unique levels, a small hub, and 3 hidden characters to find. This is also the first time I've implemented a save and load feature into a game, which keeps the level completed progress, and characters found. The game is entirely unlit and emulates lighting using projectors.
Implemented Mechanics:Save/Load: Data handler which holds information on level completion and friend progress. Does a serialized save at the completion of each level and a deserialized load each time the player starts the game.
Camera Based Movement: Upon getting the input horizontal and vertical axis and using the camera as a reference, cause the player to transition to look in that direction and move forward while doing so. Pivot Cameras: Due to camera based movement the player may like to rotate the camera, they can do so in 45 degree increments that are smoothly transitioned to and from. Static Cameras: When entering areas that may have tight angles the camera will sometimes move to a position to give a clearer perspective. If this change is drastically different than what would be used normally the camera based movement is disabled and the player continues to move as if the camera hadn't moved. Orbs: Can be picked up and when done so emit an aura that activates objects of the same color. Can be used in correspondence with a mirror to reflect the aura in a given direction. Mirrors: When an orb is near these will shoot a massive ray in the direction its facing. This ray can enable specific mirror switches that have the same functionality as a button. Buttons: When the player pushes these down they can cause an object to rotate, a platform to start or stop moving, a teleporter to open, or a cage holding a friend to unlock. Any of these functionalities can occur given a reference and activating the given boolean. Respawn Points: When the player falls into the water they will die and need to respawn, if the player touches one of these respawn platforms they can choose to respawn there rather than the beginning of the level. All level progress stays upon death. Moving Platforms: Platforms of which interpolate between multiple positions based on time. Switch Platforms: Platforms which stay in one position for a given time, then quickly switch to a separate position. Typically used for moving in and out of a wall. Disappearing Platforms: Once the player has landed on this platform they will have a limited time before it begins to shrink and ultimately disappear. It remains in this state for a few seconds before reappearing. Rotation Buttons: Rotates a given object around the Y axis for the time the player is pushing it down. Can be toggled to be clockwise or counterclockwise. Teleporters: When enabled transfer the player character from one position to the other using a direct reference. |
created MODELS :Sapling: Small magical tree player character with a single leaf and eyes.
Sapling Friends: 3 small sapling friends to later be found and rescued by the player. Orb: Small sphere intended for the player to pick up and move. Environment Pieces: Several floor tiles, wall tiles, windows, torches, trees, bushes, flowers, roofing, arches, buttons, cages, and teleporters. |
Fragments (unity, c#, maya)
Fragments is a third person platformer where a small alien robot must use a water jet to propel themselves around the level collecting coins and fragments. The latter of which can be used activate portals to new levels! Everything in this game aside from the skybox and background music was created by me within a 48 hour game jam.
IMpletmented MECHANICS :Movement: The player can move in 8 separate directions based on the given input. They will instantly snap to and move in the given direction.
Water Jet: Seeming the player cannot jump, they must use the water jet to ascend heights. This simply holds an adjustable amount of water and adds a force to the character rigidbody to propel them upward. Refill Water: When the water jet is emptied the player can stand in a pool of water to regain the lost amount. Collectibles: This project was created without proper knowledge of how to correctly create this, and instead I created a workaround where all of the collectibles in the game would be created under a prefab during the initial loading screen, then enabled or disabled dependent on if the scene was the corresponding scene. The objects would simply be destroyed once collected, thus having them unable to reappear after returning to a level. Portals and Activators: When a player moves near an activator for a portal, a message prompt appears stating the amount of fragments they need to unlock the portal. If the player has the amount needed they can click to open the portal to the next level. |
Created MODELS :Main Character: A small pyramid headed robot outfitted with a small water jet.
Collectibles: Small coins and a fragment collectible vaguely representing a lantern. Environment Pieces: Several base platform varients, fencing, a portal table, and posts to mark the edges of the portals. |
tyrese and the magical things (unity, c#)
This game is a simple third person platformer where the player must move Tyrese the t-rex through various levels collecting bones and crystals.
IMplemented MECHANICS:Movement: This was the first real project I worked on in the Unity engine, and due to that the movement is based largely on the existing third person character controller.
Attacking: The player can attack to fight off enemies who drop meat upon death. Health: Health is lost by being attacked by an enemy and regained upon colliding with a meat object. Collectibles: All collectibles simply destroy on collision and respawn whenever the player returns to a level. |
Level Design:The level map started out on paper and was later finalized using Photoshop. While the entire level was never built due to time constraints, a lot of the level did end up in the final project.
|
elementals (html5, js, createjs, Flash)
Elementals is a 2D platformer with some RPG elements. The player can choose between three different characters based on the elements of earth, fire, and water. Each of these have different visual appearences and stats used in combat.
Implemented MECHANICS:Movement: Handled using velocity which increments each frame it is lower than the max speed.
Jumping: Determined by how long the player holds the spacebar and is less than the max jump height. Seeming the player has a constant gravity pulling them down the jumping has a smooth arc. Building levels: Done using a 2D array. On initialization the game pushes a series of arrays into a large overarching array. Then pushes 58 blocks into each new array. Placement is handled by multiplying the index number of each array by 40. Combat and Leveling: From the point you choose your character you are set to LV: 1 and distributed stats for HP, ATK, and MG. Upon colliding with an enemy these are called upon and a menu for combat appears. The player can choose to attack, defend, use magic, or heal. Upon selecting one of these the enemy determines if it can finish off the player. If not, it randomly selects a number from 1 to 20. This is used to determine the type of attack or magic it will use. Along with a chance to critical (dmg*1.5) or miss. If the player successfully blocks a physical attack they can then deal a critical hit on the enemy the following turn. Upon finishing a battle the player receives experience which is used to level up. Increasing all stats of the player and reseting experience. Also if the enemy was one of the three bosses the player gains an ability. Wall jump: Whenever the player jumps into a wall they will cling to the side and slowly decend. If the player jumps during this time they will push off the wall with a larger force. Hover: When falling if the player holds the jump button they will slow their decent allowing for more control of the landing. Dash: When the player quickly taps left or right the character will dash quickly in that direction. This allows for the player to quickly traverse and pass over gaps. It also keeps the player at a set height for its duration. |
Art Assets:All of the art in this project was created by me using Flash. While not the best program for pixel art, it was the one I knew best at the time.
|
Hatstrom (unity, c#, maya)
Hatstrom is a survival shooter created during a game jam held by NSCC based on the theme of "Exploding Hats". While I primarily focused on modeling and level design, I also assisted with some programming.
Implemented MECHANICS:Points: When the player shoots and successfully hits an enemy add points to their score based on if the enemy was defeated and what weapon they were attacked with.
Unlocking Areas/Weapons: When the player approaches a gate or weapon display a text prompt informing the player of the cost to remove the gate or acquire the weapon. Upon confirmation, deduct the amount from the available points. Bowler Hat Weapon: Replaces the default weapon with a weapon that slowly instantiates bowler hats. These launch using physics and will explode after a given time or upon colliding with an enemy, dealing large damage to all enemies within range. Dunce Cap Weapon: Replaces the default weapon with a fast firing weapon that deals low damage. This quickly instantiates several physics-based hats that destroy on impact and can push enemies away to give the player time to escape. |
Level Design:Seeming the primary focus of the game is to survive, creating an interesting environment to do so is a huge part of the project. Given the timeframe I attempted to make distinguishable areas of the map that interconnected to allow the player multiple different areas not only to see but to allow them to run from the coat racks!
Created MODELS:Main Character: A small blue blob character wearing a laser shooting hat.
Hats: A bowler and dunce hat. Environment Pieces: Various trees, rocks, pillars, and fencing. |