Hi!
I'm a newbie in drawing graphics with Java and have another problem with my traffic Jam simulation:
At the end of the simulation the program should draw the finalA array as a series of filled/unfilled squares. All I get is a white window coming up:@
I will post all my code so that you can try to compile it and see what it does. The issue with the do-while loops hadn't been yet quite resolved but the program creates the road in most cases.
And if someone is really good, would you have an idea how to animate the drawing so that for each t in flowSimuator method a new array with the filled/unfilled squares would be redrawn, say every 3s....
If anyone can help me I'll be very grateful as I spent so much time on this program, got stuck at this point and don't know what to do now:'(
Here are my classes:
1. Road. java
class Road {
private int n;
private int c;
private int road[];
private int allocated;
private int assigned;
/// constructor for road taking length and number of cars putting them down randomly
public Road(int n, int c){
this.road = new int[n];
/// if c>(n/2) then allocate 0s, if c<=n/2 allocate 1s
if(c < (n/2)){
/// do{
int allocated = 0;
for(int i = 0; ((allocated < c) && (i < n)); i++){
this.road[i]=binaryGenerator();
if(this.road[i]==1) {
allocated = allocated +1;
}
}
/// System.out.println("T "+ allocated +" " + c);
/// }
/// while(allocated < c);
}
if(c >= (n/2)){
/// do{
int assigned = 0;
for(int i = 0; ((assigned < (n-c)) && (i < n)); i++){
this.road[i]=binaryGenerator();
if(this.road[i] == 0) {
assigned = assigned +1;
}
}
/// }
/// while(assigned < (n - c));
}
}
/// constructor for road out of array
public Road(int[] ROAD){
int road[] = new int[ROAD.length];
for(int i=0; i < ROAD.length; i++){
this.road[i] = ROAD[i];
}
}
/// method to return 0 or 1 randomly
private int binaryGenerator(){
double y = Math.floor(Math.random()*2);
int x = (int)y;
return x;
}
/// getter method for array
public int[] Array(){
return this.road;
}
public static int[] flowSimulator(Road A, int time, int c){
int road[] = new int[A.Array().length];
road = A.Array();
int totalmoved = 0;
double avVel = 0;
/// time - set number of iterations
for(int t = 1; t < time + 1; t++){
int movedcars = 0;
/// checking from end: if car can move forward using modulo for each space,if a car can move change its value to 2 but don't move it
for(int i=0, j = road.length-1; i < road.length; i++, j--){
if(road[j] == 1){
if(road[(j+1) % road.length] == 0){
road[j] = 2;
movedcars = movedcars +1;
}
else {
road[j]=1;
}
}
}
totalmoved = totalmoved + movedcars;
double speed = 0;
speed = (double)movedcars/(double)c;
System.out.println("Speed for time " + t+" is "+ speed);
/// now move the cars to the final positions after the iteration
for(int i=0; i < road.length; i++){
if(road[i] == 2){
road[i] = 0;
road[(i+1) % road.length] = 1;
}
}
}
/// calculate average velocity
avVel = (double)totalmoved/(double)(time*c);
System.out.println("The averege velocity of cars in this time interval was " + avVel);
return road;
}
}And TrafficFlow.java
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.io.*;
class RoadPanel extends JPanel {
private int W;
private int H;
private int road[];
/// creator for Road panel
public RoadPanel(int W, int H, int[] A) {
this.W = W;
this.H = H;
setBackground(Color.white);
this.road = A;
}
/// override paint component to create road
public void paintComponent(Graphics a,Graphics g){
/// colour background white
g.setColor(Color.white);
super.paintComponent(g);
g.setColor(Color.black);
a.setColor(Color.yellow);
/// middle of car in the middle of the road. Car - square 20x20 pixels. Filled cars will be yellow, empty spaces black border
int x,y,w,h;
w = 20;
h = 20;
y = ((H - h)/2);
for(int i = 0; i < road.length; i++){
x = i * w;
if( road[i] == 0){
g.drawRect(x,y,w,h);
}
if( road[i] == 1){
a.fillRect(x,y,w,h);
}
}
}
}
class RoadFrame extends JFrame {
static final int W = 800;
static final int H = 120;
public RoadFrame(int[] A) {
setTitle("Traffic at end at end of time");
/// add panel to frame
RoadPanel street = new RoadPanel(W,H,A);
getContentPane().add(street);
addWindowListener(new WindowAdapter() {
/// Window closing option
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
///size of frame
setSize(W,H);
}
}
/// MAIN program start
class TrafficFlow {
static BufferedReader keyboard = new BufferedReader(new InputStreamReader (System.in));
public static void main (String argv[]) throws IOException {
/// try-catch block to handle exceptions
try{
System.out.println("Input length of road between 1 to 60");
double n = new Double(keyboard.readLine()).doubleValue();
if((n < 1) || (n > 60)){
System.out.println("Invalid imput, simulation terminated");
System.exit(1);
}
System.out.println("Input density of traffic from 0 to 1");
double density = new Double(keyboard.readLine()).doubleValue();
if((density < 0) || (density > 1)){
System.out.println("Invalid imput, simulation terminated");
System.exit(1);
}
double c = n*density;
System.out.println("Input the time of simulation");
int time = new Integer(keyboard.readLine()).intValue();
if(time < 1){
System.out.println("Invalid imput, simulation terminated");
System.exit(1);
}
Road cramped = new Road((int)n,(int)c);
int cram[] = cramped.Array();
// perform simulation
int finalA[] = new int[cram.length];
finalA = Road.flowSimulator(cramped, time,(int)c);
//Road Final = new Road(final)
RoadFrame F = new RoadFrame(finalA);
F.setVisible(true);
}
catch (Exception ex)
{
System.out.println("You typed some invalid input.");
}
}
}