The Connect4Server class serves as a stub program to get the server started. Check out the source code for it:

class Connect4Server {
  public static void main(String args[]) {
    System.out.println("NetConnect4 server up and running...");
    new Connect4Daemon().start();
  }
}

As you can see, the Connect4Server class contains only one method, main, which prints a message and creates a Connect4Daemon object. The Connect4Daemon class is where the server is actually created and initialized. The Connect4Daemon class is responsible for creating the server socket and handling client connections. Take a look at the member variables defined in the Connect4Daemon class:

public static final int PORTNUM = 1234;
private ServerSocket    port;
private Connect4Player  playerWaiting = null;
private Game            thisGame = null;

Other than the constant port number, Connect4Daemon defines three member variables consisting of a ServerSocket object, a Connect4Player object, and a Game object. The Connect4Player and Game classes are covered a little later in the lesson. The ServerSocket member object, port, is created using an arbitrary port number above 1024. If you recall from yesterChapter's lesson, all ports below 1024 are reserved for standard system services, so you must use one above 1024. More specifically, I chose 1234 as the port number, which is represented by the PORTNUM constant.

The run method in Connect4Daemon is where the details of connecting clients are handled:

public void run() {
  Socket clientSocket;
  while (true) {
    if (port == null) {
      System.out.println("Sorry, the port disappeared.");
      System.exit(1);
    }
    try {
      clientSocket = port.accept();
      new Connect4Player(this, clientSocket).start();
    }
    catch (IOException e) {
      System.out.println("Couldn't connect player: " + e);
      System.exit(1);
    }
  }
}

The run method first retrieves the socket for a connecting client via a call to the ServerSocket class's accept method. If you recall from yesterChapter's lesson, the accept method waits until a client connects and then returns a socket for the client. After a client connects, a Connect4Player object is created using the client socket.

The waitForGame method is where players are paired up with each other. Listing 19.1 contains the source code for the waitForGame method.

Listing 19.1. The Connect4Daemon class's waitForGame method.

public synchronized Game waitForGame(Connect4Player p) {
  Game retval = null;
  if (playerWaiting == null) {
    playerWaiting = p;
    thisGame = null;    // just in case!
    p.send("PLSWAIT");
    while (playerWaiting != null) {
      try {
        wait();
      }
      catch (InterruptedException e) {
        System.out.println("Error: " + e);
      }
    }
    return thisGame;
  }
  else {
    thisGame = new Game(playerWaiting, p);
    retval = thisGame;
    playerWaiting = null;
    notify();
    return retval;
  }
}

The waitForGame method is called from within the Connect4Player class, which you'll learn about in a moment. waitForGame is passed a Connect4Player object as its only parameter. If no player is waiting to play, this player is flagged as a waiting player, and a loop is entered that waits until another player connects. A null Game object is then returned to indicate that only one player is present. When another player connects and waitForGame is called, things happen a little differently. Because a player is now waiting, a Game object is created using the two players. This Game object is then returned to indicate that the game is ready to begin.

The finalize method in Connect4Daemon is simply an added measure to help clean up the server socket when the daemon dies:

protected void finalize() {
  if (port != null) {
    try {
      port.close();
    }
    catch (IOException e) {
      System.out.println("Error closing port: " + e);
    }
    port = null;
  }
}

To clean up the server socket, finalize simply calls the close method on the port.

The Connect4Daemon class made a few references to the Connect4Player class, which logically represents a player in the game. Listing 19.2 contains the source code for the Connect4Player class.

Listing 19.2. The Connect4Player class.

class Connect4Player extends SocketAction {
  private Connect4Daemon daemon = null;

  public Connect4Player(Connect4Daemon server, Socket sock) {
    super(sock);
    daemon = server;
  }

  public void run() {
    daemon.waitForGame(this).playGame(this);
  }

  public void closeConnections() {
    super.closeConnections();
    if (outStream != null) {
      send("GAMEOVER");
    }
  }
}

The Connect4Player class represents a player from the server's perspective. Connect4Player is derived from SocketAction, which is the generic socket class you developed yesterChapter. I told you it would come in handy. The only member variable defined in Connect4Player is daemon, which holds the Connect4Daemon object associated with the player.

The constructor for Connect4Player takes Connect4Daemon and Socket objects as its two parameters. The Connect4Daemon object is used to initialize the daemon member variable, and the Socket object is passed on to the parent constructor in SocketAction.

The run method for Connect4Player calls back to the daemon's waitForGame method to get a Game object for the player. The playGame method is then called on the Game object to get the game underway. The closeConnections method closes the client connection and is typically used to end the game.

The last class the NetConnect4 server comprises is the Game class, which handles the details associated with managing the game logic and the communication between players. The Game class takes on the bulk of the work involved in maintaining the state of the game, as well as communicating that state between the players. The Game class contains a group of member constants that define the different states in the game:

public static final int ERROR = -1;
public static final int IWON = -2;
public static final int IQUIT = -3;
public static final int ITIED = -4;
public static final int YOURTURN = -5;
public static final int SENTSTRING = -6;

Along with the constants, the Game class has member variables representing each player, along with an event queue for each player and a string used to send messages to the other player:

private Connect4Player  player1 = null;
private Connect4Player  player2 = null;
private Vector          p1Queue = null;
private Vector          p2Queue = null;
private String          sentString;

An event queue is a list of events that take place within a particular context.

In the case of NetConnect4, an event consists of player moves and related game states. So the event queue is used to keep up with the latest player moves and game states.

The workhorse method in the Game class is playGame, which essentially manages the game flow and logic for each player. Listing 19.3 contains the source code for the playGame method.

Listing 19.3. The Game class's playGame method.

public void playGame(Connect4Player me) {
  String instr;
  boolean playgame = true;
  boolean theirturn = false;

  try {
    if (me == player2) {
      theirturn = true;
    }
    else if (me != player1) {
      System.out.println("Illegal call to playGame!");
      return;
    }

    while (playgame) {
      if (!theirturn) {
        me.send("YOURTURN");
        instr = me.receive();
        instr = instr.toUpperCase();
        instr = instr.trim();
        if (instr.startsWith("IQUIT")) {
          sendStatus(me, IQUIT);
          playgame = false;
        }
        else if (instr.startsWith("IWON")) {
          sentString = me.receive();
          sentString = sentString.toUpperCase();
          sentString = sentString.trim();
          sendStatus(me, IWON);
          sendStatus(me, SENTSTRING);
          playgame = false;
        }
        else if (instr.startsWith("ITIED")) {
          sentString = me.receive();
          sentString = sentString.toUpperCase();
          sentString = sentString.trim();
          sendStatus(me, ITIED);
          sendStatus(me, SENTSTRING);
        }
        else {
          sentString = instr;
          sendStatus(me, SENTSTRING);
        }
      }
      else {
        theirturn = false;
      }

      if (playgame) {
        me.send("THEIRTURN");
        int stat = getStatus(me);
        if (stat == IWON) {
          me.send("THEYWON");
          if (getStatus(me) != SENTSTRING) {
            System.out.println("Received Bad Status");
            me.closeConnections();
          }
          me.send(sentString);
          playgame = false;
        }
        else if (stat == ITIED) {
          me.send("THEYTIED");
          if (getStatus(me) != SENTSTRING) {
            System.out.println("Received Bad Status");
            me.closeConnections();
          }
          me.send(sentString);
          playgame = false;
        }
        else if (stat == IQUIT) {
          me.send("THEYQUIT");
          playgame = false;
        }
        else if (stat == SENTSTRING) {
          me.send(sentString);
        }
        else if (stat == ERROR) {
          me.send("ERROR");
          me.closeConnections();
          playgame = false;
        }
        else {
          System.out.println("Received Bad Status");
          sendStatus(me,ERROR);
          me.closeConnections();
          playgame = false;
        }
      }
    }
    me.closeConnections();
    return;
  }
  catch (IOException e) {
    System.out.println("I/O Error: " + e);
    System.exit(1);
  }
}

The logic used in playGame is fairly simple in that it models the way a game of Connect4 takes place; basically, each player waits while the other takes her turn. The only potentially confusing aspect of playGame is the mechanism it uses to communicate between the players. Each player has an event queue, which contains game information sent by the other player. The players communicate with each other in an indirect fashion by using the event queue. The state of the game is encoded into event messages using the state constants, along with strings. The playGame method interprets this information for each player.

The getStatus method gets the status of the game for the player passed in the me parameter. Listing 19.4 contains the source code for the getStatus method.

Listing 19.4. The Game class's getStatus method.

private synchronized int getStatus(Connect4Player me) {
  Vector ourVector = ((me == player1) ? p1Queue : p2Queue);
  while (ourVector.isEmpty()) {
    try {
      wait();
    }
    catch (InterruptedException e) {
      System.out.println("Error: " + e);
    }
  }
  try {
    Integer retval = (Integer)(ourVector.firstElement());
    try {
      ourVector.removeElementAt(0);
    }
    catch (ArrayIndexOutOfBoundsException e) {
      System.out.println("Array index out of bounds: " + e);
      System.exit(1);
    }
    return retval.intValue();
  }
  catch (NoSuchElementException e) {
    System.out.println("Couldn't get first element: " + e);
    System.exit(1);
    return 0; // never reached, just there to appease compiler
  }
}

The getStatus method waits until the player's event queue contains status information, and then it grabs the information and returns it.

The sendStatus method is the complement of getStatus; it's used to update a player's event queue with status information:

private synchronized void sendStatus(Connect4Player me, int message) {
  Vector theirVector = ((me == player1) ?  p2Queue : p1Queue);
  theirVector.addElement(new Integer(message));
  notify();
}

The integer status message passed in as the second parameter to sendStatus is added to the player's event queue. The notify method is then called, which causes the wait call in getStatus to return. This shows the synchronized nature of these two methods: getStatus waits until sendStatus provides the information it needs.

That sums up the code for the server. At this point, you have half a game. Too bad you can't do much with it yet; you still need a client. Knowing that, let's take a look at the code involved in making the client side work.

The Client

The client side of NetConnect4 consists of four classes, three of which you've seen before:

• Connect4State
• Connect4Engine
• Connect4
• Connect4ClientConnection