tictactoegamecontrol.java

myjxta是用jxta开发的一个p2p通讯软件 有聊天 文件共享 视频3大功能 界面采用swing

/*
 * TicTacToePlugin.java
 *
 * Created on February 8, 2005, 2:34 AM
 */

package net.jxta.myjxta.plugins.tictactoe;

import net.jxta.endpoint.ByteArrayMessageElement;
import net.jxta.endpoint.Message;
import net.jxta.endpoint.MessageElement;
import net.jxta.endpoint.StringMessageElement;
import net.jxta.logging.Logging;
import net.jxta.myjxta.dialog.Dialog;
import net.jxta.myjxta.dialog.DialogListener;
import net.jxta.myjxta.dialog.DialogMessage;

import javax.imageio.ImageIO;
import javax.imageio.ImageReader;
import javax.imageio.stream.FileImageInputStream;
import javax.imageio.stream.MemoryCacheImageInputStream;
import javax.swing.*;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.util.*;
import java.util.List;
import java.util.Timer;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * @author Jeff Moore
 */
public class TicTacToeGameControl implements DialogListener, MoveListener {


    /**
     * Time to wait for response after a command  message is sent
     * out. Default is 10 seconds.
     */
    private static final long DEFAULT_MESSAGE_ACK_TIMEOUT = 160000;

    /**
     * Minimum time we will wait till a message ack comes back
     */
    private static final long MINIMUM_MESSAGE_ACK_TIMEOUT = 2000;
    /**
     * Timeout waiting for config request
     */
    private static final long CONFIG_WAIT_TIMOUT = 20000;


    /**
     * Tag for an element element carrying voice data
     */
    public static final String TAG_POSITION_DATA = "PositionData";

    public static final String TAG_ICON_DATA = "IconData";

    public static final String TAG_ICON_TYPE = "IconType";

    /**
     * Element tag denoting a message containing TTT session command data
     */
    public static final String TAG_SESSION_COMMAND = "TTTSessionCommand";

    /**
     * commands sent btn peers managing the TTT session
     */

    private static final int CONNECT_SLEEP_TIME = 200;

    public static final String COMMAND_INVITE_REQUEST = "InviteRequest";

    public static final String COMMAND_INVITE_ACCEPT = "InviteAccept";

    public static final String COMMAND_START_GAME_REQUEST = "StartGameRequest";

    public static final String COMMAND_START_GAME_ACCEPT = "StartGameAccept";

    public static final String COMMAND_CONFIG_REQUEST = "ConfigRequest";

    public static final String COMMAND_CONFIG_ACCEPT = "ConfigAccept";

    public static final String COMMAND_NEW_MOVE = "NewMove";

    public static final String COMMAND_NEW_MOVE_ACCEPT = "NewMoveAccept";

    public static final String COMMAND_END_GAME_REQUEST = "EndGameRequest";

    public static final String COMMAND_END_GAME_ACCEPT = "EndGameAccept";

    public static final String COMMAND_DISCONNECT_REQUEST = "DisconnectRequest";

    public static final String COMMAND_DISCONNECT_ACCEPT = "DisconnectAccept";


    /**
     * internal session state
     */


    public static final int SESSION_DISCONNECTED = 10;

    public static final int SESSION_DISCONNECTING = 11;

    public static final int SESSION_CONNECTED = 12;

    public static final int SESSION_CONNECTING = 13;

    public static final int SESSION_STARTING = 20;

    public static final int SESSION_STARTED = 30;

    public static final int SESSION_ENDING = 40;

    public static final int SESSION_ENDED = 50;

    public static final int SESSION_PLAYING = 100;


    public static final int SESSION_DISCONNECT_REQUEST_SENT = 210;

    public static final int SESSION_DISCONNECT_REQUEST_RECEIVED = 220;

    public static final int SESSION_DISCONNECT_ACCEPT_SENT = 230;

    public static final int SESSION_DISCONNECT_ACCEPT_RECEIVED = 240;

    public static final int SESSION_START_REQUEST_SENT = 340;

    public static final int SESSION_START_REQUEST_RECEIVED = 350;

    public static final int SESSION_START_ACCEPT_SENT = 360;

    public static final int SESSION_CONFIG_REQUEST_SENT = 362;

    public static final int SESSION_CONFIG_REQUEST_RECEIVED = 363;

