Jonathan Gardner's Portfolio


C++

    All of the projects listed here have been programmed in C++. I have worked on both solo projects and group projects. There are a variety of different projects listed here. Some I have worked on as personal projects, some for College courses, and others for jobs. Below you will find the projects name with a detailed description. Most (if not all) of my projects have information available for download. Unless noted the download will be a zip file. If you need any more information check out my Contact Info page and let me know. I retain all rights to the material that is available for download or viewable.




Genetics
Project Title : DNA Project
Application Title : Genetics
Date Completed : December 2007
Project Timeline :
  July '07 to August '07 (Pre-Production),
  September '07 to December 3rd '07 (Production)
Team (roles) :
  Jonathan Gardner (Team/Project Lead, Programming Lead, Designer, Documentation)
  Jonathon Hubbard (Programmer, Designer, Outsource Manager)
Application Type : Entertainment (PC Game) / Tools
Location : Phoenix, AZ
Project Type : Personal, and College Course
Project Hours :
  Jonathan Gardner : ~350 Total Hours (275 Production, ~75 Pre-Production)
  Jonathon Hubbard : ~135 Total Hours (80 Production, ~55 Pre-Production)
Sister Links :
  Genetics Documentation (Docs)
  World Editor (C#)

Documentation :
  For a complete overview of the Genetics Documentation, head over to the Documentation section. You can jump to the Genetics Documentation with the link above.

  We created and developed a Game Design Doc (Game Bible) for the DNA Project. Overall it is pretty complete for a game doc. The only areas that weren't completely developed were the Story and Dialog. This was mainly because of the short time frame we had for the project. The Story that we developed for Genetics has 5 Archs. While we developed all 5 Archs, we only fully developed the First Arch. Again this was mainly because of the time restraints for the project. Along with that, the Dialog wasn't fully developed either. This was kind in a way due to the fact that we didn't fully develop the entire story. Everything else is very detailed and precise.

  Although we developed the ideas and overall design together, there were a few parts we each worked on separately. I worked on the Game Mechanics and detailed Story outline. Hubbard worked on the physical descriptions and some of the original back story for the races. There were also a few parts of the story that each of use worked on separately. While we did work on most of the doc together, the final design and layout of the doc was my responsibility. So I worked on the layout of the doc itself.

Pre-Production and Course Details :
  Genetics originally started out as a personal project between Jonathon Hubbard and myself. During the final year we attended UAT, we discussed making our own game as a final project. This was mainly because UAT at the time didn't have any final project courses. We felt that this project would give us a good demo for future interviews. After we talked about it for a little while, we both started to come up with some ideas.

  We officially started working on the project in early July. We used the extended July 4th break to get a jumpstart on the design. This part of the project was our pre-production phase. Since we both had full time schedules for the summer, we spent our spare time working on the design. Towards the end of the summer semester, we discussed creating a file project class with one of our instructors. The instructors name is Ken Adams, which both Hubbard and I had several classes with. He was one of the only other people to know about our project. After talking with Ken, we were able to set up a mod class to demonstrate our project.

  There were a few prerequisites that we had to meet for this to officially be used for the mod class. The first thing we needed was instructor support and approval. With Ken willing to sponsor us for the class, that part was taken care of. The second was that Hubbard and I had to develop the course workload and schedule. We also had to list out each members responsibilities and any outsourced material.

  With everything set up we started the classes with very ambitious and extreme goals. Overall we achieved all of our goals and our deadlines. We did have one major problem during the life of the project. While working on the Direct X Shell, Hubbard eventually ran into an error that neither of us could fix. We spent an extra 4 days working on the issues with no luck. After the 3rd day, we discussed the option of scrapping Hubbard's version of the Direct X Shell. With this being a possible option, it basically gave me the responsibility of creating the Direct X Shell. Eventually this was the path we took.

  The extra week spent working on the issues and recreating the Direct X Shell set us back a little. Overall at that point we were 1 week behind the vigorous schedule we set out to meet. The good thing was that we still had 6 weeks left in the project to make up that lost time. We planned on having the project finished on Friday November 30th, but we didn't finish until Monday December 3rd. With our progress and detailed outline of the project, Ken was willing to give us the weekend as an extension. The couple extra days make a big difference in the feature set we were able to complete.

Project Details :
  As noted above, the DNA Project was to develop a PC game. Along side with this there was the World Editor, Tile Engine, Game Engine, and a Direct X9 Shell (Interface). Originally The Direct X9 Shell and the Game Engine were going to be developed by Hubbard. But after the issues with the Direct X9 Shell, we decided that I would take over most of the programming. This was in part because I was developing the Tile Engine and World Editor. We felt it would speed up production if I developed the Game Engine alongside the World Editor and Tile Engine. This way we would spend less time analyzing each others code for the project.

  Since this was a full scale project, we originally decided to use C++ and Managed C++ for the project. Everything except the World Editor would be coded in C++, and we would wrap the World Editor in Managed C++. This was to gain the benefits of using the Gui and Interface objects. This eventually became an issue getting the Managed C++ to operate correctly. So after a slight delay, and some testing, we ended up using C# for the World Editor. The World Editor (C#) is described in more detail in my C# Section.

  Direct X9 Shell : This was the original programming foundation for our project. The Direct X9 Shell was our interface to Direct X for the rest of the project. The shell handles 2D & 3D Graphics, User Input, Joystick Support, Sounds, and a couple various utility features. Currently we have both a C++ version, and a C# version. As noted above, the C# version is for the World Editor, and the C++ version is for the Game Engine.

  Tile Engine : The Tile Engine was developed on top of the Direct X Shell. By doing the Tile Engine on the Direct X9 Shell, this allowed us to utilize all of the Direct X9 Shell Features. Basically that meant we didn't have to develop a secondary system for the Tile Engine to load Image Files with. This also allowed us to focus mainly on the features of the Tile Engine. One of the biggest features was the ability to use layers. This was a cornerstone for our project, as we would be drawing multiple layers for the game itself. Along with that we also added the ability to apply flags to the tiles. This would allow the tiles to have different properties and reaction with the player and game world.

  World Editor : The complete section on the World Editor (C#) is located in my C# Section. The World Editor was more or less built on top of the Tile Engine. It uses the Tile Engine and Direct X9 Shell to display the entire 'Game' world. This allows the user to see the game world as it would be rendered in game. The World Editor allows the user the ability to load several levels into a 'game world'. This can save time with development, as not all of the levels need to be defined at once. A similar feature is the ability to load multiple tiles or a completely separate tile set for each level. The levels operate independently of each other and of their respective tiles.

  Game Engine : The Game Engine was the last section of programming for the DNA Project. As it is right now, more or less it's a state machine. The game has a specific state and runs a specific section of code for that state. If we had been able to fully develop the game engine it would probably have more details. But for now it's just loads an initial game world. It allows the user to move and see the game world, but no real features have been implemented.



Top

Console Directed Node Mesh
Application Title : Console Directed Node Mesh
Date Completed : March 2007
Project Timeline : All of March '07
Team (roles) :
  Jonathan Gardner (All)
Application Type : Tool
Location : Phoenix, AZ
Project Type : College Course
Project Hours :
  Jonathan Gardner : ~22 Total Hours
Sister Links :
  Directed Node Mesh (Win Vers) (C#)
Downloads :
  ConsoleNodeMesh.zip  ( ~ 145 KB)

Project Details :
  This project was for a Data Structures course I took at UAT. The project was to demonstrate the ability to develop and use Data Structures. The guidelines stated that we needed to use a Node Mesh. We also had to develop a couple path finding algorithms. The ones listed in the project guidelines were Shortest and Longest Path. The Nodes also had to have an associated weight and connections to other Nodes. Lastly the Node Mesh was to be read in from a file. Since I had some prior experience in Path finding, I talked to the instructor and added a few things to this project.

  My project used a Directional Node Mesh, Loads external files, creates random node meshes, has weighted Nodes and Edges, and used these algorithms : Shortest and Longest Path, Breadth First, Best First, Dijkstra, and AStar. One of the additional features that I added was the ability to select which weights to use, or a combination of weights. This was because both my Nodes and Edges had separate weights. The duration of the project was just about 1 month. One other aspect of the project was to set up a schedule and have the instructor approve it. My schedule was pretty straight forward, and is actually included in the zip file.

  Overall, my project went very smoothly and had no major issues. Setting up the Data Structures wasn't too hard with some of my prior experience. My setup had 2 main parts, the Node and the Edges. The Edges were the connections between each of the Nodes, and were directional. Both the Edges and the Nodes had separate weights that were used in the path finding algorithms. This version of the application was done in a console window. So all input and output is displayed via a standard console window. The nice thing about this version is that I had a previous console library that added color. So I was able to add a little extra color in the display.

  That in essence covers the project in detail. I did later make a C# version for improved input and output. Along with that the use of a Gui made the application much easier to use. Check out the C# version here : Directed Node Mesh (Win Vers) (C#)



Top

AI Path Finding
Application Title : AI Path Finding
Date Completed : May 2004
Project Timeline : ~3 Weeks
Team (roles) :
  Jonathan Gardner (All)
Application Type : AI Test - Demonstrative
Location : Winter Park, FL
Project Type : College Course
Downloads :
  AI_PathFinding.zip  ( ~ 30 KB)

Project Details :
  This is one of my more in depth applications for path finding and the use of data structures. This application was given to us (the class) as a bare bones application. The Gui (or interface), the Load, and drawing features were all completed for us. The main focus of this application was to develop the path finding algorithms. The algorithms I implemented in this application are : Breadth First, Best First, Dijkstra, AStar, AStar Optimized, and AStar Node Mesh. All of the algorithms used a 2D array except the AStar Node Mesh. This was one of the guidelines for the application.

  So overall what we needed to do was implement the individual algorithms. We also had to give the application a valid array or node mesh to draw the application correctly. To start the application you will select the algorithm you would like to run. There are a couple other parameters that are optional to run the application. After which you will load a map file. I have included a set of maps in the download. After the map loads, all you need to do is run the application. The algorithm will be drawn on the screen in real time to so the current progress.

  There are a few underlying details to the application. Depending on the algorithm, different weighted values will be used to find the optimal solution. Some of them are based on the heuristic weight of the nodes from the start location, and some are from the end location. There are some basic features to the application. Some include the ability to Pause, Stop, Continue, and Clear the current algorithm. It is also possible for the application to only draw the ending solution. You can run all of the different algorithms directly on a map without having to reload it. That in a nutshell is the path finding application.



Top

Bomberman Legends
Application Title : Bomberman Legends
Team Title : RivalSoft
Date Completed : May 2004
Project Timeline : May 7th 2004 to May 28th 2004
Team (roles) :
  Joe Micelli (Technology Officer)
  Tyler Pfaff (Project Officer)
  Jonathan Gardner (Interface Officer)
Application Type : Entertainment (PC Game) / Tool
Location : Winter Park, FL
Project Type : College Course
Sister Links :
  Bomberman Legends Documentation (Docs)
Downloads :
  Bomberman.zip  ( ~ 3.32 MB)

Team Details :
  We did start this project with 4 members. Unfortunately the 4th member had some personal issues and left the project part way through the project. He was set to work on the gameplay and AI for the game. After he left the project, Joe and I took over his role and completed the gameplay and AI. We did have some assistance from Tyler on the gameplay. Listed below are the original titles and roles for the members. Here are the key parts that I worked on for this project : Project Lead, Documentation, Graphics, Direct X Input, Joystick Support, Gameplay, Menus, Powerups, and High Score table.

  Joe Micelli - Technology Officer- The Technology officer's role is to create and maintain the baseline tech that the game will use and to provide and extend functionality as needed.
  Jonathan Gardner - Interface Officer- The Interface Officer's role is to create the menu system as well as the overall HUD in game. He also handles input management and config files.
  Tyler Pfaff - Project Officer- While this role sounds non-technical, on this project it certainly is not. The Project Officer is in charge of making sure that all documentation is in place and accessible to other team members. The Project Officer is in charge of managing integration of the other member's code. He also makes sure that the project stays on schedule and that feature creep doesn't set in. His additional coding responsibilities lie in support of the technology officer. The Project officer would create particle systems and implement z-sorting. He is in charge of the appearance of the project and its correct submission.

Project Details :
  This project finished with some success. Here is a list of the finished parts of the project : Particle Engine/Editor, Game Engine, Tile Engine/Editor, Gameplay, 4 Levels, Input/Output, Simple AI, and Documentation. All of these went pretty smooth for the project. We did have some minor issues and errors, but we worked through them as a team. Unfortunately there were a few parts to the project that we didn't fully complete : The Last level, The Boss Fight, and a more complex AI. In general this project worked out pretty well though.

  The course that we did Bomberman Legends in was a fast paced course. It was set up so that groups would do a fast paced prototype game of their choosing. Each group had the same timeframe to complete their prototype, which was 3 weeks. The only difference is that the teams could range from 3 to 5 members. Our group had the best documentation out of all of the groups (12 total groups). Bomberman Legends earned the 3rd highest grade in the class as well. Overall this project had some good and bad parts. I know that after working on this project I learned a lot about team work and chemistry.

Particle Editor Details :
  Along with the game, the zip file also includes the Particle Editor. Tyler and Joe did the majority of the work on the particle editor. I helped out from time to time on it, and helped debug issues. Overall I can't say too much on the inner workings of the particle editor. There are a few saved particles that can be loaded and viewed. We did use this to produce some of the particle effects in the Bomberman Legends game.



Top

Open GL Test Level
Application Title : Open GL Test Level
Date Completed : March 2007
Project Timeline : ~3 Weeks
Team (roles) :
  Jonathan Gardner (All)
Application Type : OpenGL - Prototype - Demonstrative
Location : Phoenix, AZ
Project Type : College Course
Sister Links :
  OpenGL Test Level Documentation (Docs)
Downloads :
  TestLevel_OpenGL.zip  ( ~ 460 KB)

Project Details :
  This a fairly simple application in OpenGL. This was my final project for the class, which was a combination of all the features we covered in the class. During the class I developed an OpenGL Shell window, as the original one the instructor had was defective. So I offered mine to the class and to future classes to use and a base shell. This worked very well, and unlike the predecessor, it didn't crash when you exited the window.

  During the class we learned how to perform some manipulation of objects in OpenGL. We also learned how to setup a few different styles of drawing. This main mainly a wire frame and full polygon setting. We also learned how to use vector and flat lighting. I also added user input for camera placement. Included in the download is a word doc that covers the main aspects of the application and it has all of the controls.



Top

8 Puzzle
Application Title : 8 Puzzle
Date Completed : May 2004
Project Timeline : 6 Hours
Team (roles) :
  Jonathan Gardner (All)
Application Type : PC Game - Prototype
Location : Winter Park, FL
Project Type : College Course
Downloads :
  8Puzzle.zip  ( ~ 85 KB)

Project Details :
  The 8 Puzzle was a fun game to replicate. It was done during my AI courses to demonstrate the ability to find solutions. It used a kind of path finding logic to manipulate the 8 puzzle into the best possible solution. There are 5 difficulties to the application. Each one has a various timeframe (or number of moves) that was the optimal solution. For the assignment we were given the best possible solution number, and we had to devise the algorithm, to find that solution. This was a timed test, and we had a maximum of 7 hours to complete the test.



Top

Binary Tree
Application Title : Binary Tree
Date Completed : March 2007
Project Timeline : 10 Days in March '07
Team (roles) :
  Jonathan Gardner (All)
Application Type : Data Structures - Demonstrative
Location : Phoenix, AZ
Project Type : College Course
Downloads :
  Btrees.zip  ( ~ 190 KB)

Project Details :
  I have 2 versions of my Binary Tree here. They both use a Binary Tree to sort random numbers. Each version is listed below with some details on what it does.

Project 'Btree In Pre Post Order' Details :
  This version is pretty straight forward when you run it. It will get 16 random numbers and put them in a Binary Tree. They are sorted and then displayed in 3 different ways. The first display is 'In Order'. The scheme for this print is : go to the 'Left Node', print 'Node', then go to the 'Right Node'. The second display is in 'Pre Order'. The scheme for this print is : print 'Node', go to the 'Left Node', then go to the 'Right Node'. The last display is in 'Post Order'. The scheme for this print is : go to the 'Left Node', go to the 'Right Node', then print 'Node'.

Project 'Btree Sorted' Details :
  This version starts out by printing out a Binary Tree in a 'Pre Order' fashion. This print out is done on the tree while it is unsorted. Next the application shows you the tree in the unsorted order tiered. This is to give you some perspective on how the tree changes when sorted. The next print out is to show the tree sorted. It will also show the tree in a tiered diagram. Next the application will display the tree sorted and balanced. This means that the tree will have x tiers, and all of the nodes will be filled. Any empty nodes are represented by a 0. The last print out shows the tree sorted and balanced in a tiered diagram. This printout is done with a loop instead of a recursive function. Lastly the application will print out the root node and the number of nodes in the tree.



Top

Death Invaders
Application Title : Death Invaders
Date Completed : April 2004
Project Timeline : 5 Days
Team (roles) :
  Jonathan Gardner (All)
Application Type : PC Game - Prototype
Location : Winter Park, FL
Project Type : College Course
Downloads :
  Death_Invaders.zip  ( ~ 1.85 MB)

Project Details :
  This was a fun clone that I made while learning Direct X. It is a clone of Space Invaders with some different artwork. It includes all of the general aspects of Direct X. It has a D3D drawing area, Input, Sounds, and Image loading. You are able to play the game as a single player or in a 2 player mode. Each player will take turns switching on the death of a player. Each level the enemies become faster and shoot more rapidly. I have also implemented 3 difficulties, Easy, Medium, and Hard. This can be set for each player individually. Also I have 2 styles of enemies. One that shoots a 3 way shot, and the other shoots a single shot. The player can hid behind 1 of 3 barriers. But beware that the players' bullets can destroy the barriers. The barriers will reappear every time the player dies or on every even numbers level. There is also joystick support for this game.



Top

Allegro Games
Application Title : Allegro Games
Date Completed : April 2007
Project Timeline : 7 Weeks from March to April '07
Team (roles) :
  Jonathan Gardner (All)
  Jonathon Hubbard (All)
Application Type : Various Games (PC) - Prototypes
Location : Phoenix, AZ
Project Type : College Course
Sister Links :
  Super Goomba Documentation (Docs)
Downloads :
  AllegroApps.zip  ( ~ 3.13 MB)

Allegro and Course Details :
  This was a course to showcase game development in 2D. Also it was used to get the students familiar with an outside library during a project. For the class we used the Allegro library, which is kind of like a simplified wrapper for Direct X. We had to become familiar with the library and use it to develop a variety of games. Most of the games in the class were recreations of old 8-bit style games. Each of the games are described below.

  Some additional Notes : All of the projects were done solo with the exception of 'Super Goomba'. This was the only group project, which I did with Jonathon Hubbard. All of the projects where done in a 1 week timeframe, with the exception of 'Super Goomba'. Super Goomba was the only project we had 2 weeks to complete. Unless noted or displayed in game, all of the keys are Escape, Space, and the Arrow Keys. Escape will exit you from all of my games.

Game Name : Pong
Project Details :
  This one is a recreation of Pong. Basically you want to hit the ball back and not let it hit the wall behind your paddle.

Game Name : Asteroids (Vector) & (Non Vector)
Project Details :
  This was a recreation of the old Asteroids game. Basically you are a solo ship that blasts incoming asteroids. You are trying to stay alive as long as possible. You score 1 point for each asteroid destroyed, and 1 extra life every 100 points. You die when an asteroid hits the ship. Basically the only difference between the 2 versions is the use of vector physics for movement.

Game Name : Shooter
Project Details :
  This is a side scrolling shooter game. My version is actually a vertical scroller, but overall they are the same thing. This was to demonstrate the ability to scroll objects across the screen. In my version you are a ship trying to get back to base. There is an asteroid field in your way and you have to shoot the asteroids to get back to your base.

Game Name : Breakout
Project Details :
  This is a recreation of Breakout. My version is a horizontal version of the game. You move the paddle back and forth to knock out the bricks. The game also randomizes the colors of the brick each round and each time you run the game.

Game Name : Invaders
Project Details :
  This is a version of Space Invaders. I again used a non conventional style, My invaders come in from the side instead of the top. This was the first game in which we applied simple animations and sounds.

Game Name : RPG
Project Details :
  This one probably the most in depth game for the class that I worked on. It is a never ending dungeon with enemies in it. You are the hero and you are trying to fight your way out. The map is randomized, and it also has a path finding algorithm applied to ensure a way out. Once the map is rendered you explorer the map and level up. There are a various set of enemies that you can fight. You receive experience based on how difficult the enemy is. The stats are applied in the game to show different effects. All of the keys are displayed on the screen.

Game Name : Super Goomba
Project Details :
  This was a fun game to do. It is also very difficult to make it through al l3 of the levels. This project shows a combination of all of the aspects we learned in the class. Basically it shows off all of the key aspects of the Allegro Library. This game is a Mario style game. The main difference is that you are the Goomba instead of Mario. You make your way through 3 levels to complete the game. Also included is a very simple Game Design Doc.



Top

RPG
Application Title : RPG
Date Completed : November 2003
Project Timeline : 2 Months (October to November 03)
Team (roles) :
  Jonathan Gardner (All)
Application Type : PC Game - Prototype
Location : Winter Park, FL
Project Type : College Course
Downloads :
  RPG10.zip  ( ~ 120 KB)

Project Details :
  This was one of my first C++ Games and classes. The instructor was one of the best I have ever had. He was extremely knowledgeable in C++ and was able to explain everything in a way that was easy to understand. Outside of that, the game was a compilation of the entire class and the things we learned. This game is a simple RPG with a hero and some bad guys. It is also a Console application with some color. There are random battles and treasure chests on the map. The chests also have 'traps' that you have to answer to get the loot. Overall it is a simple but complete game.



Top

Tactics
Application Title : Tactics
Date Completed : January 2004
Project Timeline : 1 Week
Team (roles) :
  Jonathan Gardner (All)
Application Type : Data Structures - Game Prototype
Location : Winter Park, FL
Project Type : College Course
Downloads :
  Tactics.zip  ( ~ 100 KB)

Project Details :
  This is an interesting simple game. It is based off of games like Final Fantasy Tactics. Each character has a specific ability set and movement range. During each turn each player moves their characters and if able attacks the enemy. Whoever has the last team standing is the winner. The reason this was a data structures project was the use of the multiple classes. The cross class interaction and use of the 2d array was the main purpose. This was one of the first assignments in the course, so the overall tech level wasn't extremely high. Though the game is rather fun for a while, there isn't a lot of progress to be had.







Website Home
Std Ver Home


Portfolio
  -Resume
  -Professional Experience
  -Personal Intel
  -Programming
    >C++
      ~Genetics
      ~Con. Node Mesh
      ~AI Path Finding
      ~Bomberman Legends
      ~Open GL Test Level
      ~8 Puzzle
      ~Binary Trees
      ~Death Invaders
      ~Allegro Games
      ~RPG
      ~Tactics
    >C#
    >Director
    >Flash
    >Lua
    >Mods/Other
    >VB6/VB.net
  -Multimedia
  -Web
  -Documentation
  -Contact Info
  -Downloads

Services

Personal Data

Site Map

Error Reports