Hello all,

I have been messing around with the idea of way-points to be implemented into a game at a later date. I have almost all of the code working but am running to some crashes that I am not sure how to fix.The board is held in a 2D array of tiles, each of which can be clicked on. Clicking on one will save a waypoint in a linkedlist. The seeker (little ball) will move from it's current position to the next waypoint, then keep finding waypoints until it is at the end of the waypoint list. 
My problem is that after the first cycle of waypoints, the program crashes with an index out of bounds error. It works for any number of waypoints, but once it reaches the final one, I get an error. I am not sure how to go about fixing this. If anyone could help me find it or suggest a better way to go about this (or both) I'd be very thankful.

1. import java.util.*;
2.  
3. TileMap tilemap;
4. Seeker seeker;
5. void setup() {
6.   size(400,400);
7.   tilemap = new TileMap();
8.   seeker = new Seeker(0,0,20);
9. }
10.  
11. void draw() {
12.   ellipseMode(CORNER);
13.   tilemap.display();
14.   tilemap.mouseOver();
15.   tilemap.findNextWaypoint(seeker);
16.   tilemap.clearWaypointList(seeker);
17.   seeker.display();
18.   seeker.moveToWaypoint(tilemap.nextWaypoint);
19. }
20.  
21. class Seeker {
22.  
23.   int x;
24.   int y;
25.   int r;
26.   boolean reachedWaypoint;
27.  
28.   Seeker(int x_, int y_, int r_) {
29.     x = x_;
30.     y = y_;
31.     r = r_;
32.     reachedWaypoint = false;
33.   }
34.  
35.   void display() {
36.     fill(0,255,0);
37.     ellipse(x,y,r,r);
38.   }
39.  
40.   void moveToWaypoint(Waypoint waypoint) {
41.     if(waypoint != null) {
42.       if(dist(x,y,waypoint.getX(), waypoint.getY()) < 1) {
43.         reachedWaypoint = true;
44.       }
45.       if(x < waypoint.getX()) {
46.         x = x + 1;
47.       }
48.       if(x > waypoint.getX()) {
49.         x = x - 1;
50.       }
51.       if(y > waypoint.getY()) {
52.         y = y - 1;
53.       }
54.       if(y < waypoint.getY()) {
55.         y = y + 1;
56.       }
57.     }
58.   }
59.  
60.   void setReachedWaypoint() {
61.     reachedWaypoint = false;
62.   }
63.  
64.   boolean reachedWaypoint() {
65.     if(reachedWaypoint) {
66.       return true;
67.     }
68.     else {
69.       return false;
70.     }
71.   }
72.  
73.  
74.   int getX() {
75.     return x;
76.   }
77.  
78.   int getY() {
79.     return y;
80.   }
81.  
82.   int getR() {
83.     return r;
84.   }
85. }
86. class Tile {
87.  
88.   int x;
89.   int y;
90.   int w;
91.   int h;
92.   int type;
93.   boolean clicked;
94.  
95.   Tile(int x_, int y_,int w_, int h_) {
96.     x = x_;
97.     y = y_;
98.     w = w_;
99.     h = h_;
100.     type = 0;
101.     clicked = false;
102.   }
103.  
104.   void display() {
105.     fill(0,0,255);
106.     rect(x,y,w,h);
107.   }
108.  
109.   int getX() {
110.     return x;
111.   }
112.  
113.   int getY() {
114.     return y;
115.   }
116.  
117.   int getW(){
118.     return w;
119.   }
120.  
121.   int getH(){
122.     return h;
123.   }
124. }
125. class TileMap {
126.   public Waypoint currentWaypoint = null;
127.   public Waypoint nextWaypoint = null;
128.   public LinkedList waypointList = new LinkedList();
129.   public final int WIDTH = 20;
130.   public final int HEIGHT = 20;
131.  
132.   boolean clicked;
133.   int waypointState;
134.  
135.   public Tile[][] tiles;
136.   public int[][] terrain = new int[WIDTH][HEIGHT];
137.   public boolean[][] visited = new boolean[WIDTH][HEIGHT];
138.  
139.   TileMap() {
140.     clicked = false;
141.     waypointState = 0;
142.   
143.     tiles = new Tile[WIDTH][HEIGHT];
144.     for(int i = 0; i < WIDTH; i++) {
145.       for(int k = 0; k < HEIGHT; k++) {
146.         tiles[i][k] = new Tile(i*20, k*20, 20, 20);
147.       }
148.     }
149.     currentWaypoint = new Waypoint(0,0,tiles[0][0]);
150.   }
151.  
152.   void display() {
153.     for(int i = 0; i < WIDTH; i++) {
154.       for(int k = 0; k < HEIGHT; k++) {
155.         tiles[i][k].display();
156.       }
157.     }
158.   }
159.  
160.   void mouseOver() {
161.     if(!mousePressed) {
162.       clicked = false;
163.     }
164.     for(int i = 0; i < WIDTH; i++) {
165.       for(int k = 0; k < HEIGHT; k++) {
166.         if(mousePressed && clicked == false) {
167.           if(mouseX > tiles[i][k].getX() && mouseX < tiles[i][k].getX() + tiles[i][k].getW() &&
168.             mouseY > tiles[i][k].getY() && mouseY < tiles[i][k].getY() + tiles[i][k].getH()) {
169.             clicked = true;
170.             addWaypoint(tiles[i][k]);
171.           }
172.         }
173.       }
174.     }
175.   }
176.  
177.   void addWaypoint(Tile tile) {
178.     Waypoint way_pnt = new Waypoint(tile.getX(), tile.getY(), tile);
179.     waypointList.addLast(way_pnt);
180.   }
181.  
182.   void findNextWaypoint(Seeker seeker) {
183.       if(waypointList.size() == 1) {
184.         nextWaypoint = (Waypoint)waypointList.getFirst();
185.       }
186.       if(seeker.reachedWaypoint()) {
187.         currentWaypoint = nextWaypoint;
188.         waypointState = waypointState + 1;
189.         println("waypoint State: " + waypointState);
190.         if(waypointState <= waypointList.size()){
191.         nextWaypoint = (Waypoint)waypointList.get(waypointState);
192.         seeker.setReachedWaypoint();
193.         }
194.     }
195.   }
196.  
197.   void clearWaypointList(Seeker seeker) {
198.     if(waypointList.isEmpty() == false) {
199.       if(seeker.reachedWaypoint() && nextWaypoint.equals((Waypoint)waypointList.getLast())) {
200.         waypointList.clear();
201.         waypointState = 0;
202.       }
203.     }
204.   }
205.  
206.   int getWaypointListSize() {
207.     return waypointList.size();
208.   }
209. }
210. class Waypoint{
211.  
212.   int x;
213.   int y;
214.  
215.   Waypoint(int tempX, int tempY,Tile tile){
216.     x = tempX;
217.     y = tempY;
218.   }
219.  
220.   int getX(){
221.     return x;
222.   }
223.  
224.   int getY(){
225.     return y;
226.   }
227.  
228. }