This app doesn’t use a username and password login to simplify its use, having no need to memorize one more password, instead it uses social media to give special functions to the user, like connecting with friends and inviting to events (feature to be added in the future). It contains custom views to allow the user to seamlessly login with either Facebook or Twitter, or both, that will then be saved on the database and synced across devices.

It also uses Twitter to retrieve events from posts, first it gets the user location, which will in turn ask Google for the address for that location and retrieve the user current city, uses that information to query the Twitter API (with custom built classes) to retrieve the events around the user with a special query to filter mostly events, after that it goes through each event to check if the free typed user location is the same city as the user, the last step is to pinpoint that event venue on a map, for that it queries Google Places API with the user location to retrieve a place around the user with the username from the tweet, showing it on the map after.

To interact with the database the app connects to PHP webservices, that will perform the operations on the database, it’s a safer a cross platform approach. The events saved on the database are straight forward, they have all the needed information and the app just requests the events of the day, downloads the images and has everything it need to proper show to the user.

Fragments are used to follow Google’s design patterns a give the user an experience that his used to, with the system apps, also loads the important part as soon as the user opens the app, which removes the need to go through the app looking for the needed information, the user can even, with just a tap, swap to a list view instead of the map.

For the connection to the database this app uses PHP as a webservice, improving security and allowing for easier portability, since the conde doesn’t need to be embedded in the app itself. To connect to the PHP file, the app uses an Interface built for this purpose that get a HashMap with the key-pair values to query the server, the PHP than return the appropriate response which the app will then read.

The design contains different custom views to allow the app to adhere to the platform design patterns whilst having a University focused theme. The theme is kept simple and bold, so it doesn’t overcomplicate the visual effect but still gets the user attention.

Fragments and activities are used as needed to help with usability, keeping the same flow that the user is used to, with the platform. Different navigation views are used depending on their needed function.

For this project I needed to build a binary tree data structure, with add, remove, find and print methods. After doing that I decided to take it a step forward and make it a self-balancing tree, this way reducing the worst case big-O to O(log(n)).

Uses three functions to balance the tree, the first checks the balance of a specific subtree, the second function just checks what the depth for a node should be and the last function actually balances the tree, after checking if it is Right Right Heavy, Right Left Heavy, Left Left Heavy or Left Right Heavy and adjusts it accordingly.

if (balance < -1) // Left Heavy
{
    int childBalance = checkBalance(node->left);
    
    // Left Right Heavy
    /*        T         ->      R
             /          ->     / \
            O           ->    O   T
             \          ->
              R         ->              */
    if (childBalance > 0)
    {
        shared_ptr<BinaryTreeNode> tempLeftRight = node->left->right;

        if (tempLeftRight->left)
            tempLeftRight->left->parent = node->left;

        if (tempLeftRight->right)
            tempLeftRight->right->parent = node;

        node->left->right = tempLeftRight->left;
        tempLeftRight->left = node->left;

        node->left = tempLeftRight->right;
        tempLeftRight->right = node;

        if (shared_ptr<BinaryTreeNode> parent = node->parent.lock())
            (parent->left == node ? parent->left : parent->right) = tempLeftRight;
        else
            root = tempLeftRight;

        tempLeftRight->parent = node->parent;
        tempLeftRight->left->parent = tempLeftRight;
        node->parent = tempLeftRight;

        tempLeftRight->depth = getCorrectDepth(tempLeftRight);
        tempLeftRight->left->depth = getCorrectDepth(tempLeftRight->left);
    }

    ...
}

The graph required methods like, add node, add edge, check if there’s a path, Dijkstra best path, check if the graph is connected and print methods. I decided to use an adjacency list for the edges because it was going to work with sparse graphs and a matrix would consume more memory. Each edge is also an object where both nodes hold a pointer to, instead of having to update both nodes for any changes it can be made on the Edge object.

This is a straight forward use of the algorithm, for each node creates a DijkstraItem object an sets the cost to the maximum allowed number, after steps trough each node finding and keeping track of the cheapest path to it, until it gets to the destination. After check if it is connected from the start node to the end node and prints the path

///<summary>Data structure used by Dijkstra algorithm.</summary>
struct DijkstraItem
{
    weak_ptr<GraphNode> fromRef;
    size_t cost;
    bool visited;

    ///<summary>Creates a new item, with cost 0 and visited set to false.</summary>
    ///<remark>BigO notation for worst case is O(1).</remark>
    DijkstraItem()
    {
        this->cost = UINT64_MAX;
        visited = false;
    }

    ///<summary>Creates a new item, with the given properties.</summary>
    ///<remark>BigO notation for worst case is O(1).</remark>
    ///<param name="fromRef">Pointer to the node from where this was found.</param>
    ///<param name="cost">Cost to get from the starting node to this one, throught the 'fromRef'.</param>
    DijkstraItem(shared_ptr<GraphNode> fromRef, size_t cost)
    {
        if (!fromRef)
            throw invalid_argument("'fomrRef' can't be null.");

        this->fromRef = fromRef;
        this->cost = cost;
        visited = false;
    }
};

All methods of all classes on the project are tested, from wrong input to check if properties are set accordingly and operations run as they should.

Some of the functions end up with a big-O of O(n^2) because the program tries to save memory in some places and as the graph isn’t dense the iterations can be done relatively fast, for denser graphs other methods could be used. The custom queue, stack and list work as a singly linked list to save memory, for improved processing speed a hash table or a binary tree would be better used.

This game connects to a MySQL database to retrieve and save the player data and score, also retrieves the information about the possible monsters to spawn. There’s also items that are fetched from the database, they appear in chests spread throughout the maze.

The objective is to reach the exit with the maximum number of points possible, the score decreases with time but can be increased with chests and by defeating monsters. The maze is generated randomly and the same for the monsters and chests, with items or not. The player can also have several characters with different stats and visual representation.

The battles with the monsters is the same style as a Pokémon battle, with animations for the attacks or defences and colors.

Also the game is prepared to run on a windows or linux system.

Used a A* pathfinding algorithm to find the best path for the enemies to move towards the player.

The server must be ran first, opening a connection for the client to connect to. The client is currently listening for messages from the server until he receives the string "EndOfMessage", after that the client stops listening and prepares to send a message, the server in turn starts listening. Every time a message is sent from either the server or the client, they hold sending more and wait for a "Received" message to check if it was successful or if needs to send again.

def sendMessage(message, EOM = True): 
    ''' Given a message input, and a False value, send the 
message and the client keeps wayting for another message '''
    resp = ""
    while (resp != "Received"):             # If not received
        conn.send(str(message).encode())    # Send message
        print("SERVER: {}".format(message)) # Print message sent
        resp = conn.recv(1024).decode()     # Wait client feedback 
    if (EOM):                               # If is last message
        conn.send("EndOfMessage".encode())  # Was last message 

The chatbot connects to a free online database that has different types of questions with the respective answers, gets the information through the website’s API that returns it in JSON format.

There’s also three files that come together with the server, that were found online in another free website, they contain information that is used to show fun facts about historical events, famous birthdays or famous quotes, they are also used to build question for the user with that information.

With all that information the chatbot can build single or multiple question to challenges the user, give him historical fun facts or just try and have a casual conversation with the user, if it doesn’t know the answer for any question it will perform a search on Google Search to try and answer the user.

It was a group work, so not everything was done by me, but the things that I done, although they work, they are not as efficient as they could be, some things would be done differently to improve performance and quality.