    public static final int SESSION_CONFIG_ACCEPT_SENT = 364;

    public static final int SESSION_CONFIG_ACCEPT_RECEIVED = 365;

    public static final int SESSION_START_ACCEPT_RECEIVED = 370;

    public static final int SESSION_END_ACCEPT_RECEIVED = 380;

    public static final int SESSION_END_ACCEPT_SENT = 390;

    public static final int SESSION_END_REQUEST_RECEIVED = 410;

    public static final int SESSION_END_REQUEST_SENT = 420;

    public static final int SESSION_INVITE_REQUEST_SENT = 430;

    public static final int SESSION_INVITE_REQUEST_RECEIVED = 440;

    public static final int SESSION_INVITE_ACCEPT_SENT = 450;

    public static final int SESSION_INVITE_ACCEPT_RECEIVED = 460;

    public int sessionState = SESSION_DISCONNECTED;

    public int protocolState = SESSION_DISCONNECTED;

    private long messageAckTimeout = DEFAULT_MESSAGE_ACK_TIMEOUT;

    private MessageAckThread messageAckThread = null;

    private boolean locallyInitiated = false;
    private DialogMessage templateMessage = null;
    private TicTacToeDialogView tttView = null;

    /**
     * in bytes
     */
    public final static long MAX_ICON_SIZE = 60000;

    public final static int REMOTE_PLAYER = 2;

    public final static int LOCAL_PLAYER = 1;


    public final static int GAME_OVER = 1;
    public final static int GAME_WAITING = 2;
    public final static int GAME_IN_PLAY = 3;
    public final static int GAME_LOST = 4;
    public final static int GAME_WON = 5;
    public final static int GAME_DRAW = 6;


    public final static String SESSION_ICON_EXCHANGE = "iconExchange";
    private int remotePlayerTotalWins = 0;
    private int localPlayerTotalWins = 0;
    private int gameState = GAME_OVER;
    private int playersTurn = 0;
    private final List<String> localPlayerMoves ;
    private final List<String> remotePlayerMoves;
    private List<String> allMoves = null;
    private Object localIconChosenLock = null;
    private String remotePlayerName = null;
    private Hashtable<Integer, String> sessionStateTable = null;
    private Dialog tttDialog = null;
    static final Logger LOG = Logger.getLogger(TicTacToeGameControl.class.getName());
    private boolean configured = false;
    private TimerTask configWaitTimerTask = null;
    private Timer generalTimer = null;

    private String[] winningSet = null;

    private static final String[] draw = {
            "A0", "A1", "A2",
            "B0", "B1", "B2",
            "C0", "C1", "C2"
    };

    private static final String[][] wins = {
            {"A0", "A1", "A2"},
            {"B0", "B1", "B2"},
            {"C0", "C1", "C2"},
            {"A0", "B0", "C0"},
            {"A1", "B1", "C1"},
            {"A2", "B2", "C2"},
            {"A0", "B1", "C2"},
            {"A2", "B1", "C0"}
    };


