tictactoegamecontrol.java

jxta官方例程

        
        
        if (LOG.isEnabledFor (Level.INFO)) {
            LOG.info ("Dispatch Move : "+ moveId);
        }
        
        final DialogMessage msg = (DialogMessage)this.templateMessage.clone ();
        
        final StringMessageElement commandElement = new StringMessageElement (
                TicTacToeGameControl.TAG_SESSION_COMMAND, TicTacToeGameControl.COMMAND_NEW_MOVE, null);
        
        msg.addMessageElement (TicTacToeGameControl.TAG_SESSION_COMMAND, commandElement);
        
        final StringMessageElement positionElement = new StringMessageElement (
                TicTacToeGameControl.TAG_POSITION_DATA, moveId, null);
        
        msg.addMessageElement (TicTacToeGameControl.TAG_POSITION_DATA, positionElement);
        
        this.tttDialog.dispatch (msg);
        
        
    }
    
    
    
    
    
    /**
     * callback from the view that local player has made a move, the ui has
     * already been updated
     * -the order of method calls is important here
     */
    public void localMoveMade (final String moveId)  {
        
        synchronized(this.localPlayerMoves) {
            this.localPlayerMoves.add (moveId);
            this.allMoves.add(moveId);
        }
        
        /** send move to remote peer */
        dispatchMove (moveId);
        
        final Object[] p = this.localPlayerMoves.toArray ();
        for (Object element : p) {
            System.out.print (element);
        }
        System.out.println ("");
        
        final int boardState = getLocalPlayerBoardState ();
        
        if (boardState == TicTacToeGameControl.GAME_DRAW) {
            
            this.setPlayersTurn (TicTacToeGameControl.SESSION_ENDED);
            
            
            
            setGameState (TicTacToeGameControl.GAME_DRAW);
            
            this.tttView.setGameDraw ();
            
            localActionEndGame ();
            
            
        }
        if ( boardState == TicTacToeGameControl.GAME_WON) {
            
            localActionEndGame ();
            
            this.setLocalPlayerTotalWins (this.localPlayerTotalWins+1);
            
            if (LOG.isEnabledFor (Level.INFO)) {
                LOG.info ("GameWon localPlayerWins : "+ this.localPlayerTotalWins);
            }
            
            setGameState (TicTacToeGameControl.GAME_WON);
            
            this.tttView.setLocalPlayerWon (this.winningSet);
            
            this.winningSet = null;
            
            setPlayersTurn (TicTacToeGameControl.SESSION_ENDED);
            
            
        }else {
            setPlayersTurn (TicTacToeGameControl.REMOTE_PLAYER);
        }
        
        
    }
    
    private void setGameState (final int gameStatus) {
        this.gameState = gameStatus;
    }
    /**
     * called when a message comes in from a remtoe peer
     */
    private void remoteMoveMade (final String moveId) {
        
        synchronized(this.remotePlayerMoves) {
            this.remotePlayerMoves.add (moveId);
            this.allMoves.add(moveId);
        }
        
        /** send remote move to UI */
        this.tttView.remoteMoveMade (moveId);
        
        final int boardState = getRemotePlayerBoardState ();
        
        if ( boardState == TicTacToeGameControl.GAME_DRAW) {
            
            if (LOG.isEnabledFor (Level.INFO)) {
                LOG.info ("GameLost remotePlayerWins : "+ this.remotePlayerTotalWins);
            }
            
            setGameState (TicTacToeGameControl.GAME_DRAW);
            
            this.tttView.setGameDraw ();
            
            localActionEndGame ();
            
            
            
            
        }else if ( boardState == TicTacToeGameControl.GAME_WON) {
            //relative to the remote player
            setGameState (TicTacToeGameControl.GAME_LOST);
            
            this.setRemotePlayerTotalWins (this.remotePlayerTotalWins+1);
            
            if (LOG.isEnabledFor (Level.INFO)) {
                LOG.info ("GameLost remotePlayerWins : "+ this.remotePlayerTotalWins);
            }
            
            this.tttView.setLocalPlayerLost (this.winningSet);
            
            this.winningSet = null;
            
            localActionEndGame ();
            
            
            
        }else{
            setPlayersTurn (TicTacToeGameControl.LOCAL_PLAYER);
        }
        
    }
    
    protected void localActionEndGame () {
        
        if(isLocallyInitiated ()) {
            
            sendCommand (TicTacToeGameControl.COMMAND_END_GAME_REQUEST,TicTacToeGameControl.COMMAND_END_GAME_ACCEPT);
            
            setProtocolState (TicTacToeGameControl.SESSION_END_REQUEST_SENT);
            
            setPlayersTurn (TicTacToeGameControl.SESSION_ENDED);
            
            this.localPlayerMoves.clear ();
            this.remotePlayerMoves.clear ();
            this.allMoves.clear();
        }
        
    }
    
    
    public void localActionInvitePeer () {
        
        if(this.getProtocolState () == TicTacToeGameControl.SESSION_DISCONNECTED) {
            
            sendCommand (TicTacToeGameControl.COMMAND_INVITE_REQUEST, TicTacToeGameControl.COMMAND_INVITE_ACCEPT);
            
            setProtocolState (TicTacToeGameControl.SESSION_INVITE_REQUEST_SENT);
            
        }
        
    }
    
    public boolean isLocallyInitiated () {
        
        return locallyInitiated;
    }
       
    
    protected int getGameState () {
        
        return this.gameState;
    }
    
    class GameEvent {
        
//        private String action = null;
//        private String originator = null;
//        private String moveId = null;
        
        private final static String ELEMENT_HEADER = "Jxta:TicTacToe";
        private final static String ELEMENT_ACTION = ELEMENT_HEADER + "Action";
        private final static String ELEMENT_ORIGINATOR = ELEMENT_HEADER + "Originator";
        private final static String ELEMENT_MOVEID = ELEMENT_HEADER + "MoveId";
        
        
        public GameEvent () {
        }
        
        public GameEvent (final Message m) {
//            this.action = getElement (m, ELEMENT_ACTION);
//            this.originator = getElement (m, ELEMENT_ORIGINATOR);
//            this.moveId = getElement (m, ELEMENT_MOVEID);
            
        }
        
        protected String getElement (final Message msg, final String tag) {
            
            final MessageElement me = msg.getMessageElement (tag);
            return me != null ? me.toString () : null;
            
        }
        
        
        public Message toMessage () {
            
            return null;
        }
        
    }
    
    /**
     *  Called from the UI. This methodnotify's GameControl the user accepted
     *  an invite to play.
     */
    
    public void viewActionAcceptInviteRequest () {
        
        sendCommand (TicTacToeGameControl.COMMAND_INVITE_ACCEPT);
        
        setProtocolState (TicTacToeGameControl.SESSION_INVITE_ACCEPT_SENT);
        
        
    }
    
    public String getRemotePlayerName () {
        
        return this.remotePlayerName;
        
    }
    
    protected void localActionConfigAcceptReceived (final DialogMessage msg) {
        
    }
    
    
    protected void localActionConfigRequestReceived (final DialogMessage msg) {
        if (LOG.isEnabledFor (Level.INFO)) {
            LOG.info ("localActionConfigRequestReceived");
        }
        if(this.configWaitTimerTask != null) {
            if (LOG.isEnabledFor (Level.INFO)) {
                LOG.info ("localActionConfigRequestReceived: cancel configWaitTimerTask");
            }
            this.configWaitTimerTask.cancel ();
        }
        
        if( this.isConfigured()) {
            
            localActionSendConfigAccept ();
        }else{
            //we wait for user to configure
        }
    }
        
    private void parseConfigMessage (final DialogMessage msg) {
        
        if (LOG.isEnabledFor (Level.INFO)) {
            LOG.info ("localActionReceivedIconCommand");
        }
        
        final MessageElement iconTypeElement = msg.getMessageElement (TicTacToeGameControl.TAG_ICON_TYPE);
        
        this.tttView.setRemotePlayerName (msg.getOriginator ());
        
        if(iconTypeElement != null) {
            if (LOG.isEnabledFor (Level.INFO)) {
                LOG.info ("iconTypeElement is not null");
            }
            
            
            if (true) {
                
                
                
                final String iconType = iconTypeElement.toString ();
                
                if (LOG.isEnabledFor (Level.INFO)) {                
                    LOG.info ("icontype is "+iconType);
                }
                
                if(iconType.equals (TicTacToeDialogPanel.ICON_TYPE_X)) {
                    
                    if (LOG.isEnabledFor (Level.INFO)) {
                        LOG.info ("iconType is iconX");
                    }
                    
                    this.tttView.setRemotePlayerIconType (TicTacToeDialogPanel.ICON_TYPE_X);
                    
                    this.tttView.setRemotePlayerIcon (this.tttView.getIconX ());
                    
                }else if(iconType.equals (TicTacToeDialogPanel.ICON_TYPE_O)) {
                    
                    if (LOG.isEnabledFor (Level.INFO)) {
                        LOG.info ("iconType is iconO");
                    }
                    
                    this.tttView.setRemotePlayerIconType (TicTacToeDialogPanel.ICON_TYPE_O);
                    
                    this.tttView.setRemotePlayerIcon (this.tttView.getIconO ());
                    
                }else if(iconType.equals (TicTacToeDialogPanel.ICON_TYPE_CUSTOM)) {
                    if (LOG.isEnabledFor (Level.INFO)) {
                        LOG.info ("icontype is custom");
                    }
                    
                    final MessageElement iconDataElement = msg.getMessageElement (TicTacToeGameControl.TAG_ICON_DATA);
                    
                    if(iconDataElement != null) {
                        if (LOG.isEnabledFor (Level.INFO)) {
                            LOG.info ("icondataelement is not null");
                        }
                        
                        if(iconDataElement instanceof ByteArrayMessageElement) {
                            if (LOG.isEnabledFor (Level.INFO)) {
                                LOG.info ("icondata element is a bytearray message element");
                            }
                            
                            final byte[] imageData = ((ByteArrayMessageElement) iconDataElement).getBytes ();
                            
                            this.tttView.setRemotePlayerIconType (TicTacToeDialogPanel.ICON_TYPE_CUSTOM);
                            
                            this.tttView.setRemotePlayerIcon (new ImageIcon(imageData));//this.getMemImage (imageData));
                            
                        }
                    }
                    
                }else{
                    if (LOG.isEnabledFor (Level.INFO)) {
                        LOG.info ("remote icontype unknown[" + iconType+"][" + TicTacToeDialogPanel.ICON_TYPE_X +"]");
                    }
                }
                
            }else{
                if (LOG.isEnabledFor (Level.INFO)) {
                    LOG.info ("icontypeelement not instance of bytearraymessageelement");
                }
            }
        }else {
            if (LOG.isEnabledFor (Level.INFO)) {
                LOG.info ("icontypeelement is null");
            }
        }
        
    }
    
    private void setConfigured (final boolean configured) {
        
        this.configured = configured;
    }
    
    private boolean isConfigured () {
        
        return this.configured;
    }
    
    public void viewActionConfigured () {
        
        this.setConfigured (true);
        
        if (LOG.isEnabledFor (Level.INFO)) {
            LOG.info ("viewActionConfigured");
        }
        
        if(isLocallyInitiated ()) {
            
            this.localActionSendConfigRequest ();
            
            if (LOG.isEnabledFor (Level.INFO)) {
                LOG.info ("viewActionConfigured: Locally initited");
            }
            
        }else{
            
            
            if (LOG.isEnabledFor (Level.INFO)) {
                LOG.info ("viewActionConfigured: NOT Locally initited");
            }
            
            if(this.getProtocolState () == SESSION_CONFIG_REQUEST_RECEIVED) {
                
                if (LOG.isEnabledFor (Level.INFO)) {
                    LOG.info ("viewActionConfigured: config request has been received");
                }
                
                localActionSendConfigAccept ();
                
            }else{
                
                if (LOG.isEnabledFor (Level.INFO)) {
                    LOG.info ("viewActionConfigured: config request has NOT been received. starting timer");
                }
                
                /** we'll wait 40 second for a config to come from the controlling
                 *  peer. if none arrives then we go down. */
                this.configWaitTimerTask = new TimerTask () {
                    public void run () {
                        if(getProtocolState () == SESSION_CONFIG_REQUEST_RECEIVED) {
                            
                            if (LOG.isEnabledFor (Level.INFO)) {
                                LOG.info ("configWaitTimerTask: CONFIG REQUEST Received");
                            }
                            
                            
                            localActionSendConfigAccept ();
                            
                        }else{
                            
                            if (LOG.isEnabledFor (Level.INFO)) {
                                LOG.info ("configWaitTimerTask: Timeout wating for remote config");
                            }
                            
                            destroy ();
                        }
                    }
                };
                
                this.generalTimer.schedule (this.configWaitTimerTask, CONFIG_WAIT_TIMOUT);
                
            }
            
            
        }
    }

    public void destroy () {
        
        
        if(this.getProtocolState () != TicTacToeGameControl.SESSION_DISCONNECTED) {