Colony

/*

        BotGraph.java

        Colony Project

        Gregory Tress

*/

import javax.swing.*;

import java.awt.*;

import java.awt.image.*;

import java.awt.event.*;

import java.net.*;

import java.io.*;

import java.util.Random;

public class BotGraph extends JApplet implements ActionListener, MouseListener, Runnable

{

        final int CANVAS_SIZE = 550;  //don't make this too large, or the applet will be slow.

        final int BUFFER = 50;

        final int RADIUS = 30;

        JTextField txtHost;

        JTextField txtPort;

        JButton btnConnect;

        JButton btnGraph;

        JButton btnRandomize;

        JLabel lblNumRobots;

        JLabel lblHasToken;

        JLabel lblTokenPasses;

        JLabel lblConnectionStatus;

        JTextArea txtInput;  //sample matrix is entered in this area

        JTextArea txtInfo;

        JPanel panel;

        JPanel panelConnect;

        JPanel panelControl;

        JPanel panelStats;

        GraphicsConfiguration gc;

        volatile BufferedImage image;

        volatile Graphics2D canvas;

        int cx, cy;

        Socket socket;

        OutputStreamWriter out;                        //TODO: add a BufferedWriter

        DataListener datalistener;

        Font botFont;

        Random random = new Random();

        volatile int tokenLoc;  //the token is currently here

        volatile int numBots;

        volatile int selectedBot;  //the user has selected this bot

        volatile Rectangle[] botRect;  //contains boundary shapes around bots for click detection

        Thread drawThread;

        SelectionIndicator indicator;

        Simulator simulator;

        PacketMonitor packetMonitor;

        public void init ()

        {

                // We should invoke and wait to avoid browser display difficulties

                Runnable r = new Runnable() {

                        public void run() {

                                createAndShowGUI();

                        }

                };

                try {

                        SwingUtilities.invokeAndWait(r);

                } catch (InterruptedException e) {

                        //Not really sure why we would be in this situation

                        System.out.println(e);

                } catch (java.lang.reflect.InvocationTargetException e) {

                        //This should never happen. Seriously.

                        System.out.println(e);

                }

        }

        public void destroy ()

        {

                drawThread.interrupt();

                indicator.interrupt();

                simulator.interrupt();

                packetMonitor.interrupt();

        }

        private synchronized void createAndShowGUI ()

        {

                // init graphical elements

                panel = new JPanel(false);  //set automatic double-buffering to false. we are doing it manually.

                // Set up connection area

                txtHost = new JTextField("roboclub1.frc.ri.cmu.edu");

                txtPort = new JTextField("10123");

                btnConnect = new JButton("Connect");

                lblConnectionStatus = new JLabel("Status: Offline");

                panelConnect = new JPanel();

                panelConnect.setLayout(new GridLayout(2,3));

                panelConnect.add(new JLabel("Host"));

                panelConnect.add(new JLabel("Port"));

                panelConnect.add(lblConnectionStatus);

                panelConnect.add(txtHost);

                panelConnect.add(txtPort);

                panelConnect.add(btnConnect);

                panelConnect.setBorder(BorderFactory.createTitledBorder("Connection"));

                // Set up elements in the east

                panelControl = new JPanel();

                panelControl.setLayout(new GridLayout(5,1));

                lblNumRobots = new JLabel();

                lblHasToken = new JLabel();

                lblTokenPasses = new JLabel();

                panelStats = new JPanel();

                panelStats.setLayout(new GridLayout(3,2));

                panelStats.add(new JLabel("Number of Bots  "));

                panelStats.add(lblNumRobots);

                panelStats.add(new JLabel("Token At  "));

                panelStats.add(lblHasToken);

                panelStats.add(new JLabel("Token Passes / sec     "));

                panelStats.add(lblTokenPasses);

                txtInput = new JTextArea("- 9 3 - 1\n- - - 5 -\n4 - - - 2\n- - - - -\n1 - - 3 -");

                txtInput.setBorder(BorderFactory.createTitledBorder("Input Matrix"));

                txtInfo = new JTextArea();

                txtInfo.setBorder(BorderFactory.createTitledBorder("Info"));

                txtInfo.setEditable(false);

                btnGraph = new JButton("Run");

                btnRandomize = new JButton("Randomize");

                panelControl.add(panelStats);

                panelControl.add(txtInput);

                panelControl.add(txtInfo);

                panelControl.add(btnRandomize);

                panelControl.add(btnGraph);

                this.getContentPane().setLayout(new BorderLayout());

                this.getContentPane().add(panelConnect, BorderLayout.NORTH);

                this.getContentPane().add(panelControl, BorderLayout.EAST);

                this.getContentPane().add(panel, BorderLayout.CENTER);

                this.setVisible(true);

                btnGraph.addActionListener(this);

                btnRandomize.addActionListener(this);

                btnConnect.addActionListener(this);

                panel.addMouseListener(this);

                // Get the graphics configuration of the screen to create a buffer

                gc = GraphicsEnvironment.getLocalGraphicsEnvironment()

                        .getDefaultScreenDevice().getDefaultConfiguration();

                image = gc.createCompatibleImage(CANVAS_SIZE,CANVAS_SIZE);

                canvas = image.createGraphics();

                canvas.setStroke(new BasicStroke(2));  //set pen width

                // Calculate center of canvas

                cx = image.getWidth() / 2;

                cy = image.getHeight() / 2;

                botFont = new Font("Arial", Font.PLAIN, 30);

                tokenLoc = 0;

                numBots = 0;

                selectedBot = 0;

                // Set up dependent threads

                indicator = new SelectionIndicator(canvas);

                indicator.setRadius(RADIUS+3, 15);  //a tad more than the bot radius

                simulator = new Simulator();

                packetMonitor = new PacketMonitor();

                datalistener = new DataListener();

        }

