## Revision 1987

View differences:

17 17
``` * placed somewhere randomly on the map in the middle of the road*/
```
18 18
```char driveToNextInt(){
```
19 19
```        char barcode;
```
20
```
```
20

21
```        /* Keep driving until we see a barcode */
```
21 22
```        do {
```
22
```            barcode = (char) doDrive(200);
```
23
```                barcode = (char) doDrive(200);
```
23 24
```        }
```
24 25
```        while(barcode < 0); /* Condition codes are all neg. */
```
25 26

......
42 43

43 44
```        turn(type, direction);
```
44 45

46
```        /* Keep driving until we see a barcode */
```
45 47
```        do {
```
46
```            barcode = (char) doDrive(200);
```
48
```                barcode = (char) doDrive(200);
```
47 49
```        }
```
48 50
```        while(barcode < 0); /* Condition codes are all neg. */
```
49 51

......
51 53

52 54
```        newEdge->to = barcode;
```
53 55
```        newEdge->dist = time;
```
54
```
```
56

55 57
```        return barcode;
```
56 58
```}
```
57 59

58 60
```/* This function performs mapping */
```
59 61
```int createMap(){
```
60 62

61
```    int seenout_count = 0;			/* The number of intersections we have completely seen */
```
63
```        char seen[NUM_FEATURES];		/* Have we been at this intersection before*/
```
64
```        char seenout[NUM_FEATURES];		/* Have we seen the outoging edges of this intersection? */
```
62 65

63
```    char seen[NUM_FEATURES];		/* Have we seen this node? */
```
64
```    char seenout[NUM_FEATURES];		/* Have we seen the outoging edges of this node? */
```
66
```        char seenall[NUM_FEATURES];     /* This is how the array should look like once we have
```
67
```                                         * seen everything */
```
65 68

66
```    int outEdges, currInt, chosenDir;
```
69
```        int outEdges, currInt, chosenDir, i;
```
67 70

68
```    initGraph(seen, seenout);
```
71
```        /* Initialize the graph to all zeros */
```
72
```        initGraph(seen, seenout);
```
69 73

70
```    /* Drives to the nearest intersection */
```
71
```    char barcode = driveToNextInt();
```
74
```        /* When we see all the outgoing edges for the intersections,
```
75
```         * seenout will look as follows */
```
76
```        for(i=0; i<NUM_FEATURES; i++)
```
77
```                seenall[i] = 1;
```
72 78

73
```    while(seenout_count < NUM_FEATURES)
```
74
```    {
```
75
```         currInt = getIntersectNum(barcode);
```
76
```         seen[currInt] = 1;
```
77
```
```
78
```         /* Get the number of outgoing edges */
```
79
```         outEdges = getNumOut(getIntersectType(currInt));
```
79
```        /* First drives to the nearest intersection */
```
80
```        char barcode = driveToNextInt();
```
80 81

81
```        /* Randomly choose an outgoing edge that we have not seen to go down
```
82
```         * if no such edge exists */
```
83
```        // TODO: include the appropriate header file for rand()
```
84
```        chosenDir = rand() % outEdges;
```
85 82

86
```        /* We have not seen all the outgoing edges */
```
87
```        if(!seenout[currInt]){
```
88
```            intersections[currInt].outSeen++;
```
89
```            /* We have finished seeing all outgoing edges of the intersection */
```
90
```            if(intersections[currInt].numOut == intersections[currInt].outSeen){
```
91
```                seenout[currInt] = 1;
```
92
```                seenout_count ++;
```
93
```            }
```
94
```        }
```
95
```        /* Traverses edge, stores information in struct */
```
96
```        createEdge(&(intersections[currInt].outgoingEdges[chosenDir]),
```
97
```                    getIntersectType(currInt), chosenDir);
```
98
```    }
```
83
```        /* Randomly traverses the graph until all edges are seen */
```
84
```        while(seenout !=  seenall)
```
85
```        {
```
86
```                currInt = getIntersectNum(barcode);
```
87
```                seen[currInt] = 1;
```
99 88

100
```/* We are done traversing send the graph to the robots */
```
101
```sendIntersectionGraph();
```
89
```                /* Get the number of outgoing edges */
```
90
```                outEdges = getNumOut(getIntersectType(currInt));
```
102 91

92
```                /* Assign the number of outgoing edges for the current int */
```
93
```                intersections[currInt].numOut = outEdges;
```
103 94

