Colony

#include "mapping.h"

#include "lineDrive.h"

#include <dragonfly_lib.h>

#include <wl_basic.h>

//The last intersection that we encountered

int lastInt;

/* This array holds all of the intersections that are represented in the graph

 * after its creation, the graph is transmitted wirelessly */

node intersections[NUM_FEATURES]; 

/* 

 * Traverses the map using DFS 

 * Returns 0 if all of the intersections in the database were seen

 * 1 otherwise 

 */

int createEdge(edge* newEdge){

        char barcode;

        char time;

        rtc_init(SIXTEENTH_SECOND, NULL);

        rtc_reset();

    do

    {

                barcode = (char) doDrive(200);

    } while(barcode == NOBARCODE);

        time = rtc_get();

        newEdge->to = barcode;

        newEdge->dist = time;

        return 0;

}

int createMap(){

    int seenout_count = 0;                        /* The number of intersections we have completely seen */

    //int hist_count = 0;                        /* The size of our history stack */ 

    char seen[NUM_FEATURES];                /* Have we seen this node? */

    char seenout[NUM_FEATURES];                /* Have we seen the outoging edges of this node? */

    int i;

    int outEdges, currInt, chosenEdge;

    /* Initialize all of these arrays */

    for(i = 0; i<NUM_FEATURES; i++) {

            seen[i] = 0;

            seenout[i] = 0;

            intersections[i].type = 0;

            intersections[i].intNum = 0;

            intersections[i].numOut = 0;

            intersections[i].outSeen = 0;

            intersections[i].outgoingEdges[0].to = 0;

            intersections[i].outgoingEdges[0].dist = 0;

            intersections[i].outgoingEdges[1].to = 0;

            intersections[i].outgoingEdges[1].dist = 0;

            intersections[i].outgoingEdges[2].to = 0;

            intersections[i].outgoingEdges[2].dist = 0;

            intersections[i].outgoingEdges[3].to = 0;

            intersections[i].outgoingEdges[3].dist = 0;        

    }

        /* Drives to the nearest intersection */

        int barcode = nextInt();

        while(seenout_count < NUM_FEATURES)

        {

                currInt = getIntersectNum(barcode);

                seen[currInt] = 1;

                /* Get the number of outgoing edges */

                outEdges = getNumOut(getIntersectType(currInt));

                /* Randomly choose an outgoing edge that we have not seen to go down 

                 * if no such edge exists */

                                                                // TODO: include the appropriate header file for rand()

                chosenEdge = rand() % outEdges;

                /* We have not seen all the outgoing edges */

                if(!seenout[currInt]){

                        intersections[currInt].outSeen++;

                        /* We have finished seeing all outgoing edges of the intersection */

                        if(intersections[currInt].numOut == intersections[currInt].outSeen){

                                seenout[currInt] = 1;

                                seenout_count ++;

                        }

                }

                /* Traverses edge, stores information in struct */

                                                                /* TODO: Define traverseEdge, then uncomment this line

                traverseEdge(chosenEdge, &(intersections[currInt].outgoingEdges[chosenEdge])); */

        }

        /* We are done traversing send the graph to the robots */

        sendIntersectionGraph();

        return 0;

}

/* Given an intersection type, returns the number of outgoing edges */

int getNumOut(int type) {

    switch(type){

        case 0:

            return 0;

        case 1:

            return 1; 

        case 2:

            return 2; 

        case 3:

            return 3;

        case 4:

            return 4;

    }

    return -1;

}

/* Creates an edge in the graph */

int insertEdge(){

        return 0;

}

/* 

 * Drives to the next intersection and returns its ID

 * If we are at a dead end, returns -1

 */

int nextInt(){

        return 0;

}

/*

 * Given an intersection node returns an integer that

 * can be sent wirelessly

 *

 */

int encodeNode(node n){

        return 0;

}