        public synchronized void paint (Graphics g)

        {

                /*        First, redraw the graphical components in the applet.

                        This paint method overrides the built-in paint of the

                        JApplet, and we don't want to deal with redrawing the

                        components manually. Fuck that shit. */

                super.paint(g);

                // Place the buffered image on the screen, inside the panel

                panel.getGraphics().drawImage(image, 0, 0, Color.WHITE, this);

        }

        public synchronized void update (Graphics g)

        {

                paint(g);

        }

        public void actionPerformed (ActionEvent e)

        {

                Object source = e.getSource();

                if (source == btnGraph)

                {

                        btnGraph.setEnabled(false);

                        lblConnectionStatus.setText("Status: Simulation mode => running");

                        //Start dependent threads

                        drawThread = new Thread(this, "drawThread");

                        drawThread.start();

                        indicator.start();

                        simulator.start();

                        packetMonitor.start();

                }

                else if (source == btnConnect)

                {

                        doSocket();

                }

                else if (source == btnRandomize)

                {

                        randomize();

                }

        }

        private void randomize ()

        {

                Random r = new Random();

                StringBuilder s = new StringBuilder();

                int count = r.nextInt(8) + 1;

                for (int i = 0; i < count; i++)

                {

                        for (int j = 0; j < count; j++)

                        {

                                if (r.nextBoolean())

                                        s.append("" + (r.nextInt(16) + 1));

                                else

                                        s.append("-");

                                if (j != count-1)

                                        s.append(" ");

                        }

                        if (i != count-1) s.append("\n");

                }

                txtInput.setText(s.toString());

        }

        private void doSocket ()

        {

                //make sure hostname and port are valid

                if (txtHost.getText().equals("") || txtPort.getText().equals("")) {

                        err("Please enter a hostname and port.");

                        return;

                }

                int port = 0;

                try {

                        port = Integer.parseInt(txtPort.getText());

                } catch (Exception e) {

                        err("Invalid port");

                        return;

                }

                //make sure we aren't already connected. if so, disconnect first.

                if (socket != null && socket.isConnected()) {

                        try {

                                out.close();

                                socket.close();

                        } catch (IOException e) {}

                }

                try {

                        socket = new Socket(txtHost.getText(), port);

                } catch (UnknownHostException e) {

                        err("Unknown Host Exception");

                        return;

                } catch (IOException e) {

                        err("IO Exception\n\n" + e);

                        return;

                } catch (java.security.AccessControlException e) {

                        err("Permission denied by java.security.AccessControlException.\n\nYou may only connect to the server from which this applet was loaded.");

                        return;

                }

                if (socket == null || !socket.isConnected()) {

                        err("Connection failed. Try connecting again.");

                        return;

                }

                msg("Connected to " + txtHost.getText() + " on port " + port + "\n");

                lblConnectionStatus.setText("Status: ONLINE");

                try {

                        out = new OutputStreamWriter(socket.getOutputStream());

                } catch (IOException e) {

                        warn("Could not get OutputStream from socket connection.");

                }

        }