    /**
     * Creates a new instance of TicTacToePlugin
     */
    public TicTacToeGameControl(final TicTacToeDialogView tttView, final Dialog tttDialog) {

        LOG.setLevel(Level.INFO);

        if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
            LOG.info("TicTacToeGameCOntrol constructor");

        }
        locallyInitiated = tttView.isLocallyInitiated();
        this.sessionStateTable = new Hashtable<Integer, String>();
        this.sessionStateTable.put(new Integer(TicTacToeGameControl.SESSION_CONFIG_ACCEPT_RECEIVED), "SESSION_CONFIG_ACCEPT_RECEIVED");
        this.sessionStateTable.put(new Integer(TicTacToeGameControl.SESSION_CONFIG_ACCEPT_SENT), "SESSION_CONFIG_ACCEPT_SENT");
        this.sessionStateTable.put(new Integer(TicTacToeGameControl.SESSION_CONFIG_REQUEST_RECEIVED), "SESSION_CONFIG_REQUEST_RECEIVED");
        this.sessionStateTable.put(new Integer(TicTacToeGameControl.SESSION_CONFIG_REQUEST_SENT), "SESSION_CONFIG_REQUEST_SENT");
        this.sessionStateTable.put(new Integer(TicTacToeGameControl.SESSION_CONNECTED), "SESSION_CONNECTED");
        this.sessionStateTable.put(new Integer(TicTacToeGameControl.SESSION_CONNECTING), "SESSION_CONNECTING");
        this.sessionStateTable.put(new Integer(TicTacToeGameControl.SESSION_DISCONNECTED), "SESSION_DISCONNECTED");
        this.sessionStateTable.put(new Integer(TicTacToeGameControl.SESSION_DISCONNECTING), "SESSION_DISCONNECTING");
        this.sessionStateTable.put(new Integer(TicTacToeGameControl.SESSION_DISCONNECT_ACCEPT_RECEIVED), "SESSION_DISCONNECT_ACCEPT_RECEIVED");
        this.sessionStateTable.put(new Integer(TicTacToeGameControl.SESSION_DISCONNECT_ACCEPT_SENT), "SESSION_DISCONNECT_ACCEPT_SENT");
        this.sessionStateTable.put(new Integer(TicTacToeGameControl.SESSION_DISCONNECT_REQUEST_RECEIVED), "SESSION_DISCONNECT_REQUEST_RECEIVED");
        this.sessionStateTable.put(new Integer(TicTacToeGameControl.SESSION_ENDED), "SESSION_ENDED");
        this.sessionStateTable.put(new Integer(TicTacToeGameControl.SESSION_DISCONNECT_REQUEST_SENT), "SESSION_DISCONNECT_REQUEST_SENT");
        this.sessionStateTable.put(new Integer(TicTacToeGameControl.SESSION_ENDING), "SESSION_ENDING");
        this.sessionStateTable.put(new Integer(TicTacToeGameControl.SESSION_PLAYING), "SESSION_PLAYING");
        this.sessionStateTable.put(new Integer(TicTacToeGameControl.SESSION_INVITE_ACCEPT_RECEIVED), "SESSION_INVITE_ACCEPT_RECEIVED");
        this.sessionStateTable.put(new Integer(TicTacToeGameControl.SESSION_INVITE_ACCEPT_SENT), "SESSION_INVITE_ACCEPT_SENT");
        this.sessionStateTable.put(new Integer(TicTacToeGameControl.SESSION_INVITE_REQUEST_RECEIVED), "SESSION_INVITE_REQUEST_RECEIVED");
        this.sessionStateTable.put(new Integer(TicTacToeGameControl.SESSION_INVITE_REQUEST_SENT), "SESSION_INVITE_REQUEST_SENT");
        this.sessionStateTable.put(new Integer(TicTacToeGameControl.SESSION_STARTED), "SESSION_STARTED");
        this.sessionStateTable.put(new Integer(TicTacToeGameControl.SESSION_STARTING), "SESSION_STARTING");
        this.sessionStateTable.put(new Integer(TicTacToeGameControl.SESSION_START_ACCEPT_RECEIVED), "SESSION_START_ACCEPT_RECEIVED");
        this.sessionStateTable.put(new Integer(TicTacToeGameControl.SESSION_START_ACCEPT_SENT), "SESSION_START_ACCEPT_SENT");
        this.sessionStateTable.put(new Integer(TicTacToeGameControl.SESSION_START_REQUEST_RECEIVED), "SESSION_START_REQUEST_RECEIVED");
        this.sessionStateTable.put(new Integer(TicTacToeGameControl.SESSION_START_REQUEST_SENT), "SESSION_START_REQUEST_SENT");


        this.tttView = tttView;

        this.tttDialog = tttDialog;

        this.localIconChosenLock = new Object();

        this.templateMessage = new DialogMessage(this.tttDialog.getGroup()
                .getPeerGroup().getPeerName(), null, this.tttDialog.getGroup()
                .getPeerGroup().getPeerGroupID().toString(), this.tttDialog
                .getGroup().getPeerGroup().getPeerGroupName());

        this.localPlayerMoves = new ArrayList<String>();

        this.remotePlayerMoves = new ArrayList<String>();

        this.allMoves = new ArrayList<String>();

        this.tttView.addMoveListener(this);

        this.tttDialog.addListener(this);

