==> Base.java <==
/**
 * TPS (Tiny Phone System) version.
 * 4/17/01
 *
 * @author RP Futrelle
 * @version 1.0
 */

public class Base {

    private Ether ether;

    public void setEther(Ether ether) {
	this.ether = ether;
    }

    public void step() {
	Sim.logStream.println("Base stepped");
    }

} // class Base

==> Ether.java <==
/**
 * TPS (Tiny Phone System) version.
 * 4/17/01
 *
 * @author RP Futrelle
 * @version 1.0
 */

public class Ether {

    static int numChannels = 6;
    private int i; // loop counter

    public Message FCC;
    public Message RCC;
    public Message[] FVC_channels;
    public Message[] RVC_channels;

    public Ether(){
	FVC_channels = new Message[numChannels];
	for(i = 0; i < numChannels; i++)
	    FVC_channels[i] = new Message();
	RVC_channels = new Message[numChannels];
	for(i = 0; i < numChannels; i++)
	    RVC_channels[i] = new Message();

    } // construct Ether

    public void clearForward() {
	FCC = null;
	for(i = 0; i < numChannels; i++)
	    FVC_channels[i] = null;
    } // clearForward()

    public void clearReverse() {
	RCC = null;
	for(i = 0; i < numChannels; i++)
	    RVC_channels[i] = null;
    } // clearForward()


} // class Ether

==> Message.java <==
/**
 * TPS (Tiny Phone System) version.
 * 4/17/01
 *
 * @author RP Futrelle
 * @version 1.0
 */

/**
 * Simple record type for now
 */

public class Message {

    public String string;
    public int num0, num1, num2;

    Message(String s, int n0, int n1, int n2) {
	string = s;
	num0 = n0;
	num1 = n1;
	num2 = n2;
    } // construct Message

    Message() {};

} // class Message     

==> Person.java <==
/**
 * TPS (Tiny Phone System) version.
 * 4/17/01
 *
 * @author RP Futrelle
 * @version 1.0
 */

public class Person {

    private boolean stateIsIdle;
    private boolean stateIsCalling;
    private int toCallCountdown;
    private int numberCalled;

    public Phone phone;

    Person() {
	stateIsIdle = true;
	toCallCountdown = Ran.randInRange(10,30);
    } // construct person

    public void step() {
	Sim.logStream.println("Person with phone " + phone.number + "  stepped");
	if(toCallCountdown-- == 0) {
	    toCallCountdown = -1; // clamp it here for now
	    stateIsIdle = false;
	    stateIsCalling = true;
	    // avoid calling self
	   for(;;) {
	       numberCalled = Ran.randInRange(1,3);
	       if(numberCalled != phone.number)
		   break;
	   } // for() to check number

	   phone.dial(numberCalled);

	} // if it's time to call
    } // step()


} // class Person

==> Phone.java <==
/**
 * TPS (Tiny Phone System) version.
 * 4/17/01
 *
 * @author RP Futrelle
 * @version 1.0
 */

import java.io.*;

public class Phone {

    public int number;
    private Ether ether;
    private int outCallNum;
    private Message messageIn;

    private int fvChannel, rvChannel;

    private boolean idle;
    private boolean tryCallOut;
    private boolean callOutRequested;
    private boolean connectionEstablished;

    Phone() {
	idle = true;
	tryCallOut = false;
	callOutRequested = false;
	callOutRequested = false;
	connectionEstablished = false;

    } // construct Phone

    public void setPhNumber(int number) {
	this.number = number;
    } // setPhNumber

    public int getPhNumber() {
	return number;
    } // getPhNumber
    
    public void setEther(Ether ether) {
	this.ether = ether;
    } // setEther

    public void dial(int outCallNum){
	this.outCallNum = outCallNum;
	tryCallOut = true;
    };