        public void drawRobot (int id, int x, int y)

        {

                //save the bot in memory, so we can tell if we click on it later

                botRect[id] = new Rectangle(x-RADIUS, y-RADIUS, 2*RADIUS, 2*RADIUS);

                //draw the bot on the canvas

                canvas.setColor(Color.BLACK);

                canvas.drawOval(x-RADIUS, y-RADIUS, RADIUS*2, RADIUS*2);

                //draw the label

                canvas.setFont(botFont);

                canvas.drawString("" + id, x-10, y+10);

        }

        public void drawConnection (int start, int end, int radius, Color color)

        {

                final int ARROW_LENGTH = 18;

                double angle = 2.0 * Math.PI / numBots;

                int startx, starty, endx, endy;

                startx = cx - (int)(radius * Math.cos(start * angle));

                starty = cy - (int)(radius * Math.sin(start * angle));

                endx = cx - (int)(radius * Math.cos(end * angle));

                endy = cy - (int)(radius * Math.sin(end * angle));

                canvas.setColor(color);

                canvas.drawLine(startx, starty, endx, endy);

                //create arrow

                if (color.equals(Color.BLACK)) return;

                int big_dy = starty - endy;

                int big_dx = endx - startx;

                double theta = 0;

                if (big_dx == 0 && starty > endy) //pointing up

                        theta = Math.PI/2;

                else if (big_dx == 0 && starty < endy) //pointing down

                        theta = 3*Math.PI/2;

                else if (big_dy == 0 && startx > endx) //pointing left

                        theta = Math.PI;

                else if (big_dy == 0 && startx < endx) //pointing right

                        theta = 0;

                else

                        theta = Math.atan(1.0 * big_dy / big_dx);

                //create ploygon

                Polygon poly = new Polygon();

                int dx_arrow = Math.abs((int)(ARROW_LENGTH * Math.cos(theta)));

                int dy_arrow = Math.abs((int)(ARROW_LENGTH * Math.sin(theta)));

                int dy_half = (int)(ARROW_LENGTH/2 * Math.cos(theta));

                int dx_half = (int)(ARROW_LENGTH/2 * Math.sin(theta));

                int rx = (big_dx > 0) ? endx - dx_arrow : endx + dx_arrow;

                int ry = (big_dy > 0) ? endy + dy_arrow : endy - dy_arrow;

                //System.out.println("" + start + "->" + end + " : dx=" + big_dx + ",dy=" + big_dy + ",dy_arrow=" + dy_arrow + ",dx_arrow=" + dx_arrow + ",theta=" + theta + ",endx=" + endx + ",endy=" + endy + ",rx=" + rx + ",ry=" + ry);

                poly.addPoint(endx, endy);

                poly.addPoint(rx - dx_half, ry - dy_half);

                poly.addPoint(rx + dx_half, ry + dy_half);

                canvas.fillPolygon(poly);

        }

        public void run ()

        {

                while (true)

                {

                        step();

                        repaint();

                        try { Thread.sleep(90); }

                                catch (InterruptedException e) { return; }

                }

        }

        public void step ()

