My Senior Capstone project- I worked with a team of 4 other programmers and an artist to design and implement a video game. We decided to create a multiplayer space ship battle game that turned out quite fun, but would need a lot of polish to succeed in the market.

A playable version will be available here soon, but in the meantime the Game Design Document can be found here, and the source code is available for download on Bitbucket here.

Game Design DocumentSource Code (Bitbucket ZIP, 314 MB)

One level of a medieval fantasy combat game produced using Unity in my Advanced Game Programming class with one other programmer and a design team- many things are quite rough around the edges due to time constraints on the project. I worked on the enemy AI, menus, inventory, and laying out the levels, along with assisting on any other issues that arose.

You can play on Windows 64-bit systems by downloading from Dropbox here- controls can be found inside. The source code is available on GitHub here.

Play on Windows 64-bit (Dropbox)Source Code (GitHub)

A video game that I designed alongside a small team in early 2014. While the focus of my work was on creating fun levels, gameplay, and creatures, I also dabbled in creating terrain tiles and helped the programming team implement them into the game.

Source code of the project is unavailable, but the game design document can be found here. If interested in the terrain tiles, feel free to have a look at them by downloading them here (448 KB).

Game Design DocumentTerrain Tiles (448 KB)

One of the first programs that I made back in 2012- this is a pure JavaScript version of Blackjack that uses the console log and alert prompts to display and get input from the user in a two-player game. It's nice to see how far I've come!

You can play it here, or download the source code here (2 KB).

Play NowSource Code (2 KB)

A LeetCode problem where you are tasked with finding the shortest path through a grid starting at the top-left and working your way to the bottom-right with each movement costing varying amounts to complete. The full problem can be found here.

My first solution was to always search the lowest available path until the bottom-right was reached, but the overhead in finding the lowest path was actually causing it to be slower than my final implementation that just broke it down into a few computationally easy steps:

Conceptually, when the grid is finished, it will represent the shortest path to each individual square on the grid, which is obtained for each square by taking the lower of the potential adjacent origin grid squares plus the square's current value.

We calculate the values for the first row and column, adding the current value of the square we are determining to the total value determined in the previous square, completing the shortest path to the outer top and left areas of the grid.

Finally, we iteratively work through the remaining elements of the grid row by row, until we finally have the bottom-right square which is what we're after and return it.

I love how clever this solution feels once you realize it can be done so simply.

Toggle Code DisplayCopy Code To Clipboard

class Solution {
public:
	int minPathSum(vector<vector<int>>& grid)
	{
		for(int i = 1; i < grid[0].size(); i++) //Calculate the total distance to each square in the first row
		{
			grid[0][i] = grid[0][i] + grid[0][i - 1];
		}
		for(int i = 1; i < grid.size(); i++)    //Calculate the total distance to each square in the first column
		{
			grid[i][0] = grid[i][0] + grid[i - 1][0];
		}
		for(int i = 1; i < grid.size(); i++)    //Calculate the total distance to each square in the rest of the grid
		{
			for(int j = 1; j < grid[0].size(); j++)
			{
				grid[i][j] = grid[i][j] + min(grid[i - 1][j], grid[i][j - 1]);
			}
		}

		return grid[grid.size() - 1][grid[0].size() - 1];   //Return the total distance to the bottom-right square
	}
};

A LeetCode problem with the goal of rotating a linked list backward K times, with K potentially being fairly large. The full problem can be found here.

First we establish the length of the linked list by iterating through it and keep a reference to the head and tail of the list, then check if we have at least two nodes and connect the head and tail to make the linked list into a circular linked list.

Next, we want to determine what the new head and tail of the linked list will be. A surprisingly simple calculation can be done- subtract k modulus the total number of nodes from the total number of nodes (Nodes - (k % Nodes)) to get how many nodes forward from the original head we should traverse.

We simple iterate through the list once again, stopping at the node just prior to what will be the new head. Set the next node to the head, and then set the current_Node's next connection to a null pointer and finally return the new head.

I like how elegantly the solution came together, with only up to 2 loops through the list when a naïve approach could be a full k loops.