    public void step() {
	if(idle) {
	    messageIn = ether.FCC;
	    if(messageIn != null && 
	       messageIn.string =="page" 
	       && messageIn.num1 == number){
		Sim.logStream.println("Phone " + number + " caught page.");
	    }
	} // idle

	if(tryCallOut) {
	    if(ether.RCC == null) {
		ether.RCC = new Message("callrequest", number, outCallNum, -1);
		tryCallOut = false;
		callOutRequested = true;
	    }
	} // tryCallOut

	if(callOutRequested) {
	    messageIn = ether.FCC;
	    if(messageIn != null &&
	       messageIn.string =="connectionAvailable" && 
	       messageIn.num0 == number)
		{
		    fvChannel = messageIn.num1;
		    rvChannel = messageIn.num2;
		    connectionEstablished = true;
		    callOutRequested = false;
		} // getting voice channels

	} // call out requested
    } // step()	
	
} // class Phone

==> Ran.java <==
/**
 * TPS (Tiny Phone System) version.
 * 4/17/01
 *
 * @author RP Futrelle
 * @version 1.0
 */

import java.util.*;


/**
 * OVERVIEW: Furnishes static function for 
* random integers in range.
 */

public  class Ran {

    static Random ran = new Random();

    public static void main(String[] args) {

	int numSteps = 10;
	int lo = 3;
	int hi = 6;

	if (args.length > 0) {
	    try {
		numSteps = Integer.parseInt(args[0]);
		lo = Integer.parseInt(args[1]);
		hi = Integer.parseInt(args[2]);
	    }
	    catch (NumberFormatException e) {
		System.out.println("bad int arg " + e);
	    } 
	}

	for(int m = 0; m < numSteps ; m++) {
	    System.out.print(randInRange(lo, hi) + " ");
		}

    } // main()

    /**
     * Returns random number from low through hi - 1.
     */
    static int randInRange(int low, int hi) {
	return (ran.nextInt() % (hi - low) + (hi - low - 1))/2 + low;
    } // randInRange()

} // class Ran

==> Sim.java <==
/**
 * TPS (Tiny Phone System) version.
 * 4/17/01
 *
 * @author RP Futrelle
 * @version 1.0
 */

import java.io.*;

/**
 * OVERVIEW: Creates components and wires them together.
 */
public class Sim {

    static PrintWriter logStream;

    private static final int numUsers = 3;
    private static int numSteps = 10;
    private static int i;

    private static Base base;
    private static  Ether ether;
    private  static Phone[] phones;
    private  static Person[] persons;
    
    public static void main(String[] args){

	try{
	logStream = new PrintWriter(new FileWriter("log1txt"));
	}
	catch(IOException e) {
	    System.out.println("Can't create file log1.txt " + e);
	}

	base = new Base();
	ether = new Ether();
	phones = new Phone[numUsers];
	for(i = 0; i < numUsers; i++)
	    phones[i] = new Phone();
	persons = new Person[numUsers];
	for(i = 0; i < numUsers; i++)
	    persons[i] = new Person();

	if (args.length > 0) {
            try {
                numSteps = Integer.parseInt(args[0]);
            }
            catch (NumberFormatException e) {
                System.out.println("bad int arg " + e);
            }
        }

	// All the work is done here
	setup();
	simulate(numSteps);
	cleanup();

    } // main()
	
    private static void setup() {
	    for(int i = 0; i < numUsers; i++){
		phones[i].setPhNumber(i + 1);
		phones[i].setEther(ether);
		persons[i].phone = phones[i];
	    } // loop
	    base.setEther(ether);
	} // setup()

    private static void simulate (int numSteps) {
	for(int i = 0; i < numSteps; i++){
	    
	    for(int k = 0; k < numUsers; k++){
		phones[k].step();}
	    
	    ether.clearForward();

	    for(int k = 0; k < numUsers; k++){
		persons[k].step();}

	    base.step();

	    ether.clearReverse();
	
	} // main simulation loop
    } // simulate()

    private static void cleanup () {
	logStream.close();
	System.out.println("\nSimulation done!");
    } // cleanup()

} // class Sim

==> TRan.java <==
public class TRan {
	public static void main (String[] args) {
		System.out.println(Ran.randInRange(33,100));
	}		
}