        {

                final int DIAMETER = image.getWidth() - 2*BUFFER;

                final int BIGRADIUS = DIAMETER / 2;

                final int TOKENRADIUS = 40;

                boolean valid;

                // clear image

                canvas.setColor(Color.WHITE);

                canvas.fillRect(0, 0, image.getWidth(), image.getHeight());

                // parse the matrix, to see what robots exist

                String [] rows = txtInput.getText().split("\n");

                numBots = rows.length;

                String [][] entries = new String[numBots][numBots];

                valid = true;

                for (int i = 0; i < numBots; i++)

                {

                        entries[i] = rows[i].split(" ");

                        if (entries[i].length != rows.length) valid = false;

                }

                if (valid)

                {

                        lblNumRobots.setText("" + numBots);

                        lblHasToken.setText("" + tokenLoc);

                        this.showStatus("Matrix OK");

                        // draw outer ring

                        //canvas.setColor(Color.GREEN);

                        //canvas.drawOval(BUFFER, BUFFER, DIAMETER, DIAMETER);

                        // draw robots and find which one is seleced

                        double angle = 2.0 * Math.PI / numBots;

                        canvas.setColor(Color.BLACK);

                        botRect = new Rectangle[numBots];

                        int x, y;

                        if (selectedBot >= numBots) selectedBot = 0;

                        for (int i = 0; i < numBots; i++)

                        {

                                x = cx - (int)(BIGRADIUS * Math.cos(i * angle));

                                y = cy - (int)(BIGRADIUS * Math.sin(i * angle));

                                drawRobot(i, x, y);

                                if (i == selectedBot) indicator.setCenter(x, y);

                        }

                        // draw token marker

                        int tokenx, tokeny;

                        int tokenNum = tokenLoc;

                        tokenx = cx - (int)(BIGRADIUS * Math.cos(tokenNum * angle));

                        tokeny = cy - (int)(BIGRADIUS * Math.sin(tokenNum * angle));

                        canvas.setColor(Color.RED);

                        canvas.drawOval(tokenx-TOKENRADIUS, tokeny-TOKENRADIUS, 2*TOKENRADIUS, 2*TOKENRADIUS);

                        // create an inner circle along which the connections are made.

                        // let the diameter of this circle be 2*RADIUS less than the outerDiameter.

                        // see what connections exist

                        for (int row = 0; row < numBots; row++)

                        {

                                for(int col = 0; col < numBots; col++)

                                {

                                        if (! entries[row][col].equals("-") && entries[col][row].equals("-") && row != col) //one-way

                                        {

                                                //drawConnection(row, col, BIGRADIUS-RADIUS, Color.GRAY);

                                                drawConnection(row, col, BIGRADIUS-RADIUS, new Color(200,200,200));

                                        }

                                        else if (! entries[row][col].equals("-") && ! entries[col][row].equals("-") && row != col) //two-way

                                        {

                                                drawConnection(row, col, BIGRADIUS-RADIUS, Color.BLACK);

                                        }

                                }

                        }

                        // draw the selection indicator

                        indicator.draw();

                        txtInfo.setText("Bot " + selectedBot + " is selected.\n");

                        txtInfo.append("Battery: ???\n");

                        txtInfo.append("Packet statistics: ???");

                }

                else // if matrix is not valid

                {

                        this.showStatus("Error: Invalid matrix");

                }

        }

        /*        At this point, moveToken is only called by the simulator.

        *        In the future, it can be rewritten to account for non-standard

        *        token passing or deleted if the information can be retrieved

        *        directly from the Colonet server instead.

        */

        public void moveToken ()

        {

                try { tokenLoc = (tokenLoc+1)%numBots; }

                        catch (ArithmeticException e) { }  // in case numRobots is zero

                packetMonitor.addTokenPass();

        }

        //

        // MouseEvent methods

        //

        public void mouseExited(MouseEvent e) {}

        public void mouseEntered(MouseEvent e) {}

        public void mouseReleased(MouseEvent e) {}

        public void mouseClicked(MouseEvent e) {}

        public void mousePressed(MouseEvent e)

        {

                try {

                        for (int i = 0; i < numBots; i++)

                        {

                                if (botRect[i].contains(e.getPoint()))

                                        selectedBot = i;

                        }

                } catch (Exception ex) {

                        System.out.println(e);

                }

        }

        private void msg (String text) {JOptionPane.showMessageDialog(null, text, "Colonet", JOptionPane.INFORMATION_MESSAGE);}

        private void warn (String text) {JOptionPane.showMessageDialog(null, text, "Colonet", JOptionPane.WARNING_MESSAGE);}

