I don't where do I start

Question

Concept
Construct a traffic flow simulator that models cars travelling down a laneway. You may create the simulator in several stages, each one more sophisticated than the previous. In the last stage, cars travel along the laneway at various speeds, without crashing into other cars. There is also a stoplight, which alternately stops traffic and lets traffic go.
Design Considerations
Architecture
We suggest that you use an architecture that has:
1.     A driver programmer (a JApplet running in an HTML page you create and submit). Let the driver programme create the instance of the traffic simulator and start the show. Keep the driver programme simple. (See Loftus and Lewis for many examples of this sort)
2.     The simulator classes, which include:
o     A class representing the traffic simulator itself (including the controls for starting the simulation, and testing for synchronization (see below))
o     A class representing the road (It keeps a list of the cars and where the cars are on the road)
o     A class representing a car. (You will need more than one instance of this class � one for each car that is running)
o     A class representing a stoplight (You only need one instance.)
Responsibilities
To make the simulation work, you will need to have cars that have a position on the road.
�     Each car (running on its own thread) will update its position according to its current speed. It is required that you use threads.
�     The road becomes the class that �collects� these cars. Therefore, it needs to create and keep a record of which instances of the car class exist.
�     The traffic simulator itself creates the road, and any needed controls.
�     The stoplight is like a car, except that it does not move (place it half way along the road), and it alternates every few seconds between �red� (when it is like a car on the road, and other cars cannot get past it) and �green� (when it is not blocking cars)
To display the road, you might have the road draw itself, and then call on each car to draw itself on the road.
Underlying Model
It is a good idea to have a data structure of some kind to represent the simulation. Do not count on the picture of the road to also be the underlying model, because the picture is a complex set of graphic coordinates (many of which will have to change when a car moves).
Instead, think more abstractly: a road is a set of positions, and a car has one of those positions. Therefore, the underlying model of the road might be:
�     An array, each element of the array representing a position on the road. The car's current position is represented by a reference to the car placed somewhere in the array (like markers moving in a Parcheesi or Monopoly game).
You may choose another model. Whatever model you choose, you will have a much easier time moving a car by changing its position in the underlying model, than by trying to change it directly on the graphic display.
Threads
Each car needs to run on its own thread. The simulator creates the instances of car, and starts its thread. The car (inside its run() method):
�     Sleeps for a while (the faster it is going, the less time it sleeps between moves)
�     Checks the road to see if can move forward.
�     Moves, if it won't crash into cars or stoplights, or else reduces its speed and sleeps some more...
Good practice: Inside the run() method, you need to have the above steps repeat over and over. Avoid using an infinite loop (e.g. while (true)) or even a loop based on a fixed number of iterations (e.g. for (... i<1000 ...) ) . Instead, have a boolean variable such as �go� and use:
while (go) { ... }
When �go� is true, the steps can repeat. When you are ready to stop the thread, you set �go� to false. Remember to stop your thread when the car comes to the end of the road.
Synchronization
You should implement synchronization, so that each car or stoplight gets to complete one attempt at changing the state of the road without being interrupted by another car or stoplight.
Testing Synchronization
To help us test your implementation of synchronization, add a �testsync� parameter to your HTML file and to your JApplet, which you should �get� in the init() method. If it is not present, the road behaves normally, but if it is present, the change() method of the road should sleep for 2 seconds before returning. Adding the delay means that you should be able to �see� the synchronization in action: the cars will pause, too!
Start and End of Road
You can make cars appear at the start of the road by having the simulator wait a random amount of time, and then create a new instance of car. When cars get to the end of the road, you can let them �disappear�. Alternatively, you can make your road circular, i.e., have the end of the road feed cars into the beginning again. It is easy to make the road circular: just make sure that in the underlying model of the road, the next element after the final one is the first element again. The use of modular arithmetic
(index++)% myArray.length;
can make this easy. (Of course, if your road is circular, you may have to rethink how cars start ...)
Graphic display
Once you have an underlying model, and the cars move along the road on the underlying model, then it is easy to draw a picture of the road with the cars on it in their current position.
Some hints:
�     Draw the track on a JPanel that is just for the road, the stoplight and the cars. Keep any other displays in other places.
�     Use the repaint() method of JPanel to redraw it, invoking super.paint(g); as the first statement of the paint() method. (It is also possible to create your own draw methods() instead.)
�     The road can be drawn as a long rectangle going horizontally across the JPanel.
�     It is sufficient to make a rectangle to represent a top-down view of a car. To get fancier:
o     Draw a rectangle of car colour
o     Put a black edge around it
o     Put a smaller black edge in the centre of it (for the top)
o     Put the car number on the top of the car.

Answer 1

                     CAR1                    CAR2                     STOP
                      |                       |                         |
                      |                       |                         |
                      |                       |                         v
                      |                       |                      ======
                      |                       |                    \ |    |
                      |           BOOM        |                    -(|    |
                      |             |         |                     (|    |
                      v             |         v                     (|    |
                                    v                                |____|
                     ________      .  * .   ______                     ||
                    /    |   \      * .  * /   |  \                    ||
              _____/_____|____\___/\/\/\/|/____|___\_____o             ||
        o     |   __              __ |  __           __  |             ||
     .     o (|__/  \____________/  #|_/  \_________/  \_|)            ||
    O  .  o  ==  \__/            \__%  *__/         \__/               ||