104
```return 0;
```
95
```                /* Randomly choose an outgoing edge that we have not seen to go down
```
96
```                 * if no such edge exists */
```
97
```                chosenDir = rand() % outEdges;
```
98

99
```                /* We have not seen all the outgoing edges for the intersection we are at */
```
100
```                if(!seenout[currInt]){
```
101
```                        intersections[currInt].outSeen++;
```
102
```                        /* We have finished seeing all outgoing edges of the intersection */
```
103
```                        if(outEdges == intersections[currInt].outSeen){
```
104
```                                seenout[currInt] = 1;
```
105
```                        }
```
106
```                }
```
107
```
```
108
```                /* Traverses edge, stores information in struct */
```
109
```                //TODO: Does the chosendDir, correspond with what is in Priya's Code?
```
110
```                //A number between 0 and the number of outgoing edges ?
```
111
```                createEdge(&(intersections[currInt].outgoingEdges[chosenDir]),
```
112
```                                getIntersectType(currInt), chosenDir);
```
113
```        }
```
114

115
```        /* We are done traversing send the graph to the robots */
```
116
```        while(1) sendIntersectionGraph();
```
117

118
```        return 0;
```
105 119
```}
```
106 120

107 121
```/* Initializes the elements in the graph to 0 */
```
108 122
```void initGraph(char* seen, char* seenout){
```
109 123

110
```    int i;
```
124
```        int i, j;
```
111 125

112
```    /* Initialize all of these arrays */
```
113
```    for(i = 0; i<NUM_FEATURES; i++) {
```
114
```            seen[i] = 0;
```
115
```            seenout[i] = 0;
```
116
```            intersections[i].type = 0;
```
117
```            intersections[i].intNum = 0;
```
118
```            intersections[i].numOut = 0;
```
119
```            intersections[i].outSeen = 0;
```
120
```            intersections[i].outgoingEdges[0].to = 0;
```
121
```            intersections[i].outgoingEdges[0].dist = 0;
```
122
```            intersections[i].outgoingEdges[1].to = 0;
```
123
```            intersections[i].outgoingEdges[1].dist = 0;
```
124
```            intersections[i].outgoingEdges[2].to = 0;
```
125
```            intersections[i].outgoingEdges[2].dist = 0;
```
126
```            intersections[i].outgoingEdges[3].to = 0;
```
127
```            intersections[i].outgoingEdges[3].dist = 0;
```
128
```    }
```
126
```        /* Set all graph storge elements to 0 */
```
127
```        for(i = 0; i<NUM_FEATURES; i++) {
```
128
```                seen[i] = 0;
```
129
```                seenout[i] = 0;
```
130
```                intersections[i].type = 0;
```
131
```                intersections[i].intNum = 0;
```
132
```                intersections[i].numOut = 0;
```
133
```                intersections[i].outSeen = 0;
```
134
```                for(j = 0; j<4; j++){
```
135
```                        intersections[i].outgoingEdges[0].to = 0;
```
136
```                        intersections[i].outgoingEdges[0].dist = 0;
```
137
```                }
```
138
```        }
```
129 139
```}
```
130 140

131 141

132 142
```/* Given an intersection type, returns the number of outgoing edges */
```
133 143
```int getNumOut(int type) {
```
134
```    switch(type){
```
135
```        case 0: return 3;
```
136
```        case 1: return -1;
```
137
```        case 2: return -1;
```
138
```        case 3: return 3;
```
139
```        case 4: return 2;
```
140
```    }
```
141
```    return -1;
```
144
```        switch(type){
```
145
```                case 0: return 3;
```
146
```                case 1: return -1;
```
147
```                case 2: return -1;
```
148
```                case 3: return 3;
```
149
```                case 4: return 2;
```
150
```        }
```
151
```        return -1;
```
142 152
```}
```
143

144
```/*
```
145
``` * Drives to the next intersection and returns its ID
```
146
``` * If we are at a dead end, returns -1
```
147
``` */
```
148
```int nextInt(){
```
149
```        return 0;
```
150
```}
```
151

152

153
```/*
```
154
``` * Given an intersection node returns an integer that
```
155
``` * can be sent wirelessly
```
156
``` *
```
157
``` */
```
158
```int encodeNode(node n){
```
159
```        return 0;
```
160
```}
```
161

Also available in: Unified diff