Tic-Tac-Toe

Overview

This colorful take on the classic tic-tac-toe game was the very first app I created as a developer. Users can register to use the app and their user and game data are saved to a Rails API. I learned so much throughout the process of building this first app and it was incredibly fun figuring out how to implement the game logic. My proudest moment during development was probably when I figured out how to render a full readout of a user's game history. It was a challenging issue for me to tackle at the time, particularly since I had not yet been introduced to helpers like Handlebars.

Links

Front-End Repo: https://github.com/ND56/Tic-Tac-Toe

Deployed Front-End: https://nd56.github.io/Tic-Tac-Toe/

npcHub

Background: Dungeons & Dragons ("D&D")

To understand the utility of npcHub (and it's moniker), one must first have a basic understanding of the classic tabletop game commonly known as D&D.

D&D is a role-playing game ("RPG") in which a group of people come together to play characters---i.e., "player characters," or, "PCs"---in a game created by an individual known as the Dungeon Master ("DM").

While DMs often have many tools at their disposal to construct the world in which the PCs will play their game, it is an incredibly onerous task. The DM is responsible for creating civilizations, cultures, monsters, pantheons, and---finally---every person that exists in that world aside from the PCs.

This last category is commonly referred to as "non-player characters," or "NPCs"---and that's where npcHub comes into play! As I expand on below, my app is designed to alleviate some of the burden that DMs face in creating their worlds, allowing for faster game-building and more D&D-playing.

Overview

npcHub is a place for DMs to create, share, and validate other DM's NPCs.

I created a standard one-to-many relationship between users and NPCs to allow for DMs to CRUD NPC resources. This has many uses for DMs; one use is that it allows DMs to store their NPCs somewhere and they can come back to them and reuse them in future D&D adventures (i.e., DMs can keep them organized).

Another big part of why this app is useful is its search functionality and its ability for DMs to not only manage their own NPCs, but to share NPCs with eachother. The current iteration of the app allows DMs to view all public NPCs (the app has an option to set NPCs to private), as well as to search through NPCs based on a number of criteria (including NPC name, class, race, level, challenge rating, and NPC creator).

In this current iteration, the search functionality operates mostly based on exact equivalence between the search parameters and the NPC attribute; however, two exceptions are searches by race and searches by class---which are somewhat more robust. Both of these searches make use of stored arrays of classes, subclasses, races, and subraces and will return all NPCs falling within one of those arrays if the user's search parameter also falls within one of the arrays. In other words, a search for "Elf" will return all variations of Elves (e.g., Drow, Eladrin, etc.) and a search for "Wizard" will return all variations of Wizard (e.g., Illusionist, Necromancer, etc.).

In the final stages of this iteration, I implemented a "like" functionality. The idea dawned on me after I asked some friends to make a few NPCs to get my database started and I subsequently found myself repeatedly checking back to see what they updated. I realized that the hope of a "reward" kept me coming back to my deployed app and it struck me that this was much like social media, which---whether we want to admit it or not---many of us use because of the lottery-like rewards that come in the form of "likes" and "follows."

Realizing that this could draw more users to my app, I decided to implement a many-to-many relationship between users and NPCs through a new resource aptly named "likes." In this current iteration, when viewing other DMs' NPCs (DMs cannot "like" their own NPCs), DMs can "like" those NPCs (DMs can only "like" an NPC once) and the UI provides a readout of how many times each NPC has been liked. In addition, every user's home page has a display of the two NPCs that have garnered the most likes. In addition to being a tool that can draw more DMs to my app, I think this also serves the dual purpose of allowing DMs to validate eachother's NPCs and to draw the best of the group to the attention of other users---making my app that much more effective in its purpose. After all, better NPCs will yield better D&D gameplay.

Links

Front-End Repo: https://github.com/ND56/NPC-Organizer_Client

Deployed Front-End: https://nd56.github.io/NPC-Organizer_Client/

Back-End Repo: https://github.com/ND56/NPC-Organizer_API

Deployed Back-End: https://npc-organizer.herokuapp.com/

Clique

Overview

My two team members and I were tasked with building an application that would allow users to upload files; a plain, utilitarian app, aptly titled "fileBucket." However, after getting started, we quickly realized that we wanted to build something that had more character, that was fun and unique, and that would challenge us more. Thus, "Clique" was born! Inspired by social media apps like instagram and snapchat, Clique is an app that allows users to upload and share photographs with each other. Unlike existing social media apps, though, users' feeds are not populated based on a friend list. Instead, we thought it would be neat to build a social media app that connected people based on geographical location. To that end, we utilized multiple third party APIs to populate an image carousel (i.e., the user's feed) by comparing the geographical location of uploaded images with the user's current location. It was a blast to develop and we hope you check it out---and share it with your friends!

Third Party APIs

1. Amazon's AWS-SDK API (for uploading image files)
2. Geolocation API (for client geolocation)
3. GeoLib API (for image geolocation)

Links

Front-End Repo: https://github.com/ND56/Clique_Client

Deployed Front-End: https://nd56.github.io/Clique_Client/

Back-End Repo: https://github.com/ND56/Clique_API

Deployed Back-End: https://wdi-clique-api.herokuapp.com/

Fin

Overview

Fin is a conversational companion and personal assistant that I built using Google's natural language processing platform, Dialogflow, as well as an assortment of other technologies. Interactions with Fin are processed through the use of web sockets and each client interaction is siloed from others, which is achieved through a combination of (1) having each client generate a unique Dialogflow session and (2) having the Fin API socket only broadcast Fin's responses to the client that prompted the response.

Functionality

In it's current iteration, users can prompt Fin to do the following:

1. Tell jokes
2. Muse on the meaning of life
3. Engage in simple conversation
4. Provide a random fact
5. Send text messages
6. Report on the weather
7. Search the web
8. Provide playlist recommendations

Third Party APIs

1. Socket.io
2. Dialogflow API
3. Google Custom Search Engine ('CSE') API
4. World Weather Online API
5. Twilio
6. Spotify API

Links

Front-End Repo: https://github.com/ND56/Fin_Client

Deployed Front-End: https://nd56.github.io/Fin_Client/

Back-End Repo: https://github.com/ND56/Fin_API

Deployed Back-End: https://fin-api.herokuapp.com/