        private void err (String text) {JOptionPane.showMessageDialog(null, text, "Colonet", JOptionPane.ERROR_MESSAGE);}

        /*

        *        SelectionIndicator thread.

        *        Graphical representation of the selection marker

        *

        *        step() and draw() are synchronized methods. step() is private and

        *        used to update the position of the crosshairs. draw() is called

        *        externally and should only run if all calculations in step() have

        *        been completed.

        */

        private class SelectionIndicator extends Thread

        {

                final int INDICATOR_DELAY = 100;

                final double DTHETA = 0.3;    //larger values make the marker rotate faster

                Graphics2D g;   //canvas to draw on

                boolean running;

                int sx, sy;                //center

                int r, dr;                //radius and width of marker

                double theta;   //current angle

                volatile Polygon poly1, poly2, poly3, poly4;

                int px1, py1;

                int rx1, ry1;

                int px2, py2;

                int rx2, ry2;

                int px3, py3;

                int rx3, ry3;

                int px4, py4;

                int rx4, ry4;

                int steps;

                public SelectionIndicator (Graphics2D g)

                {

                        super("SelectionIndicator");

                        this.g = g;

                        running = false;

                        steps = 0;

                        theta = 0;

                        rx1 = 0; ry1 = 0;

                        px1 = 0; py1 = 0;

                        rx2 = 0; ry2 = 0;

                        px2 = 0; py2 = 0;

                        rx3 = 0; ry3 = 0;

                        px3 = 0; py3 = 0;

                        rx4 = 0; ry4 = 0;

                        px4 = 0; py4 = 0;

                }

                public synchronized void setCenter (int sx, int sy)

                {

                        if (sx == this.sx && sy == this.sy) return;

                        this.sx = sx;

                        this.sy = sy;

                        steps = 0;

                }

                public synchronized void setRadius (int r, int dr)

                {

                        this.r = r;

                        this.dr = dr;

                        steps = 0;

                }

                public void run ()

                {

                        running = true;

                        while (running)

                        {

                                step();

                                try { Thread.sleep(INDICATOR_DELAY); }

                                        catch (InterruptedException e) {  running = false; return; }

                        }

                }

                private synchronized void step ()

                {

                        Polygon poly1_new = new Polygon();

                        Polygon poly2_new = new Polygon();

                        Polygon poly3_new = new Polygon();

                        Polygon poly4_new = new Polygon();

                        //the step

                        theta = (theta + DTHETA/Math.PI) % (Math.PI);

                        //the calculation

                        //let p be the point of the pointy thing toward the center

                        //let r be the point at the opposite side

                        //recalculate radius, if it will look cool, lolz

                        int newr = r;

                        if (steps < 100) newr = (int)( r + 200/(steps+1) );

                        //precompute values for dx and dy

                        int dx_inner = (int)(newr * Math.cos(theta));

                        int dy_inner = (int)(newr * Math.sin(theta));

                        int dx_outer = (int)((newr+dr) * Math.cos(theta));

                        int dy_outer = (int)((newr+dr) * Math.sin(theta));

                        //calculate polygon constants

                        int dy_poly = (int)(dr/2 * Math.cos(theta));

                        int dx_poly = (int)(dr/2 * Math.sin(theta));

                        //determine critical points

                        px1 = sx + dx_inner;

                        py1 = sy - dy_inner;

                        rx1 = sx + dx_outer;

                        ry1 = sy - dy_outer;

                        px2 = sx - dx_inner;

                        py2 = sy + dy_inner;

                        rx2 = sx - dx_outer;

                        ry2 = sy + dy_outer;

                        px3 = sx - dy_inner;

                        py3 = sy - dx_inner;

                        rx3 = sx - dy_outer;

                        ry3 = sy - dx_outer;

                        px4 = sx + dy_inner;

                        py4 = sy + dx_inner;

                        rx4 = sx + dy_outer;

                        ry4 = sy + dx_outer;

                        //create polygons

                        poly1_new.addPoint(px1, py1);

                        poly1_new.addPoint(rx1+dx_poly, ry1+dy_poly);

                        poly1_new.addPoint(rx1-dx_poly, ry1-dy_poly);

                        poly2_new.addPoint(px2, py2);

                        poly2_new.addPoint(rx2+dx_poly, ry2+dy_poly);

                        poly2_new.addPoint(rx2-dx_poly, ry2-dy_poly);

                        poly3_new.addPoint(px3, py3);

                        poly3_new.addPoint(rx3-dy_poly, ry3+dx_poly);

                        poly3_new.addPoint(rx3+dy_poly, ry3-dx_poly);

                        poly4_new.addPoint(px4, py4);

                        poly4_new.addPoint(rx4-dy_poly, ry4+dx_poly);

                        poly4_new.addPoint(rx4+dy_poly, ry4-dx_poly);

                        //reassign updated polygons

                        poly1 = poly1_new;

                        poly2 = poly2_new;

                        poly3 = poly3_new;

                        poly4 = poly4_new;

                        if (steps < 300) steps++;

                }

