PlayerController has-a Connection

package telnet.connection;

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.NoSuchElementException;
import java.util.Observable;
import java.util.Observer;
import java.util.Properties;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.logging.Logger;
import org.apache.commons.net.telnet.TelnetClient;
import telnet.player.Action;

public final class TelnetConnection implements Observer {

    private Logger log = Logger.getLogger(TelnetConnection.class.getName());
    private TelnetClient telnetClient = new TelnetClient();
    private InputStreamWorker remoteInputStreamWorker = new InputStreamWorker();
    private ConsoleReader localInputReader = new ConsoleReader();
    private CharacterDataQueueWorker characterDataQueueWorker = new CharacterDataQueueWorker();
    private ConcurrentLinkedQueue<Character> remoteCharDataQueue = new ConcurrentLinkedQueue<>();
    private Deque<Action> actions = new ArrayDeque<>();

    public TelnetConnection() throws UnknownHostException, SocketException, IOException {
        Properties props = PropertiesReader.getProps();
        InetAddress host = InetAddress.getByName(props.getProperty("host"));
        int port = Integer.parseInt(props.getProperty("port"));
        telnetClient.connect(host, port);
    }

    public void startReadPrintThreads() throws SocketException, IOException {
        remoteInputStreamWorker.print(telnetClient.getInputStream(), remoteCharDataQueue);
        localInputReader.read();
        localInputReader.addObserver(this);
        characterDataQueueWorker.read(remoteCharDataQueue);
        characterDataQueueWorker.addObserver(this);
    }

    private void sendActions(long delay) {
        byte[] commandBytes = null;
        OutputStream outputStream = telnetClient.getOutputStream();
        while (!actions.isEmpty()) {
            try {
                Action action = actions.remove();
                sendAction(action);
                Thread.sleep(delay);
            } catch (InterruptedException | IOException | NoSuchElementException ex) {
            } finally {
            }
        }
    }

    private void sendAction(Action action) throws IOException {
        byte[] actionBytes = action.getCommand().getBytes();
        OutputStream outputStream = telnetClient.getOutputStream();
        outputStream.write(actionBytes);
        outputStream.write(13);
        outputStream.write(10);
        outputStream.flush();
    }

    @Override
    public void update(Observable o, Object arg) {
        long delay = 0;
//        Deque<Action> newActions = new ArrayDeque<>();
        actions = new ArrayDeque<>();
        try {
            if (o instanceof CharacterDataQueueWorker) {
                String remoteOutputMessage = characterDataQueueWorker.getFinalData();
//                newActions = playerController.processGameData(remoteOutputMessage);
                delay = 5;
            }
 //           actions.addAll(newActions);
            sendActions(delay);
        } catch (NullPointerException npe) {
            log.fine(npe.toString());
        }

        if (o instanceof ConsoleReader) {
            try {
                String userInput = localInputReader.getCommand();
                Action action = new Action(userInput);
                sendAction(action);
            } catch (IOException ex) {
            }
        }
    }

    public String getGameData() {
        String s = remoteCharDataQueue.toString();
        return s;
    }
}



package telnet.player;

import java.io.IOException;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.Deque;
import java.util.Map.Entry;
import java.util.logging.Level;
import java.util.logging.Logger;
import telnet.connection.TelnetConnection;

public class PlayerController {

    private final static Logger log = Logger.getLogger(PlayerController.class.getName());
    private static Player player = Player.INSTANCE;  //single player only, ever
    private static RegexWorker rw = new RegexWorker();
    private static TelnetConnection tc;

    public PlayerController() {
    }

    public static void processGameData() {
        String gameData = tc.getGameData();
        Deque<Action> actions = rw.parseAndUpdatePlayerCharacter(gameData);
        Flag flag = null;
        for (Entry<Flag, Boolean> entry : player.getFlags().entrySet()) {
            if (entry.getKey() != Flag.LOGGEDIN) {
                if (entry.getValue()) {
                    flag = entry.getKey();
                    log.log(Level.INFO, "detected\t{0}", flag);
                    player.setFlag(flag, false);
                    actions.addAll(flag.getActionsForState());
                }
            }
        }
    }

    public static void main(String[] args) throws UnknownHostException, IOException {
                    tc = new TelnetConnection();
        while (true) {
            processGameData();
        }
    }
}