        // wait for pipes to connect
        if (this.tttDialog != null) {
            new Thread(new Runnable() {

                public void run() {
                    while (!TicTacToeGameControl.this.tttDialog.isConnected()) {
                        try {
                            Thread.sleep(CONNECT_SLEEP_TIME);
                            if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
                                LOG.info("Waiting for is connected ");
                            }
                        }
                        catch (final InterruptedException ignored) {
                        }
                    }
                }
            }, getClass().getName() + ":isConnected").start();
        }

        this.generalTimer = new Timer(true);


    }

    public String getSessionStateString(final int sessionState) {

        return this.sessionStateTable.get(new Integer(sessionState));
    }

    public void initSession() {
        if (isLocallyInitiated()) {
            if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
                LOG.info("locally inititated");
            }

            this.setProtocolState(TicTacToeGameControl.SESSION_INVITE_REQUEST_SENT);
            this.sendCommand(TicTacToeGameControl.COMMAND_INVITE_REQUEST, TicTacToeGameControl.COMMAND_INVITE_ACCEPT);


            //generalTimer.schedule(roundTripTimerTask, this.ROUND_TRIP_INTERVAL, this.ROUND_TRIP_INTERVAL);
        } else {
            if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
                LOG.info("NOT locally inititated");
            }
        }
    }

    public void gameControl(final String command, final DialogMessage msg) {


        if (COMMAND_INVITE_REQUEST.equals(command)) {
            //call should be in disconnected state for this to happen

            if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
                LOG.info("gameControl : received " +
                        TicTacToeGameControl.COMMAND_INVITE_REQUEST +
                        " received");
            }
            if (getProtocolState() == TicTacToeGameControl.SESSION_DISCONNECTED) {

                setProtocolState(TicTacToeGameControl.SESSION_INVITE_REQUEST_RECEIVED);

                this.sendCommand(TicTacToeGameControl.COMMAND_INVITE_ACCEPT);

                setProtocolState(TicTacToeGameControl.SESSION_INVITE_ACCEPT_SENT);


            } else {
                if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
                    LOG.info("expected " +
                            TicTacToeGameControl.SESSION_DISCONNECTED + " got " +
                            command);
                }
            }

        } else if (COMMAND_INVITE_ACCEPT.equals(command)) {

            if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
                LOG.info("gameControl : received " +
                        TicTacToeGameControl.COMMAND_INVITE_ACCEPT +
                        " received");
            }


            if (getProtocolState() == TicTacToeGameControl.SESSION_INVITE_REQUEST_SENT) {

                updateAckThread(command);

                setProtocolState(TicTacToeGameControl.SESSION_INVITE_ACCEPT_RECEIVED);

                //we wait on user to config and send config out

            } else {
                if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
                    LOG.info("expected " +
                            TicTacToeGameControl.SESSION_INVITE_REQUEST_SENT +
                            " got " + command);
                }
            }

        } else if (COMMAND_CONFIG_REQUEST.equals(command)) {

            if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
                LOG.info("gameControl : received " +
                        TicTacToeGameControl.COMMAND_CONFIG_REQUEST +
                        " received");
            }


            if (getProtocolState() == TicTacToeGameControl.SESSION_INVITE_ACCEPT_SENT) {

                parseConfigMessage(msg);

                setProtocolState(TicTacToeGameControl.SESSION_CONFIG_REQUEST_RECEIVED);

                localActionConfigRequestReceived(msg);

                // wait on user to send config accept

            } else {
                if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
                    LOG.info("expected " +
                            TicTacToeGameControl.SESSION_INVITE_ACCEPT_SENT +
                            " - got " + command);
                }
            }

        } else if (COMMAND_CONFIG_ACCEPT.equals(command)) {

            if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
                LOG.info("gameControl : received " +
                        TicTacToeGameControl.COMMAND_CONFIG_ACCEPT +
                        " received");
            }


            if (getProtocolState() == TicTacToeGameControl.SESSION_CONFIG_REQUEST_SENT) {


                updateAckThread(command);

                parseConfigMessage(msg);

                setProtocolState(TicTacToeGameControl.SESSION_CONFIG_ACCEPT_RECEIVED);

                localActionConfigAcceptReceived(msg);


                setProtocolState(TicTacToeGameControl.SESSION_START_REQUEST_SENT);
                sendCommand(TicTacToeGameControl.COMMAND_START_GAME_REQUEST, TicTacToeGameControl.COMMAND_START_GAME_ACCEPT);


                /** remote player will make first move */

            } else {