Random Walk/임인택

~cpp 

import java.util.Random;

public class Roach{
    int dir_x[]={-1,0,1,1,1,0,-1,-1};
    int dir_y[]={1,1,1,0,-1,-1,-1,0};
    Board _board;
    boolean bOnTrip;
    Random rand;

    public Roach() {
        bOnTrip = true;
        rand = new Random();
    }

    public void move() {
        int randNum;

        while( bOnTrip ) {
            randNum = rand.nextInt()%dir_x.length;
            try {
                _board.walkOn(dir_x[randNum], dir_y[randNum]);
            }  catch (ArrayIndexOutOfBoundsException e) {
                //System.err.println(e);
                drink();
            }
        }
    }

    public void finishJourney() {
        bOnTrip = false;
    }

    public void drink() {
        System.out.println("toast~!");
    }

    public void putOnTheBoard(Board board) {
        _board = board;
    }
}
 

~cpp 

public class Board {
    int _board[][];
    int sizeX, sizeY;
    int roaX, roaY; // watch position of the roach
                              // because the roach doesn't know his position
    int visitedPlace = 1;
    Roach _roach;

    public Board(int x, int y) {
        sizeX = x;
        sizeY = y;
        roaX = roaY = 0;
        _board = new int[sizeX][sizeY];
    }

    public void walkOn(int x, int y) {
        System.out.println("바퀴위치 : " + (roaX+x) + ", " + (roaY+y));

        if ( _board[roaX+x][roaY+y] == 0 )
            visitedPlace++;

        roaX += x;
        roaY += y;

        System.out.println("바퀴위치 : " + roaX + ", " + roaY);

        _board[roaX][roaY]++;

        if( visitedPlace == sizeX*sizeY ) {
            _roach.finishJourney();
            printOutBoard();
        }

    }

    public void putRoachOn(Roach roach) {
        _roach = roach;
    }

    public void printOutBoard() {
        for(int i=0; i<sizeX; i++) {
            for(int j=0; j<sizeY; j++) {
                System.out.print(_board[i][j] + "\t");
            }
            System.out.println();
        }
    }
}
 

~cpp 

public class RandomWalk {

    public static void main(String[] args){
        Roach myRoach = new Roach();
        Board myBoard = new Board(8,8);

        myRoach.putOnTheBoard(myBoard);
        myBoard.putRoachOn(myRoach);

        myRoach.move();
    }
}

 

~cpp 

/**
 * Created by IntelliJ IDEA.
 * Author: Intaek Lim
 * Date: 2003. 6. 7.
 * Time: 오후 10:29:36
 */

import java.net.*;
import java.io.*;
import java.util.Random;

// operates just like 'token ring'
public class Cell  implements Runnable {
    private String _nextHostName, _localHostName;
    private int _hostIndex, _nextHostIndex;
    private int _numOfVisited;
    private int _xSize, _ySize;
    private int _adjacentCellIdx[];
    private ServerSocket _serverSock;
    private Socket _nextSock;
    private final int _defaultPort = 38317;
    private boolean _bEndCondition;

    public Cell(int localHostNum, int hostIndex, String nextHostName, int nextHostNum) {
        _hostIndex = localHostNum;
        _hostIndex = hostIndex;
        _bEndCondition = false;

        try {
            _serverSock = new ServerSocket(_defaultPort);
        } catch(IOException e) {
            System.err.println(e);
        }
    }

    public void setXY(int x, int y) {
        _xSize = x;
        _ySize = y;
    }

    public void setAdjacentCells(String adjIdx) {
        // parse adjacent cell info
        String adjHostIdxes[] = adjIdx.split(" ");
        _adjacentCellIdx = new int[adjHostIdxes.length];

        for(int i=0; i<_adjacentCellIdx.length; i++)
            _adjacentCellIdx[i] = Integer.parseInt(adjHostIdxes[i]);
    }

    public void connect() {
        try {
            _nextSock = new Socket(getNextHostName(), _defaultPort);
        } catch(IOException e) {
            System.err.println(e);
        }
    }

    // accept after connection was estabilished to previous host.
    public void acceptConnection() {
        try {
            _nextSock = _serverSock.accept();
        } catch(IOException e) {
            System.err.println(e);
        }
    }

    public String getNextHostName() {
        return _nextHostName;
    }

    public String getHostName() {
        return _localHostName;
    }

    public int getHostIndex() {
        return _hostIndex;
    }

    public void run() {
        try {
            ObjectInputStream in
                    = new ObjectInputStream(_nextSock.getInputStream());
            while( !_bEndCondition ) {
                Object obj = in.readObject();
                parseMessage((Message)obj);
            }
        }  catch(IOException e) {
            System.err.println(e);
        } catch(ClassNotFoundException e) {
            System.err.println(e);
        }
    }

    public void parseMessage(Message msg) {
        // if the roach visited all cells..
        if( msg.checkEndCondition(getHostIndex()) ) {
            processFinishing(msg);
        }
        else if( msg.killMessage) { // if the cell received kill message
            killClients(msg);
        } else {  // when the roach is on walking~~~
            if( msg.targetHostNum == getHostIndex() ) {
                transmitRoach(msg);
            }
            relay(msg);
        }
    }

    public void relay(Message msg) {
        try {
            ObjectOutputStream out
                    = new ObjectOutputStream(_nextSock.getOutputStream());
            out.writeObject(msg);
        } catch(IOException e) {
            System.err.println(e);
        }
    }

    public void showEndStatus() {
        System.out.println("Random walk finished.");
        System.out.println("There are" + _numOfVisited + " arrivals");
    }

    public void processFinishing(Message msg) {
        // if here is the starting point, then send kill signal to others.
        if( getHostIndex()==0 ) {
            msg.killMessage = true;
            relay(msg);
        }  else { // else, relay to the first point.
            relay(msg);
        }
    }

    public void killClients(Message msg) {
        // if this is not the last point relay to the last point
        if( _nextHostIndex<getHostIndex() ) {
            relay(msg);
        } else {
            showEndStatus();
        }
    }

    public void transmitRoach(Message msg) {
        if( _numOfVisited==0 ) {
            msg.numOfRemainCell--;
        }

        int nextIdx = new Random().nextInt() % _adjacentCellIdx.length;

        msg.sourceHostNum = getHostIndex();
        msg.targetHostNum = nextIdx;

        relay(msg);
    }
}
 

~cpp 

/**
 * Created by IntelliJ IDEA.
 * Author: Intaek Lim
 * Date: 2003. 6. 7.
 * Time: 오후 10:58:58
 */
public class Message {
    public int targetHostNum;
    public int sourceHostNum;
    public int numOfRemainCell;
    public boolean killMessage;

    public boolean checkEndCondition(int cellIdx) {
        return (numOfRemainCell==0);
    }
}

 

~cpp 

/**
 * Created by IntelliJ IDEA.
 * Author: Intaek Lim
 * Date: 2003. 6. 8.
 * Time: 오후 4:7:20
 */
public class RandomWalk {
    public static void main(String args[]) {
        // localhostname, localHostNum, nextHostName, nextHostNum
        // sizeX, sizeY, cellInfo
        String localHostName =args[0];
        int localNum = Integer.parseInt(args[1]);
        String nextHostName = args[2];
        int nextHostNum = Integer.parseInt(args[3]);
        int xSize = Integer.parseInt(args[4]);
        int ySize = Integer.parseInt(args[5]);

        String adjInfo = "";
        for(int i=6; i<args.length; i++) {
            adjInfo += args[i] + " ";
        }

        System.out.println(adjInfo);
    }
}