                public synchronized void draw ()

                {

                        if (!running) return;

                        g.setColor(Color.GRAY);

                        //draw polygons

                        g.fillPolygon(poly1);

                        g.fillPolygon(poly2);

                        g.fillPolygon(poly3);

                        g.fillPolygon(poly4);

                }

        }

        /*

        *        Simulator thread.

        *

        */

        private class Simulator extends Thread

        {

                final int SIMULATOR_DELAY = 300;

                boolean running;

                public Simulator ()

                {

                        super("Simulator");

                        running = false;

                }

                public void run ()

                {

                        running = true;

                        while (running)

                        {

                                step();

                                try { Thread.sleep(SIMULATOR_DELAY); }

                                        catch (InterruptedException e) { running = false; return; }

                        }

                }

                private void step ()

                {

                        // simulate passing the token

                        moveToken();

                }

        }

        /*

        *        PacketMonitor thread.

        *

        *        Currently, this counts the rate of token passes but will eventually

        *        be modified to keep more important statistics.

        */

        private class PacketMonitor extends Thread

        {

                final int PACKETMONITOR_DELAY = 1000;

                boolean running;

                int tokenPasses;

                public PacketMonitor ()

                {

                        super("PacketMonitor");

                        running = false;

                        tokenPasses = 0;

                }

                public void run ()

                {

                        running = true;

                        while (running)

                        {

                                displayTokenPasses();

                                try { Thread.sleep(PACKETMONITOR_DELAY); }

                                        catch (InterruptedException e) { running = false; return; }

                        }

                }

                public synchronized void addTokenPass ()

                {

                        tokenPasses++;

                }

                public synchronized void displayTokenPasses ()

                {

                        lblTokenPasses.setText("" + tokenPasses);

                        tokenPasses = 0;

                }

        }

        /*

        *        DataListener thread.

        *

        */

        class DataListener extends Thread

        {

                final int DATALISTENER_DELAY = 1000;

                BufferedReader reader;

                public DataListener ()

                {

                        super("Colonet DataListener");

                }

                public void run ()

                {

                        String line;

                        try {

                                reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));

                        } catch (IOException e) {

                                warn("Could not open input stream from socket.\nTry relooding the applet.");

                        }

                        while (true)

                        {

                                try {

                                        if (reader.ready())

                                        {

                                                line = reader.readLine();

                                                if (line != null)

                                                {

                                                        msg("Incoming data: [" + line + "]");

                                                }

                                        }

                                        Thread.sleep(DATALISTENER_DELAY);

                                } catch (InterruptedException e) {

                                        return;

                                } catch (IOException e) {

                                        warn("IOException while reading incoming data.");

                                }

                        }

                }

        }

        /*

        *        Matrix class

        *        holds current sensor matrix data

        */

        /*

        private class Matrix

        {

                int [][] grid;

                public Matrix ()

                {

                        grid = new int[1][1];

                }

                public String toString ()

                {

                        StringBuilder s = new StringBuilder();

                        for (int j = 0; j < grid.length; j++)

                        {

                                for (int i = 0; i < grid[0].length; i++)

                                        s.append(grid[i][j]);

                                if (j < grid.length-1) s.append("\n");

                        }

                        return s.toString();

                }

        }

        */

}