Toggle Code DisplayCopy Code To Clipboard

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution
{
    public:
        ListNode* rotateRight(ListNode* head, int k)
        {
            ListNode* current_Node = head;
            int number_Of_Nodes = 1;    //If 0 are actually present the head will be nullptr and be returned later

            if(head != nullptr)
            {
                //Count the number of nodes in the linked list and move current_Node to the end
                while(current_Node->next != nullptr)
                {
                    current_Node = current_Node->next;
                    number_Of_Nodes = number_Of_Nodes + 1;
                }
            }

            if(number_Of_Nodes > 1) //0 and 1 both return the current head without adjustment (Nullptr or a single entry)
            {
                current_Node->next = head;  //Make the linked list into a circular linked list
                current_Node = head;    //Reset current_Node from the old end to the original head

                //Move current_Node to the end of what will be the new linked list. 
                for(int i = 0; i < number_Of_Nodes - (k % number_Of_Nodes) - 1; i++)
                {
                    current_Node = current_Node->next;
                }
                head = current_Node->next;  //The new head is the next in the circular linked list
                current_Node->next = nullptr;   //Cut the circular linked list to make it a normal linked list
            }

            return head;
        }
};

A LeetCode problem in which we are tasked with finding whether a vector in which each value represents the max number of indexes forward you can traverse through the vector and must determine if the final entry is reachable. The full problem can be found here.

First, we will reconceptualize the vector from being the number of jumps available at that space to be the furthest space that index is able to reach. To do so, we simple add the index to the value for each entry in the vector.

Next, we will loop over the vector going to the available space that is able to travel the furthest each time we jump until we either reach the end or aren't able to make any progress on that jump and return true or false accordingly.

This is another problem that I enjoyed due to how simple it can be reduced to in contrast to how complex it sounds to accomplish.

Toggle Code DisplayCopy Code To Clipboard

class Solution
{
    public:
        bool canJump(vector<int>& nums)
        {
            int lower_Index_Bound = 0;
            int higher_Index_Bound = nums[0];
            int previous_Higher_Index_Bound = 0;

            //Change the array to represent the furthest space the jump can reach
            for(int i = 0; i < nums.size() - 1; i++)
            {
                nums[i] = nums[i] + i;
            }

            //Check from newly available positions for the highest available space. Break out if we make no progress or reach the last index
            while(higher_Index_Bound != lower_Index_Bound && higher_Index_Bound < nums.size() - 1)
            {
                previous_Higher_Index_Bound = higher_Index_Bound;
                higher_Index_Bound = max(higher_Index_Bound,
					*max_element(nums.begin() + lower_Index_Bound + 1,min(nums.begin() + higher_Index_Bound + 1, nums.end() - 1)));
                lower_Index_Bound = previous_Higher_Index_Bound;
            }

            //Check if some series of jumps successfully reached the last index
            if(higher_Index_Bound >= nums.size() - 1)
            {
                return true;
            }
            else    //If none did, then a jump made no progress which means the last index is unreachable
            {
                return false;
            }
        }
};

A tool for calculating expected damage output in combat for the 5th edition of the tabletop role-playing game Dungeons & Dragons (D&D). Great for analyzing character builds and planning combat encounters.

Take a look at it here, or view the source code on GitHub here.

Use NowSource Code (GitHub)

While more of a personal list that I use and very tailored to that end, players of the MMO version of D&D- Dungeons & Dragons Online (DDO)- may find this sortable table of quests to be convenient.

Check it out here or download the source code here (13 KB).

Use NowSource Code (13 KB)

Another DDO tool that I've found to be helpful- this one is just some straightforward calculations to determine average damage output, great to help decide between many items and abilities.

Available for use here, and download here (3 KB).

Use NowSource Code (3 KB)

A project I contributed to at the Conrad Blucher Institute (CBI) that would give forecasted weather and severe weather events along a travel route. I worked with an existing codebase to improve speed, reliability, and implement additional features such as optional overlays for temperatures, precipitation levels, and windspeeds along a route. Weather On Wheels was available on a website and in the Android and Apple stores, but unfortunately, CBI no longer maintains the project and handed it off to another company that has left it nonfunctioning for a long time.

A poster I used for a presentation on Weather On Wheels that contains some additional information and screenshots of it in a late stage of development can be found here.

View Poster

A primitive paint program I made to assist with an early Graphics Programming project that was used to demonstrate just how intensive making simple graphics can be. You can play around with it here, or download the source code here (3 KB).

Use NowSource Code (3 KB)

This website! Hopefully you've found that it runs quickly and is organized well. If you've noticed any problems, let me know about them at andrewdylanfrost@gmail.com.

The background images are available for free at the following external locations: About Me, Projects, Résumé. Source code for the website can be found on GitHub here.

I used Prism for code section highlighting, but otherwise everything is made from scratch.

Source Code (GitHub)

In addition, I've worked on a large number of small projects to bolster my skills using a variety of languages including F#, Perl, and Java. Some of the projects include small games such as Tic-tac-toe, an optimal path-finding algorithm, and a command-line file navigator.