Client -> InputThread
---------------------

package tw.client;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.net.Socket;
import java.util.Vector;
import java.util.concurrent.BlockingQueue;

import tw.Projectile;
import tw.Tank;


public class InputThread extends Thread {

    private     ObjectInputStream   in          = null;
    private     BlockingQueue       queue           = null;
    private     boolean         running         = true;

    private     int         playerNr        = 0;
    private     Vector<Tank>        updatedTanks        = null;
    private     Vector<Projectile>  updatedProjectiles  = null;


    /**
     * ClientThread constructor.
     */
    public InputThread(Socket socket, BlockingQueue queue) {
        this.queue = queue;

        // Initialize input stream
        try {
            in = new ObjectInputStream(socket.getInputStream());
        } catch (IOException e) {
            e.printStackTrace();
        }

        start();
    }


    /**
     * Run method, called when thread is started.
     */
    @SuppressWarnings("unchecked")
    public void run() {
        // Get playerNr and first tank vector
        try {
            playerNr = in.readInt();
            System.out.println("playerNr " + playerNr);

            updatedTanks = (Vector<Tank>) in.readObject();
            queue.put(updatedTanks);
        } catch (InterruptedException e2) {
            e2.printStackTrace();
        } catch (IOException e2) {
            e2.printStackTrace();
        } catch (ClassNotFoundException e2) {
            e2.printStackTrace();
        }

        // Get entities from server
        try {
            while (running) {
                updatedTanks = (Vector<Tank>) in.readObject();
                System.out.println("Tank 0 is active: " + updatedTanks.get(0).isActive());
                System.out.println("Tank 1 is active: " + updatedTanks.get(1).isActive());
                sleep(5000);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    } // run


    /**
     * Sets 'running' to 'false', stopping the input loop.
     */
    public void stopRunning() {
        running = false;
    }


    /**
     * Getter of the property <tt>playerNr</tt>
     * @return Returns playerNr
     * @uml.property name="playerNr"
     */
    public int getPlayerNr() {
        return playerNr;
    }


    /**
     * Getter of the property (vector) <tt>updatedEntitites</tt>
     * @return  Returns the updatedEntities vector.
     * @uml.property  name="updatedEntities"
     */
    public Vector<Tank> getUpdatedTanks() {
        return updatedTanks;
    }
}


Server -> OutputThread
----------------------

package tw.server;

import java.io.IOException;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.concurrent.BlockingQueue;


public class OutputThread extends Thread  {

    private ObjectOutputStream  out         = null;
    private boolean             running     = true;

    private int                 playerNr;
    private GameManager         gm;


    /**
     * OutputThread constructor.
     * @param s
     * @param playerNr
     * @param gm
     * @throws IOException
     */
    public OutputThread(Socket s, int playerNr, GameManager gm) throws IOException {
        this.playerNr = playerNr;
        this.gm = gm;

        // Open new output stream to client
        out = new ObjectOutputStream(s.getOutputStream());

        start();
    }


    public void run() {

        // Send player number to client
        try {
            out.writeInt(playerNr);
        } catch (IOException e) {
            e.printStackTrace();
        }

        // Send entities client
        try {
            while(running) {
                out.writeObject(gm.getTanks());
                System.out.println("Tank 0 is active: " + gm.getTanks().get(0).isActive());
                System.out.println("Tank 1 is active: " + gm.getTanks().get(1).isActive());
                sleep(5000);
            }
        } catch (IOException e1) {
            e1.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Output Client:
Tank 0 is active: false
Tank 1 is active: true
Tank 0 is active: false
Tank 1 is active: true
Client output: 32
Tank 0 is active: false
Tank 1 is active: true
Tank 0 is active: false
Tank 1 is active: true

Output Server:
Tank 0 is active: false
Tank 1 is active: true
Tank 0 is active: false
Tank 1 is active: true
GameManager: Action triggered!
Tank 0 is active: true
Tank 1 is active: false
Tank 0 is active: true
Tank 1 is active: false