Changeset 28 for chess


Ignore:
Timestamp:
02/06/09 13:16:35 (13 years ago)
Author:
BegemoT
Message:

threading, network protocol, UI issues

Location:
chess
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • chess/chess.jad

    r27 r28  
    11MIDlet-1: Chess Game, , chess.ui.ChessMIDlet 
    2 MIDlet-Jar-Size: 310674 
     2MIDlet-Jar-Size: 311214 
    33MIDlet-Jar-URL: chess.jar 
    44MIDlet-Name: Chess 
  • chess/src/chess/MSG.properties

    r27 r28  
    11command.ok=OK 
     2command.cancel=\u041e\u0442\u043c\u0435\u043d\u0438\u0442\u044c 
     3 
    24command.yes=\u0414\u0430 
    35command.no=\u041d\u0435\u0442 
    4 command.exit=\u0412\u044b\u0445\u043e\u0434 
     6 
    57command.back=\u041d\u0430\u0437\u0430\u0434 
    6 command.cancel=\u041e\u0442\u043c\u0435\u043d\u0438\u0442\u044c 
    78command.refresh=\u041e\u0431\u043d\u043e\u0432\u0438\u0442\u044c 
    8 command.close=\u0417\u0430\u0432\u0435\u0440\u0448\u0438\u0442\u044c 
     9 
     10command.surrender=\u0421\u0434\u0430\u0442\u044c\u0441\u044f 
     11command.ask-for-draw=\u041f\u0440\u0435\u0434\u043b\u043e\u0436\u0438\u0442\u044c \u043d\u0438\u0447\u044c\u044e 
     12 
    913command.new-game=\u041d\u043e\u0432\u0430\u044f \u0438\u0433\u0440\u0430 
    1014command.join-game=\u041d\u0430\u0439\u0442\u0438 \u0438\u0433\u0440\u0443 
     15 
    1116command.help=\u0421\u043f\u0440\u0430\u0432\u043a\u0430 
     17command.exit=\u0412\u044b\u0445\u043e\u0434 
    1218 
    1319start-menu.title= \u041a\u0430\u0442\u0435\u0433\u043e\u0440\u0438\u0447\u0435\u0441\u043a\u0438 \u043f\u0440\u0438\u0432\u0435\u0442\u0441\u0442\u0432\u0443\u044e! 
     
    3137wait.for-opponent = \u041e\u0436\u0438\u0434\u0430\u0435\u043c \u0445\u043e\u0434 \u043f\u0440\u043e\u0442\u0438\u0432\u043d\u0438\u043a\u0430... 
    3238wait.for-connect = \u041e\u0436\u0438\u0434\u0430\u0435\u043c \u0441\u043e\u0435\u0434\u0438\u043d\u0435\u043d\u0438\u044f... 
     39wait.for-sync  = \u041f\u0435\u0440\u0435\u0434\u0430\u0435\u043c \u0441\u043e\u0441\u0442\u043e\u044f\u043d\u0438\u0435 \u0438\u0433\u0440\u044b... 
    3340wait.for-network  = \u041f\u0435\u0440\u0435\u0434\u0430\u0447\u0430 \u0434\u0430\u043d\u043d\u044b\u0445... 
    3441 
  • chess/src/chess/Util.java

    r27 r28  
    3131 
    3232    public static IRemote create() throws Exception { 
    33         return new BTRemote(); 
    34         //return new DebugRemote( 500, 500 ); 
     33        //return new BTRemote(); 
     34        return new DebugRemote( 500, 500 ); 
    3535    } 
    3636 
  • chess/src/chess/control/BaseController.java

    r25 r28  
    2323 */ 
    2424public class BaseController implements IConnectionListener, IUIListener { 
    25         public static final int WAITING_FOR_LOCAL = 0; 
    26         public static final int WAITING_FOR_NETWORK = 1; 
    27         public static final int WAITING_FOR_OPPONENT = 2; 
    28         public static final int WAITING_CONNECT = 3; 
    29  
    30         private final App app; 
    31         private final GameCanvas ui; 
    32         private final IGame game; 
    33         private final IRemoteNode node; 
    34         private Player player; 
    35  
    36         private final boolean master; 
    37  
    38         private int status; 
    39  
    40         private long lastTimeStamp = System.currentTimeMillis(); 
    41  
    42         private BaseController( final App app, 
    43                                 final GameCanvas ui, 
    44                                 final IGame game, 
    45                                 final Player player, 
    46                                 final IRemoteNode node ) throws IOException { 
    47                 this.app = app; 
    48                 this.ui = ui; 
    49                 this.game = game; 
    50                 this.player = player; 
    51                 this.node = node; 
    52                 game.setOwner( player ); 
    53  
    54                 master = ( player != null ); 
    55  
    56                 node.setListener( this ); 
    57                 node.start(); 
    58                 setStatus( WAITING_CONNECT ); 
    59  
    60                 ui.setUIListener( this ); 
    61                 if( master ) { 
    62                         sendLog( game, player, node ); 
    63                 } 
    64                 lastTimeStamp = System.currentTimeMillis(); 
    65         } 
    66  
    67         private void sendLog( final IGame game, 
    68                               final Player player, 
    69                               final IRemoteNode node ) { 
    70                 //ïðè ñîåäèíåíèè â ïåðâóþ î÷åðåäü ïåðåäàåì ïàðòíåðó ñîñòîÿíèå èãðû 
    71                 final Vector log = game.getActionsLog(); 
    72                 for( int i = 0; i < log.size(); i++ ) { 
    73                         final Action a = ( Action ) log.elementAt( i ); 
    74                         node.send( a ); 
    75                 } 
    76                 //çàòåì êåì îí èãðàåò 
    77                 node.send( new SystemAction( SystemAction.SET_PLAYER, player.opponent() ) ); 
    78  
    79                 /*ðåøàåì, êòî õîäèò*/ 
    80                 if( log.isEmpty() ) {//íà÷àëî èãðû - õîäÿò áåëûå 
    81                         if( player.isWhite() ) { 
    82                                 ui.setStatus( GameCanvas.ACTIVE ); 
    83                         } else { 
    84                                 node.send( new SystemAction( SystemAction.YOUR_TURN, player.opponent() ) ); 
    85                         } 
    86                 } else { 
    87                         final Action lastAction = ( Action ) log.elementAt( log.size() - 1 ); 
    88                         if( lastAction.getPlayer() == player ) { 
    89                                 ui.setStatus( GameCanvas.ACTIVE ); 
    90                         } else { 
    91                                 node.send( new SystemAction( SystemAction.YOUR_TURN, player.opponent() ) ); 
    92                         } 
    93                 } 
    94         } 
    95  
    96         public void connected() { 
    97                 //todo 
    98                 setStatus( WAITING_FOR_OPPONENT ); 
    99         } 
    100  
    101         public synchronized void received( final IDatagram data ) { 
    102                 if( data instanceof Action ) { 
    103                         processAction( ( Action ) data ); 
    104                 } else if( data instanceof SystemAction ) { 
    105                         final SystemAction sa = ( SystemAction ) data; 
    106                         processSystemAction( sa ); 
    107                 } else { 
    108                         throw new IllegalArgumentException( "Datagram " + data + " is in unknown format" ); 
    109                 } 
    110         } 
    111  
    112         protected void processAction( final Action a ) { 
    113                 game.doAction( a ); 
    114         } 
    115  
    116         protected synchronized void processSystemAction( final SystemAction sa ) { 
    117                 if( sa.type() == SystemAction.SET_PLAYER ) { 
    118                         player = sa.getPlayer(); 
    119                         game.setOwner( player ); 
    120                         if( isMaster() ) { 
    121                                 throw new IllegalStateException( "Master should not got SET_PLAYER commands" ); 
    122                         } 
    123                         setStatus( WAITING_FOR_OPPONENT ); 
    124                 } else if( sa.type() == SystemAction.YOUR_TURN ) { 
    125                         if( player == null ) { 
    126                                 throw new IllegalStateException( "Player == null" ); 
    127                         } 
    128                         //if ( !master ) { 
    129                         //    synchronized ( this ) { 
    130                         //        notifyAll(); 
    131                         //    } 
    132                         //} 
    133                         lastTimeStamp = System.currentTimeMillis(); 
    134                         setStatus( WAITING_FOR_LOCAL ); 
    135                 } else if( sa.type() == SystemAction.SURRENDER ) { 
    136                         final ChessMIDlet midlet = app.getMidlet(); 
    137                         setStatus( WAITING_FOR_LOCAL ); 
    138                         midlet.display.setCurrent( 
    139                                         new Alert( "Opponent surrenders. You win." ), 
    140                                         midlet.startForm 
    141                         ); 
    142                 } else if( sa.type() == SystemAction.ASK_FOR_DRAW ) { 
    143                         //todo implement 
    144                 } 
    145         } 
    146  
    147         public synchronized void wasSent( final IDatagram data ) { 
    148                 if( status == WAITING_FOR_NETWORK ) { 
    149                         setStatus( WAITING_FOR_OPPONENT ); 
    150                 } 
    151         } 
    152  
    153         public void closed() { 
    154                 setStatus( WAITING_CONNECT ); 
    155         } 
    156  
    157         public void post( final IDatagram data ) { 
    158                 setStatus( WAITING_FOR_NETWORK ); 
    159                 node.send( data ); 
    160         } 
    161  
    162         public synchronized void setStatus( final int status ) { 
    163                 //todo 
    164                 this.status = status; 
    165                 switch( status ) { 
    166                         case WAITING_FOR_LOCAL: 
    167                                 ui.setStatus( GameCanvas.ACTIVE ); 
    168                                 break; 
    169                         case WAITING_FOR_NETWORK: 
    170                                 ui.setStatus( GameCanvas.WAITING_FOR_NETWORK ); 
    171                                 break; 
    172                         case WAITING_FOR_OPPONENT: 
    173                                 ui.setStatus( GameCanvas.WAITING_FOR_OPPONENT ); 
    174                                 break; 
    175                         case WAITING_CONNECT: 
    176                                 ui.setStatus( GameCanvas.NOT_CONNECTED ); 
    177                                 break; 
    178                         default: 
    179                                 throw new IllegalStateException( "Unknown status:" + status ); 
    180                 } 
    181         } 
    182  
    183         public boolean isMaster() { 
    184                 return master; 
    185         } 
    186  
    187         public void keyPressed( final int code ) { 
    188                 ui.clearHighlightedCells(); 
    189                 final Location prevFC = ui.getFocusedCell(); 
    190                 int x, y; 
    191                 if( prevFC == null ) { 
    192                         x = y = 0; 
    193                 } else { 
    194                         x = prevFC.x; 
    195                         y = prevFC.y; 
    196                 } 
    197                 if( code == ui.leftKey ) { 
    198                         x -= 1; 
    199                         if( x < 0 ) { 
    200                                 x = game.getWidth() - 1; 
    201                         } 
    202                 } else if( code == ui.rightKey ) { 
    203                         x += 1; 
    204                         if( x >= game.getWidth() ) { 
    205                                 x = 0; 
    206                         } 
    207                 } else if( code == ui.downKey ) { 
    208                         y -= 1; 
    209                         if( y < 0 ) { 
    210                                 y = game.getHeight() - 1; 
    211                         } 
    212  
    213                 } else if( code == ui.upKey ) { 
    214                         y += 1; 
    215                         if( y >= game.getHeight() ) { 
    216                                 y = 0; 
    217                         } 
    218                 } 
    219  
    220                 final Location selectedCell = ui.getSelectedCell(); 
    221                 if( selectedCell == null ) { 
    222                         final Location focused = new Location( x, y ); 
    223                         ui.setFocusedCell( focused ); 
    224                         final IUnit unit = game.getUnit( focused ); 
    225                         if( unit != null ) { 
    226                                 highlightDomain( unit ); 
    227                         } 
    228  
    229                         if( code == ui.fireKey 
    230                                         && unit != null 
    231                                         && unit.getOwner() == player ) { 
    232                                 ui.setSelectedCell( focused ); 
    233                                 ui.setFocusedCell( focused ); 
    234  
    235                                 ui.addCommand( app.getMidlet().backCommand ); 
    236                         } 
    237                 } else { 
    238                         final IUnit unit = game.getUnit( selectedCell ); 
    239                         if( unit != null ) { 
    240                                 final Location[] domain = highlightDomain( unit ); 
    241                                 //final int index = findNearest( domain, x, y ); 
    242                                 //if ( index >= 0 ) { 
    243                                 //    ui.setFocusedCell( domain[index] ); 
    244                                 //} 
    245                                 final Location _fc = new Location( x, y ); 
    246                                 ui.setFocusedCell( _fc ); 
    247                                 if( code == ui.fireKey ) { 
    248                                         if( selectedCell.equals( _fc ) ) { 
    249                                                 ui.setSelectedCell( null ); 
    250                                                 ui.removeCommand( app.getMidlet().backCommand ); 
    251                                         } else { 
    252                                                 boolean inDomain = false; 
    253                                                 for( int i = 0; i < domain.length; i++ ) { 
    254                                                         final Location ld = domain[i]; 
    255                                                         if( ld.equals( _fc ) ) { 
    256                                                                 inDomain = true; 
    257                                                                 break; 
    258                                                         } 
    259                                                 } 
    260                                                 if( inDomain ) { 
    261                                                         final Location focusedCell = ui.getFocusedCell(); 
    262  
    263                                                         ui.setFocusedCell( null ); 
    264                                                         ui.setSelectedCell( null ); 
    265                                                         ui.clearHighlightedCells(); 
    266  
    267                                                         ui.removeCommand( app.getMidlet().backCommand ); 
    268  
    269  
    270                                                         postAction( selectedCell, focusedCell ); 
    271                                                 } 
    272                                         } 
    273                                 } 
    274                         } else { 
    275                                 ui.setSelectedCell( null ); 
    276                         } 
    277  
    278                 } 
    279         } 
    280  
    281         private void postAction( final Location from, 
    282                                  final Location to ) { 
    283                 final Action action = new Action( 
    284                                 player, 
    285                                 System.currentTimeMillis() - lastTimeStamp, 
    286                                 from, 
    287                                 to 
    288                 ); 
    289                 game.doAction( action ); 
    290                 postAction( action ); 
    291         } 
    292  
    293         private void postAction( final Action action ) { 
    294                 post( action ); 
    295                 post( new SystemAction( SystemAction.YOUR_TURN, player ) ); 
    296         } 
    297  
    298         public void commandAction( final Command c, 
    299                                    final Displayable d ) { 
    300                 final ChessMIDlet midlet = app.getMidlet(); 
    301                 if( c == midlet.backCommand ) { 
    302                         ui.removeCommand( c ); 
    303                         ui.setSelectedCell( null ); 
    304                         ui.clearHighlightedCells(); 
    305                 } else if( c == midlet.cancelCommand && d == ui.waitScreen ) { 
    306                         if( status == WAITING_CONNECT ) { 
    307                                 //fixme: òóò ïîäñòàâà -- ïîõîæå, deadlock 
    308                                 node.close(); 
    309                                 midlet.searchGame(); 
    310                         } 
    311                 } 
    312         } 
    313  
    314         private Location[] highlightDomain( final IUnit unit ) { 
    315                 final Location[] available = unit.canMoveTo(); 
    316                 for( int i = 0; i < available.length; i++ ) { 
    317                         final Location l = available[i]; 
    318                         final IUnit u = game.getUnit( l ); 
    319                         final boolean attack = u != null && unit.isOpponent( u ); 
    320                         ui.addHighlightedCell( l, attack ); 
    321                 } 
    322                 return available; 
    323         } 
    324  
    325         public static BaseController createClient( final App app, 
    326                                                    final GameCanvas ui, 
    327                                                    final IGame game, 
    328                                                    final IRemoteNode node ) throws IOException { 
    329                 return new BaseController( app, ui, game, null, node ); 
    330         } 
    331  
    332         public static BaseController createMaster( final App app, 
    333                                                    final GameCanvas ui, 
    334                                                    final IGame game, 
    335                                                    final Player player, 
    336                                                    final IRemoteNode node ) throws IOException { 
    337                 return new BaseController( app, ui, game, player, node ); 
    338         } 
     25    public static final int WAITING_FOR_LOCAL = 0; 
     26    public static final int WAITING_FOR_SYNC = 1; 
     27    public static final int WAITING_FOR_NETWORK = 2; 
     28    public static final int WAITING_FOR_OPPONENT = 3; 
     29    public static final int WAITING_CONNECT = 4; 
     30 
     31    private final App app; 
     32    private final GameCanvas ui; 
     33    private final IGame game; 
     34    private final IRemoteNode node; 
     35    private Player player; 
     36 
     37    private final boolean master; 
     38 
     39    private int status; 
     40 
     41    private long lastTimeStamp = System.currentTimeMillis(); 
     42 
     43    private BaseController( final App app, 
     44                            final GameCanvas ui, 
     45                            final IGame game, 
     46                            final Player player, 
     47                            final IRemoteNode node ) throws IOException { 
     48        this.app = app; 
     49        this.ui = ui; 
     50        this.game = game; 
     51        this.player = player; 
     52        this.node = node; 
     53        game.setOwner( player ); 
     54 
     55        master = ( player != null ); 
     56 
     57        setStatus( WAITING_CONNECT ); 
     58        node.setListener( this ); 
     59        node.start(); 
     60 
     61        ui.setUIListener( this ); 
     62        lastTimeStamp = System.currentTimeMillis(); 
     63    } 
     64 
     65    private void sendLog( final IGame game, 
     66                          final Player player, 
     67                          final IRemoteNode node ) { 
     68        //ïåðåäàåì êåì îí èãðàåò 
     69        node.send( SystemAction.setPlayer( player.opponent() ) ); 
     70        //ïåðåäàåì ïåðåäàåì ïàðòíåðó ñîñòîÿíèå èãðû 
     71        final Vector log = game.getActionsLog(); 
     72        for ( int i = 0; i < log.size(); i++ ) { 
     73            final Action a = ( Action )log.elementAt( i ); 
     74            node.send( a ); 
     75        } 
     76    } 
     77 
     78    public void connected() { 
     79        if ( status == WAITING_CONNECT ) { 
     80            if ( master ) { 
     81                setStatus( WAITING_FOR_SYNC ); 
     82            } else { 
     83                setStatus( WAITING_FOR_OPPONENT ); 
     84            } 
     85        } 
     86        if ( master ) { 
     87            sendLog( game, player, node ); 
     88            /*ðåøàåì, êòî õîäèò*/ 
     89            final Vector log = game.getActionsLog(); 
     90            if ( log.isEmpty() ) {//íà÷àëî èãðû - õîäÿò áåëûå 
     91                if ( player.isWhite() ) { 
     92                    setStatus( WAITING_FOR_LOCAL ); 
     93                } else { 
     94                    node.send( SystemAction.yourTurn( player.opponent() ) ); 
     95                } 
     96            } else { 
     97                final Action lastAction = ( Action )log.elementAt( log.size() - 1 ); 
     98                if ( lastAction.getPlayer() == player ) { 
     99                    setStatus( WAITING_FOR_LOCAL ); 
     100                } else { 
     101                    node.send( SystemAction.yourTurn( player.opponent() ) ); 
     102                } 
     103            } 
     104 
     105        } 
     106    } 
     107 
     108    public synchronized void received( final IDatagram data ) { 
     109        if ( data instanceof Action ) { 
     110            processAction( ( Action )data ); 
     111        } else if ( data instanceof SystemAction ) { 
     112            final SystemAction sa = ( SystemAction )data; 
     113            processSystemAction( sa ); 
     114        } else { 
     115            throw new IllegalArgumentException( "Datagram " + data + " is in unknown format" ); 
     116        } 
     117    } 
     118 
     119    protected void processAction( final Action a ) { 
     120        game.doAction( a ); 
     121    } 
     122 
     123    protected synchronized void processSystemAction( final SystemAction sa ) { 
     124        if ( sa.type() == SystemAction.SET_PLAYER ) { 
     125            player = sa.getPlayer(); 
     126            game.setOwner( player ); 
     127            if ( isMaster() ) { 
     128                throw new IllegalStateException( "Master should not got SET_PLAYER commands" ); 
     129            } 
     130            setStatus( WAITING_FOR_OPPONENT ); 
     131        } else if ( sa.type() == SystemAction.YOUR_TURN ) { 
     132            if ( player == null ) { 
     133                throw new IllegalStateException( "Player == null" ); 
     134            } 
     135            //if ( !master ) { 
     136            //    synchronized ( this ) { 
     137            //        notifyAll(); 
     138            //    } 
     139            //} 
     140            lastTimeStamp = System.currentTimeMillis(); 
     141            setStatus( WAITING_FOR_LOCAL ); 
     142        } else if ( sa.type() == SystemAction.SURRENDER ) { 
     143            final ChessMIDlet midlet = app.getMidlet(); 
     144            setStatus( WAITING_FOR_LOCAL ); 
     145            midlet.display.setCurrent( 
     146                    new Alert( "Opponent surrenders. You win." ), 
     147                    midlet.startForm 
     148            ); 
     149        } else if ( sa.type() == SystemAction.ASK_FOR_DRAW ) { 
     150            //todo implement 
     151        } 
     152    } 
     153 
     154    public synchronized void wasSent( final IDatagram data ) { 
     155        if ( status == WAITING_FOR_NETWORK ) { 
     156            setStatus( WAITING_FOR_OPPONENT ); 
     157        } 
     158    } 
     159 
     160    public void closed() { 
     161        setStatus( WAITING_CONNECT ); 
     162    } 
     163 
     164    public void post( final IDatagram data ) { 
     165        setStatus( WAITING_FOR_NETWORK ); 
     166        node.send( data ); 
     167    } 
     168 
     169    public synchronized void setStatus( final int status ) { 
     170        //todo 
     171        this.status = status; 
     172        switch ( status ) { 
     173            case WAITING_FOR_LOCAL: 
     174                ui.setStatus( GameCanvas.ACTIVE ); 
     175                break; 
     176            case WAITING_FOR_NETWORK: 
     177                ui.setStatus( GameCanvas.WAITING_FOR_NETWORK ); 
     178                break; 
     179            case WAITING_FOR_SYNC: 
     180                ui.setStatus( GameCanvas.WAITING_FOR_SYNC ); 
     181                break; 
     182            case WAITING_FOR_OPPONENT: 
     183                ui.setStatus( GameCanvas.WAITING_FOR_OPPONENT ); 
     184                break; 
     185            case WAITING_CONNECT: 
     186                ui.setStatus( GameCanvas.NOT_CONNECTED ); 
     187                break; 
     188            default: 
     189                throw new IllegalStateException( "Unknown status:" + status ); 
     190        } 
     191    } 
     192 
     193    public boolean isMaster() { 
     194        return master; 
     195    } 
     196 
     197    public void keyPressed( final int code ) { 
     198        ui.clearHighlightedCells(); 
     199        final Location prevFC = ui.getFocusedCell(); 
     200        int x, y; 
     201        if ( prevFC == null ) { 
     202            x = y = 0; 
     203        } else { 
     204            x = prevFC.x; 
     205            y = prevFC.y; 
     206        } 
     207        if ( code == ui.leftKey ) { 
     208            x -= 1; 
     209            if ( x < 0 ) { 
     210                x = game.getWidth() - 1; 
     211            } 
     212        } else if ( code == ui.rightKey ) { 
     213            x += 1; 
     214            if ( x >= game.getWidth() ) { 
     215                x = 0; 
     216            } 
     217        } else if ( code == ui.downKey ) { 
     218            y -= 1; 
     219            if ( y < 0 ) { 
     220                y = game.getHeight() - 1; 
     221            } 
     222 
     223        } else if ( code == ui.upKey ) { 
     224            y += 1; 
     225            if ( y >= game.getHeight() ) { 
     226                y = 0; 
     227            } 
     228        } 
     229 
     230        final Location selectedCell = ui.getSelectedCell(); 
     231        if ( selectedCell == null ) { 
     232            final Location focused = new Location( x, y ); 
     233            ui.setFocusedCell( focused ); 
     234            final IUnit unit = game.getUnit( focused ); 
     235            if ( unit != null ) { 
     236                highlightDomain( unit ); 
     237            } 
     238 
     239            if ( code == ui.fireKey 
     240                    && unit != null 
     241                    && unit.getOwner() == player ) { 
     242                ui.setSelectedCell( focused ); 
     243                ui.setFocusedCell( focused ); 
     244 
     245                ui.addCommand( app.getMidlet().backCommand ); 
     246            } 
     247        } else { 
     248            final IUnit unit = game.getUnit( selectedCell ); 
     249            if ( unit != null ) { 
     250                final Location[] domain = highlightDomain( unit ); 
     251                //final int index = findNearest( domain, x, y ); 
     252                //if ( index >= 0 ) { 
     253                //    ui.setFocusedCell( domain[index] ); 
     254                //} 
     255                final Location _fc = new Location( x, y ); 
     256                ui.setFocusedCell( _fc ); 
     257                if ( code == ui.fireKey ) { 
     258                    if ( selectedCell.equals( _fc ) ) { 
     259                        ui.setSelectedCell( null ); 
     260                        ui.removeCommand( app.getMidlet().backCommand ); 
     261                    } else { 
     262                        boolean inDomain = false; 
     263                        for ( int i = 0; i < domain.length; i++ ) { 
     264                            final Location ld = domain[i]; 
     265                            if ( ld.equals( _fc ) ) { 
     266                                inDomain = true; 
     267                                break; 
     268                            } 
     269                        } 
     270                        if ( inDomain ) { 
     271                            final Location focusedCell = ui.getFocusedCell(); 
     272 
     273                            ui.setFocusedCell( null ); 
     274                            ui.setSelectedCell( null ); 
     275                            ui.clearHighlightedCells(); 
     276 
     277                            ui.removeCommand( app.getMidlet().backCommand ); 
     278 
     279 
     280                            postAction( selectedCell, focusedCell ); 
     281                        } 
     282                    } 
     283                } 
     284            } else { 
     285                ui.setSelectedCell( null ); 
     286            } 
     287 
     288        } 
     289    } 
     290 
     291    private void postAction( final Location from, 
     292                             final Location to ) { 
     293        final Action action = new Action( 
     294                player, 
     295                System.currentTimeMillis() - lastTimeStamp, 
     296                from, 
     297                to 
     298        ); 
     299        game.doAction( action ); 
     300        postAction( action ); 
     301    } 
     302 
     303    private void postAction( final Action action ) { 
     304        post( action ); 
     305        post( SystemAction.yourTurn( player.opponent() ) ); 
     306    } 
     307 
     308    private void postSurrender() { 
     309        post( SystemAction.surrender( player ) ); 
     310    } 
     311 
     312    public void commandAction( final Command c, 
     313                               final Displayable d ) { 
     314        final ChessMIDlet midlet = app.getMidlet(); 
     315        if ( d == ui.waitScreen ) { 
     316            if ( c == midlet.cancelCommand ) { 
     317                if ( status == WAITING_CONNECT ) { 
     318                    //fixme: òóò ïîäñòàâà -- ïîõîæå, deadlock 
     319                    node.close(); 
     320                    midlet.searchGame(); 
     321                } 
     322            } 
     323        } 
     324        if ( d == ui ) { 
     325            if ( c == midlet.backCommand ) { 
     326                ui.removeCommand( c ); 
     327                ui.setSelectedCell( null ); 
     328                ui.clearHighlightedCells(); 
     329            } else if ( c == ui.surrenderCommand ) { 
     330                postSurrender(); 
     331                node.close(); 
     332                midlet.showStartScreen(); 
     333            } else if ( c == ui.askForDrawCommand ) { 
     334                //todo implement 
     335            } 
     336        } 
     337    } 
     338 
     339    private Location[] highlightDomain( final IUnit unit ) { 
     340        final Location[] available = unit.canMoveTo(); 
     341        for ( int i = 0; i < available.length; i++ ) { 
     342            final Location l = available[i]; 
     343            final IUnit u = game.getUnit( l ); 
     344            final boolean attack = u != null && unit.isOpponent( u ); 
     345            ui.addHighlightedCell( l, attack ); 
     346        } 
     347        return available; 
     348    } 
     349 
     350    public static BaseController createClient( final App app, 
     351                                               final GameCanvas ui, 
     352                                               final IGame game, 
     353                                               final IRemoteNode node ) throws IOException { 
     354        return new BaseController( app, ui, game, null, node ); 
     355    } 
     356 
     357    public static BaseController createMaster( final App app, 
     358                                               final GameCanvas ui, 
     359                                               final IGame game, 
     360                                               final Player player, 
     361                                               final IRemoteNode node ) throws IOException { 
     362        return new BaseController( app, ui, game, player, node ); 
     363    } 
    339364} 
  • chess/src/chess/control/SystemAction.java

    r14 r28  
    109109        } 
    110110    } 
     111 
     112    /** 
     113     * @param p ÷åé õîä òåïåðü 
     114     * @return 
     115     */ 
     116    public static SystemAction yourTurn( final Player p ) { 
     117        return new SystemAction( YOUR_TURN, p ); 
     118    } 
     119 
     120    /** 
     121     * @param p êåì èãðàåò òîò, êîìó àäðåñîâàíî ñîîáùåíè 
     122     * @return 
     123     */ 
     124    public static SystemAction setPlayer( final Player p ) { 
     125        return new SystemAction( SET_PLAYER, p ); 
     126    } 
     127 
     128    /** 
     129     * @param p êòî ñäàåòñÿ 
     130     * @return 
     131     */ 
     132    public static SystemAction surrender( final Player p ) { 
     133        return new SystemAction( SURRENDER, p ); 
     134    } 
     135 
     136    /** 
     137     * @param p êòî ïðåäëàãàåò íè÷üþ 
     138     * @return 
     139     */ 
     140    public static SystemAction askForDraw( final Player p ) { 
     141        return new SystemAction( ASK_FOR_DRAW, p ); 
     142    } 
    111143} 
  • chess/src/chess/remote/impl/debug/DebugRemote.java

    r27 r28  
    7676        ); 
    7777        new GenericDatagram( a ).write( out ); 
    78         final SystemAction yourTurnAction = new SystemAction( 
    79                 SystemAction.YOUR_TURN, 
    80                 player 
    81         ); 
     78        final SystemAction yourTurnAction = SystemAction.yourTurn( player.opponent() ); 
    8279        new GenericDatagram( yourTurnAction ).write( out ); 
    8380    } 
     
    154151                            listener.connected(); 
    155152                        } 
    156                     }, networkLatency 
     153                    }, 
     154                    networkLatency 
    157155            ); 
    158156        } 
     
    192190                                                ); 
    193191                                            } else { 
    194                                                 listener.received( new SystemAction( SystemAction.SURRENDER, player ) ); 
     192                                                listener.received( SystemAction.surrender( player ) ); 
    195193                                            } 
    196194                                        } catch ( Exception e ) { 
     
    242240                    Util.log.println( name + ": sending SET_PLAYER" ); 
    243241                    listener.received( 
    244                             new SystemAction( 
    245                                     SystemAction.SET_PLAYER, 
    246                                     player.opponent() 
    247                             ) 
     242                            SystemAction.setPlayer( player.opponent() ) 
    248243                    ); 
    249244                    if ( player == Player.WHITE ) { 
     
    251246                    } else { 
    252247                        listener.received( 
    253                                 new SystemAction( 
    254                                         SystemAction.YOUR_TURN, 
    255                                         player 
    256                                 ) 
     248                                SystemAction.yourTurn( player.opponent() ) 
    257249                        ); 
    258250                        //èíà÷å æäåì YOUR_TURN îò áåëûõ 
     
    318310                    ); 
    319311                } else { 
    320                     listener.received( new SystemAction( SystemAction.SURRENDER, player ) ); 
     312                    listener.received( SystemAction.surrender( player ) ); 
    321313                } 
    322314            } catch ( Exception e ) { 
  • chess/src/chess/ui/ChessMIDlet.java

    r27 r28  
    2525 
    2626    /* commands */ 
    27     public final Command okCommand = new Command( MSG.getMessage( "command.ok" ), Command.OK, 1 ); 
    2827    public final Command yesCommand = new Command( MSG.getMessage( "command.yes" ), Command.OK, 1 ); 
    2928    public final Command noCommand = new Command( MSG.getMessage( "command.no" ), Command.CANCEL, 1 ); 
     29 
     30    public final Command okCommand = new Command( MSG.getMessage( "command.ok" ), Command.OK, 1 ); 
     31    public final Command cancelCommand = new Command( MSG.getMessage( "command.cancel" ), Command.CANCEL, 1 ); 
     32 
     33    public final Command backCommand = new Command( MSG.getMessage( "command.back" ), Command.BACK, 1 ); 
     34 
     35    public final Command refreshCommand = new Command( MSG.getMessage( "command.refresh" ), Command.SCREEN, 1 ); 
     36 
     37    public final Command newCommand = new Command( MSG.getMessage( "command.new" ), Command.SCREEN, 1 ); 
     38 
     39    public final Command joinCommand = new Command( MSG.getMessage( "command.join" ), Command.SCREEN, 1 ); 
     40 
     41    public final Command helpCommand = new Command( MSG.getMessage( "command.help" ), Command.HELP, 1 ); 
     42 
    3043    public final Command exitCommand = new Command( MSG.getMessage( "command.exit" ), Command.EXIT, 1 ); 
    31     public final Command closeCommand = new Command( MSG.getMessage( "command.close" ), Command.STOP, 1 ); 
    32     public final Command cancelCommand = new Command( MSG.getMessage( "command.cancel" ), Command.CANCEL, 1 ); 
    33     public final Command backCommand = new Command( MSG.getMessage( "command.back" ), Command.BACK, 1 ); 
    34     public final Command refreshCommand = new Command( MSG.getMessage( "command.refresh" ), Command.SCREEN, 1 ); 
    35     public final Command newCommand = new Command( MSG.getMessage( "command.new" ), Command.SCREEN, 1 ); 
    36     public final Command joinCommand = new Command( MSG.getMessage( "command.join" ), Command.SCREEN, 1 ); 
    37     public final Command helpCommand = new Command( MSG.getMessage( "command.help" ), Command.HELP, 1 ); 
    3844 
    3945    /* GUI */ 
     
    126132                new IServerListener() { 
    127133                    private boolean retValue = false; 
     134                    private IRemoteNode client; 
    128135 
    129136                    public synchronized boolean incoming( final IRemoteNode client ) { 
     
    137144                                AlertType.CONFIRMATION 
    138145                        ); 
    139                         dlg.setTimeout( Alert.FOREVER ); 
     146                        //dlg.setTimeout( Alert.FOREVER ) is implicitly set if 
     147                        //Alert has 2 or more commands -- see javadoc 
    140148                        dlg.addCommand( yesCommand ); 
    141149                        dlg.addCommand( noCommand ); 
    142                         //dlg.removeCommand( Alert.DISMISS_COMMAND ); 
    143150                        dlg.setCommandListener( 
    144151                                new CommandListener() { 
     
    170177                        } 
    171178                        if ( retValue ) { 
    172                             try { 
    173                                 app = new App( 
    174                                         ChessMIDlet.this, 
    175                                         new Game(), 
    176                                         gameCanvas, 
    177                                         client, 
    178                                         player 
    179                                 ); 
    180                                 Util.log.println( "joined client" ); 
    181                             } catch ( Exception e ) { 
    182                                 e.printStackTrace(); 
    183                             } 
     179                            this.client = client; 
    184180                        } 
    185181                        return retValue; 
     
    192188                            case IAsyncProcess.SUCCEEDED: 
    193189                                waitScreen.finished( res ); 
     190                                try { 
     191                                    app = new App( 
     192                                            ChessMIDlet.this, 
     193                                            new Game(), 
     194                                            gameCanvas, 
     195                                            client, 
     196                                            player 
     197                                    ); 
     198                                    Util.log.println( "joined client" ); 
     199                                } catch ( Exception e ) { 
     200                                    e.printStackTrace(); 
     201                                } 
    194202                                break; 
    195203                            case IAsyncProcess.FAILED: 
    196                                 final Alert alert = new Alert( "Error", "Error in starting server", null, AlertType.ERROR ); 
     204                                final Alert alert = new Alert( 
     205                                        "Error", 
     206                                        "Error in starting server", 
     207                                        null, 
     208                                        AlertType.ERROR 
     209                                ); 
    197210                                display.setCurrent( alert, startForm ); 
    198211                                break; 
  • chess/src/chess/ui/GameCanvas.java

    r25 r28  
    1717 */ 
    1818public class GameCanvas extends Canvas implements CommandListener, IGameListener { 
    19         public static final int ACTIVE = 0; 
    20         public static final int WAITING_FOR_NETWORK = 1; 
    21         public static final int WAITING_FOR_OPPONENT = 2; 
    22         public static final int NOT_CONNECTED = 3; 
    23  
    24         private static final char[] COLUMNS = new char[] { 
    25                         'A', 'B', 'C', 'D', 'E', 'F', 'J', 'H' 
    26         }; 
    27         private static final char[] ROWS = new char[] { 
    28                         '1', '2', '3', '4', '5', '6', '7', '8' 
    29         }; 
    30  
    31         protected final ChessMIDlet midlet; 
    32  
    33         public final int fireKey; 
    34         public final int leftKey; 
    35         public final int rightKey; 
    36         public final int upKey; 
    37         public final int downKey; 
    38  
    39         //protected Player player; 
    40         protected IGame game; 
    41  
    42         private int status = ACTIVE; 
    43  
    44         private Location focusedCell; 
    45         private Location selectedCell; 
    46  
    47         //bitwise masks -- 1 bit per cell 
    48         private final BitSet64 highlightedCells = new BitSet64(); 
    49         private final BitSet64 attackedCells = new BitSet64(); 
    50  
    51         private IUIListener listener = null; 
    52         private transient int vMargin; 
    53         private transient int hMargin; 
    54         private transient int cellSize; 
    55  
    56  
    57         private static final int MARGIN = 1; 
    58         //colors 
    59         private static final int BG_COLOR = 0xFFFFFF; 
    60         private static final int LABELS_COLOR = 0; 
    61  
    62         public final WaitScreen waitScreen; 
    63  
    64         public final Command surrenderCommand = new Command( MSG.getMessage( "command.surrender" ), Command.CANCEL, 1 ); 
    65         public final Command askForDrawCommand = new Command( MSG.getMessage( "command.ask-for-draw" ), Command.SCREEN, 1 ); 
    66  
    67         public GameCanvas( final ChessMIDlet midlet ) { 
    68                 this.midlet = midlet; 
    69                 fireKey = getKeyCode( FIRE ); 
    70                 leftKey = getKeyCode( LEFT ); 
    71                 rightKey = getKeyCode( RIGHT ); 
    72                 upKey = getKeyCode( UP ); 
    73                 downKey = getKeyCode( DOWN ); 
    74  
    75                 waitScreen = new WaitScreen( 
    76                                 midlet, 
    77                                 MSG.getMessage( "wait.title" ), 
    78                                 this 
    79                 ); 
    80                 waitScreen.addCommand( midlet.cancelCommand ); 
    81                 waitScreen.setCommandListener( this ); 
    82  
    83                 addCommand( midlet.closeCommand ); 
    84                 addCommand( surrenderCommand ); 
    85                 addCommand( askForDrawCommand ); 
    86                 addCommand( midlet.helpCommand ); 
    87                 setCommandListener( this ); 
    88         } 
    89  
    90         public void init( final IGame game ) { 
    91                 if( this.game != null ) { 
    92                         this.game.setListener( null ); 
    93                 } 
    94                 this.game = game; 
    95                 game.setListener( this ); 
    96         } 
    97  
    98         public void setUIListener( final IUIListener listener ) { 
    99                 this.listener = listener; 
    100         } 
    101  
    102         public Location getFocusedCell() { 
    103                 return focusedCell; 
    104         } 
    105  
    106         public void setFocusedCell( final Location l ) { 
    107                 if( focusedCell == null && l == null ) { 
    108                         //nothing 
    109                 } else if( focusedCell == null ) { 
    110                         focusedCell = l; 
    111                         repaintCell( l.x, l.y ); 
    112                 } else if( l == null ) { 
    113                         repaintCell( focusedCell.x, focusedCell.y ); 
    114                         focusedCell = l; 
    115                 } else { 
    116                         final Location old = focusedCell; 
    117                         focusedCell = l; 
    118                         repaintCell( old.x, old.y ); 
    119                         repaintCell( l.x, l.y ); 
    120                 } 
    121         } 
    122  
    123         public Location getSelectedCell() { 
    124                 return selectedCell; 
    125         } 
    126  
    127         public void setSelectedCell( final Location l ) { 
    128                 if( selectedCell == null && l == null ) { 
    129                         //nothing 
    130                 } else if( selectedCell == null ) { 
    131                         selectedCell = l; 
    132                         repaintCell( l.x, l.y ); 
    133                 } else if( l == null ) { 
    134                         repaintCell( selectedCell.x, selectedCell.y ); 
    135                         selectedCell = l; 
    136                 } else { 
    137                         final Location old = selectedCell; 
    138                         selectedCell = l; 
    139                         repaintCell( old.x, old.y ); 
    140                         repaintCell( l.x, l.y ); 
    141                 } 
    142         } 
    143  
    144         public void addHighlightedCell( final Location l, 
    145                                         final boolean attack ) { 
    146                 addHighlightedCell( l.x, l.y, attack ); 
    147         } 
    148  
    149         public void addHighlightedCell( final int x, 
    150                                         final int y, 
    151                                         final boolean attack ) { 
    152                 final byte index = game.toIndex( x, y ); 
    153                 if( attack ) { 
    154                         attackedCells.set( index ); 
    155                 } else { 
    156                         highlightedCells.set( index ); 
    157                 } 
    158                 repaintCell( x, y ); 
    159         } 
    160  
    161         public void clearHighlightedCells() { 
    162                 highlightedCells.clear(); 
    163                 attackedCells.clear(); 
    164                 repaint(); 
    165         } 
    166  
    167         protected void paint( final Graphics g ) { 
    168                 final int canvasWidth = getWidth(); 
    169                 final int canvasHeight = getHeight(); 
    170                 //clear 
    171                 g.setColor( BG_COLOR ); 
    172                 g.fillRect( 0, 0, canvasWidth, canvasHeight ); 
    173  
    174                 //paint desk 
    175                 if( game != null ) { 
    176                         final int nX = game.getWidth(); 
    177                         final int nY = game.getHeight(); 
    178  
    179                         final int availableWidth = canvasWidth - 2 * MARGIN; 
    180                         final int availableHeight = canvasHeight - 2 * MARGIN; 
    181  
    182                         final Font font = g.getFont(); 
    183                         final int fontHeight = font.getHeight(); 
    184  
    185                         //ðåçåðâèðóåì ìåñòî ïîä èíôîðìåðû: 2 * (âûñîòîé rows ñòðîê + îòñòóïû ) 
    186                         //ñ÷èòàåì, ñêîëüêî íóæíî ñòðî÷åê, ÷òîáû íàïèñàòü "Áåëûå: 1235 ñåê <ñïèñîê âçÿòûõ ôèãóð>" 
    187                         final int charWidth = font.charWidth( 'W' ); 
    188                         final int chars = Math.max( 
    189                                         Player.WHITE.name().length(), 
    190                                         Player.BLACK.name().length() 
    191                         ) + ": 99999 sec".length() + 16/*16 units per player*/; 
    192  
    193                         final int rows = ( int ) Math.floor( availableWidth / ( 1.0f * charWidth * chars ) ) + 1; 
    194                         final int informerHeight = rows * fontHeight; 
    195  
    196                         final int _availableHeight = availableHeight - 2 * ( informerHeight + MARGIN ); 
    197  
    198                         //ðåçåðâèðóåì 2 ñòîëáöà è 2 ñòðîêè äëÿ ïîäïèñåé 
    199                         cellSize = Math.min( 
    200                                         availableWidth / ( nX + 2 ), 
    201                                         _availableHeight / ( nY + 2 ) 
    202                         ); 
    203  
    204                         if( cellSize < 2 ) { 
    205                                 throw new IllegalStateException( "Too small canvas" ); 
    206                         } 
    207  
    208                         final int _deskWidth = cellSize * ( nX + 2 ); 
    209                         final int _deskHeight = cellSize * ( nY + 2 ); 
    210  
    211                         final int vDeskMargin = ( canvasHeight - _deskHeight ) / 2; 
    212                         final int hDeskMargin = ( canvasWidth - _deskWidth ) / 2; 
    213                         vMargin = vDeskMargin + cellSize; 
    214                         hMargin = hDeskMargin + cellSize; 
    215  
    216                         //draw labels 
    217                         drawLabels( g, nX, nY ); 
    218  
    219                         //draw desk and units 
    220                         for( int _y = 0; _y < nY; _y++ ) { 
    221                                 for( int _x = 0; _x < nX; _x++ ) { 
    222                                         final int x = toScreenX( _x ); 
    223                                         final int y = toScreenY( _y ); 
    224  
    225                                         final int index = game.toIndex( _x, _y ); 
    226                                         //A1 -- ÷åðíîå 
    227                                         final boolean black = ( _x % 2 == 0 ) ^ ( _y % 2 != 0 ); 
    228                                         final boolean highlight = highlightedCells.is( index ); 
    229                                         final boolean attack = attackedCells.is( index ); 
    230                                         if( black ) { 
    231                                                 if( attack ) { 
    232                                                         g.setColor( 150, 100, 100 ); 
    233                                                 } else if( highlight ) { 
    234                                                         g.setColor( 100, 150, 100 ); 
    235                                                 } else { 
    236                                                         g.setColor( 100, 100, 100 ); 
    237                                                 } 
    238                                         } else { 
    239                                                 if( attack ) { 
    240                                                         g.setColor( 250, 200, 200 ); 
    241                                                 } else if( highlight ) { 
    242                                                         g.setColor( 200, 250, 200 ); 
    243                                                 } else { 
    244                                                         g.setColor( 200, 200, 200 ); 
    245                                                 } 
    246                                         } 
    247  
    248                                         g.fillRect( x, y, cellSize, cellSize ); 
    249  
    250                                         final IUnit unit = game.getUnit( _x, _y ); 
    251                                         if( unit != null ) { 
    252                                                 unit.paint( g, x, y, cellSize, cellSize ); 
    253                                         } 
    254                                 } 
    255                         } 
    256                         if( focusedCell != null ) { 
    257                                 g.setColor( 0, 150, 0 ); 
    258                                 final int x = toScreenX( focusedCell.x ); 
    259                                 final int y = toScreenY( focusedCell.y ); 
    260                                 g.drawRoundRect( x + 1, y + 1, cellSize - 2, cellSize - 2, 2, 2 ); 
    261                                 g.drawRoundRect( x, y, cellSize, cellSize, 2, 2 ); 
    262                         } 
    263                         if( selectedCell != null ) { 
    264                                 g.setColor( 0, 250, 0 ); 
    265                                 final int x = toScreenX( selectedCell.x ); 
    266                                 final int y = toScreenY( selectedCell.y ); 
    267                                 g.drawRoundRect( x + 1, y + 1, cellSize - 2, cellSize - 2, 2, 2 ); 
    268                                 g.drawRoundRect( x, y, cellSize, cellSize, 2, 2 ); 
    269                         } 
    270  
    271                         g.setColor( 0 ); 
    272                         g.drawRect( 
    273                                         hMargin - cellSize, 
    274                                         vMargin - cellSize, 
    275                                         _deskWidth, 
    276                                         _deskHeight 
    277                         ); 
    278                         g.drawRect( 
    279                                         hMargin, 
    280                                         vMargin, 
    281                                         _deskWidth - cellSize * 2, 
    282                                         _deskHeight - cellSize * 2 
    283                         ); 
    284  
    285                         drawInformers( g, availableWidth, informerHeight ); 
    286                 } 
    287         } 
    288  
    289         private void drawLabels( final Graphics g, 
    290                                  final int nX, 
    291                                  final int nY ) { 
    292                 //draw labels 
    293                 { 
    294                         g.setColor( LABELS_COLOR ); 
    295                         final int x1 = toScreenX( -1 ); 
    296                         final int x2 = toScreenX( nX ); 
    297                         for( int i = 0; i < nY; i++ ) { 
    298                                 final int y = toScreenY( i ); 
    299  
    300                                 final int baseline = y + cellSize * 3 / 4; 
    301                                 g.drawChar( 
    302                                                 ROWS[i], 
    303                                                 x1 + cellSize / 2, 
    304                                                 baseline, 
    305                                                 Graphics.HCENTER | Graphics.BASELINE 
    306                                 ); 
    307                                 g.drawChar( 
    308                                                 ROWS[i], 
    309                                                 x2 + cellSize / 2, 
    310                                                 baseline, 
    311                                                 Graphics.HCENTER | Graphics.BASELINE 
    312                                 ); 
    313                         } 
    314                         final int y1 = toScreenY( -1 ); 
    315                         final int y2 = toScreenY( nY ); 
    316                         for( int i = 0; i < nX; i++ ) { 
    317                                 final int x = toScreenX( i ); 
    318  
    319                                 final int baseline1 = y1 + cellSize * 3 / 4; 
    320                                 final int baseline2 = y2 + cellSize * 3 / 4; 
    321                                 g.drawChar( 
    322                                                 COLUMNS[i], 
    323                                                 x + cellSize / 2, 
    324                                                 baseline1, 
    325                                                 Graphics.HCENTER | Graphics.BASELINE 
    326                                 ); 
    327                                 g.drawChar( 
    328                                                 COLUMNS[i], 
    329                                                 x + cellSize / 2, 
    330                                                 baseline2, 
    331                                                 Graphics.HCENTER | Graphics.BASELINE 
    332                                 ); 
    333                         } 
    334                 } 
    335         } 
    336  
    337         private void drawInformers( final Graphics g, 
    338                                     final int width, 
    339                                     final int height ) { 
    340                 final int x = MARGIN; 
    341                 final int canvasHeight = getHeight(); 
    342  
    343                 drawInformer( g, 
    344                               x, MARGIN, 
    345                               width, height, 
    346                               Player.BLACK 
    347                 ); 
    348  
    349                 drawInformer( g, 
    350                               x, canvasHeight - height - 2 * MARGIN, 
    351                               width, height, 
    352                               Player.WHITE 
    353                 ); 
    354         } 
    355  
    356         private void drawInformer( final Graphics g, 
    357                                    final int x, 
    358                                    final int y, 
    359                                    final int width, 
    360                                    final int height, 
    361                                    final Player player ) { 
    362                 g.drawRect( x, y, width, height ); 
    363                 final String name = game.getOwner() == player ? player.name() + " (you)" : player.name(); 
    364                 final int inset = 2; 
    365                 g.drawString( name, 
    366                               x + inset, 
    367                               y + inset, 
    368                               Graphics.LEFT | Graphics.TOP 
    369                 ); 
    370                 final Font font = g.getFont(); 
    371                 final int nameWidth = font.stringWidth( name ); 
    372  
    373                 final long timing = game.getTiming( player ); 
    374  
    375                 final String time = ": " + String.valueOf( timing / 1000 ) + " s"; 
    376                 final int timeWidth = font.stringWidth( time ); 
    377                 g.drawString( time, 
    378                               x + inset + nameWidth + inset, 
    379                               y + inset, 
    380                               Graphics.LEFT | Graphics.TOP 
    381                 ); 
    382  
    383  
    384                 final Vector dead = game.getDeadUnits( player.opponent() ); 
    385                 final int length = dead.size(); 
    386                 final int size = 10; 
    387                 final int xStart = x + nameWidth + timeWidth + 3 * inset; 
    388                 for( int i = 0; i < length; i++ ) { 
    389                         final IUnit u = ( IUnit ) dead.elementAt( i ); 
    390                         u.paint( g, 
    391                                  xStart + i * size, 
    392                                  y + inset, 
    393                                  size, size 
    394                         ); 
    395                 } 
    396         } 
    397  
    398         private int toScreenX( final int x ) { 
    399                 return x * cellSize + hMargin; 
    400         } 
    401  
    402         private int toScreenY( final int y ) { 
    403                 return ( game.getHeight() - 1 - y ) * cellSize + vMargin; 
    404         } 
    405  
    406         private void repaintCell( final int x, 
    407                                   final int y ) { 
    408                 final int _x = toScreenX( x ); 
    409                 final int _y = toScreenY( y ); 
    410                 repaint( 
    411                                 _x - 1, _y - 1, 
    412                                 cellSize + 2, cellSize + 2 
    413                 ); 
    414                 //System.out.println( "queried repaint:[" + x + "," + y + "]" ); 
    415                 //repaint(); 
    416         } 
    417  
    418         protected void keyPressed( final int keyCode ) { 
    419                 super.keyPressed( keyCode ); 
    420                 if( listener != null && isActive() ) { 
    421                         listener.keyPressed( keyCode ); 
    422                 } 
    423         } 
    424  
    425         public void commandAction( final Command c, 
    426                                    final Displayable displayable ) { 
    427                 if( c == midlet.helpCommand ) { 
    428                         midlet.showHelp(); 
    429                 } else if( c == midlet.closeCommand ) { 
    430                         midlet.showStartScreen(); 
    431                 } else if( listener != null && isActive() ) { 
    432                         listener.commandAction( c, displayable ); 
    433                 } 
    434         } 
    435  
    436         public void changed() { 
    437                 if( isShown() ) { 
    438                         repaint(); 
    439                 } 
    440         } 
    441  
    442         public synchronized void setStatus( final int status ) { 
    443                 this.status = status; 
    444                 switch( status ) { 
    445                         case ACTIVE: 
    446                                 midlet.display.setCurrent( this ); 
    447                                 Util.log.println( "status:ACTIVE" ); 
    448                                 break; 
    449                         case WAITING_FOR_NETWORK: 
    450                                 showWaitMessage( MSG.getMessage( "wait.for-network" ) ); 
    451                                 Util.log.println( "status:WAIT_FOR_NETWORK" ); 
    452                                 break; 
    453                         case WAITING_FOR_OPPONENT: 
    454                                 showWaitMessage( MSG.getMessage( "wait.for-opponent" ) ); 
    455                                 Util.log.println( "status:WAIT_FOR_OPPONENT" ); 
    456                                 break; 
    457                         case NOT_CONNECTED: 
    458                                 showWaitMessage( MSG.getMessage( "wait.for-connect" ) ); 
    459                                 Util.log.println( "status:NOT_CONNECTED" ); 
    460                                 //todo implement 
    461                                 break; 
    462                 } 
    463         } 
    464  
    465         private void showWaitMessage( final String message ) { 
    466                 waitScreen.setText( message ); 
    467                 if( midlet.display.getCurrent() != waitScreen ) { 
    468                         midlet.display.setCurrent( waitScreen ); 
    469                 } 
    470         } 
    471  
    472         public synchronized int getStatus() { 
    473                 return status; 
    474         } 
    475  
    476         public boolean isActive() { 
    477                 return getStatus() == ACTIVE; 
    478         } 
    479  
    480         //public void repaint(){ 
    481         //    this.repaint(); 
    482         //} 
     19    public static final int ACTIVE = 0; 
     20    public static final int WAITING_FOR_SYNC = 1; 
     21    public static final int WAITING_FOR_NETWORK = 2; 
     22    public static final int WAITING_FOR_OPPONENT = 3; 
     23    public static final int NOT_CONNECTED = 4; 
     24 
     25    private static final char[] COLUMNS = new char[]{ 
     26            'A', 'B', 'C', 'D', 'E', 'F', 'J', 'H' 
     27    }; 
     28    private static final char[] ROWS = new char[]{ 
     29            '1', '2', '3', '4', '5', '6', '7', '8' 
     30    }; 
     31 
     32    protected final ChessMIDlet midlet; 
     33 
     34    public final int fireKey; 
     35    public final int leftKey; 
     36    public final int rightKey; 
     37    public final int upKey; 
     38    public final int downKey; 
     39 
     40    //protected Player player; 
     41    protected IGame game; 
     42 
     43    private int status = ACTIVE; 
     44 
     45    private Location focusedCell; 
     46    private Location selectedCell; 
     47 
     48    //bitwise masks -- 1 bit per cell 
     49    private final BitSet64 highlightedCells = new BitSet64(); 
     50    private final BitSet64 attackedCells = new BitSet64(); 
     51 
     52    private IUIListener listener = null; 
     53    private transient int vMargin; 
     54    private transient int hMargin; 
     55    private transient int cellSize; 
     56 
     57 
     58    private static final int MARGIN = 1; 
     59    //colors 
     60    private static final int BG_COLOR = 0xFFFFFF; 
     61    private static final int LABELS_COLOR = 0; 
     62 
     63    public final WaitScreen waitScreen; 
     64 
     65    public final Command surrenderCommand = new Command( MSG.getMessage( "command.surrender" ), Command.CANCEL, 1 ); 
     66    public final Command askForDrawCommand = new Command( MSG.getMessage( "command.ask-for-draw" ), Command.SCREEN, 1 ); 
     67 
     68    public GameCanvas( final ChessMIDlet midlet ) { 
     69        this.midlet = midlet; 
     70        fireKey = getKeyCode( FIRE ); 
     71        leftKey = getKeyCode( LEFT ); 
     72        rightKey = getKeyCode( RIGHT ); 
     73        upKey = getKeyCode( UP ); 
     74        downKey = getKeyCode( DOWN ); 
     75 
     76        waitScreen = new WaitScreen( 
     77                midlet, 
     78                MSG.getMessage( "wait.title" ), 
     79                this 
     80        ); 
     81        waitScreen.addCommand( midlet.cancelCommand ); 
     82        waitScreen.setCommandListener( this ); 
     83 
     84        //addCommand( midlet.closeCommand ); 
     85        addCommand( surrenderCommand ); 
     86        addCommand( askForDrawCommand ); 
     87        addCommand( midlet.helpCommand ); 
     88        setCommandListener( this ); 
     89    } 
     90 
     91    public void init( final IGame game ) { 
     92        if ( this.game != null ) { 
     93            this.game.setListener( null ); 
     94        } 
     95        this.game = game; 
     96        game.setListener( this ); 
     97    } 
     98 
     99    public void setUIListener( final IUIListener listener ) { 
     100        this.listener = listener; 
     101    } 
     102 
     103    public Location getFocusedCell() { 
     104        return focusedCell; 
     105    } 
     106 
     107    public void setFocusedCell( final Location l ) { 
     108        if ( focusedCell == null && l == null ) { 
     109            //nothing 
     110        } else if ( focusedCell == null ) { 
     111            focusedCell = l; 
     112            repaintCell( l.x, l.y ); 
     113        } else if ( l == null ) { 
     114            repaintCell( focusedCell.x, focusedCell.y ); 
     115            focusedCell = l; 
     116        } else { 
     117            final Location old = focusedCell; 
     118            focusedCell = l; 
     119            repaintCell( old.x, old.y ); 
     120            repaintCell( l.x, l.y ); 
     121        } 
     122    } 
     123 
     124    public Location getSelectedCell() { 
     125        return selectedCell; 
     126    } 
     127 
     128    public void setSelectedCell( final Location l ) { 
     129        if ( selectedCell == null && l == null ) { 
     130            //nothing 
     131        } else if ( selectedCell == null ) { 
     132            selectedCell = l; 
     133            repaintCell( l.x, l.y ); 
     134        } else if ( l == null ) { 
     135            repaintCell( selectedCell.x, selectedCell.y ); 
     136            selectedCell = l; 
     137        } else { 
     138            final Location old = selectedCell; 
     139            selectedCell = l; 
     140            repaintCell( old.x, old.y ); 
     141            repaintCell( l.x, l.y ); 
     142        } 
     143    } 
     144 
     145    public void addHighlightedCell( final Location l, 
     146                                    final boolean attack ) { 
     147        addHighlightedCell( l.x, l.y, attack ); 
     148    } 
     149 
     150    public void addHighlightedCell( final int x, 
     151                                    final int y, 
     152                                    final boolean attack ) { 
     153        final byte index = game.toIndex( x, y ); 
     154        if ( attack ) { 
     155            attackedCells.set( index ); 
     156        } else { 
     157            highlightedCells.set( index ); 
     158        } 
     159        repaintCell( x, y ); 
     160    } 
     161 
     162    public void clearHighlightedCells() { 
     163        highlightedCells.clear(); 
     164        attackedCells.clear(); 
     165        repaint(); 
     166    } 
     167 
     168    protected void paint( final Graphics g ) { 
     169        final int canvasWidth = getWidth(); 
     170        final int canvasHeight = getHeight(); 
     171        //clear 
     172        g.setColor( BG_COLOR ); 
     173        g.fillRect( 0, 0, canvasWidth, canvasHeight ); 
     174 
     175        //paint desk 
     176        if ( game != null ) { 
     177            final int nX = game.getWidth(); 
     178            final int nY = game.getHeight(); 
     179 
     180            final int availableWidth = canvasWidth - 2 * MARGIN; 
     181            final int availableHeight = canvasHeight - 2 * MARGIN; 
     182 
     183            final Font font = g.getFont(); 
     184            final int fontHeight = font.getHeight(); 
     185 
     186            //ðåçåðâèðóåì ìåñòî ïîä èíôîðìåðû: 2 * (âûñîòîé rows ñòðîê + îòñòóïû ) 
     187            //ñ÷èòàåì, ñêîëüêî íóæíî ñòðî÷åê, ÷òîáû íàïèñàòü "Áåëûå: 1235 ñåê <ñïèñîê âçÿòûõ ôèãóð>" 
     188            final int charWidth = font.charWidth( 'W' ); 
     189            final int chars = Math.max( 
     190                    Player.WHITE.name().length(), 
     191                    Player.BLACK.name().length() 
     192            ) + ": 9999:99 sec".length() + 16/*16 units per player*/; 
     193 
     194            final int rows = ( int )Math.floor( availableWidth / ( 1.0f * charWidth * chars ) ) + 1; 
     195            final int informerHeight = rows * fontHeight; 
     196 
     197            final int _availableHeight = availableHeight - 2 * ( informerHeight + MARGIN ); 
     198 
     199            //ðåçåðâèðóåì 2 ñòîëáöà è 2 ñòðîêè äëÿ ïîäïèñåé 
     200            cellSize = Math.min( 
     201                    availableWidth / ( nX + 2 ), 
     202                    _availableHeight / ( nY + 2 ) 
     203            ); 
     204 
     205            if ( cellSize < 2 ) { 
     206                throw new IllegalStateException( "Too small canvas" ); 
     207            } 
     208 
     209            final int _deskWidth = cellSize * ( nX + 2 ); 
     210            final int _deskHeight = cellSize * ( nY + 2 ); 
     211 
     212            final int vDeskMargin = ( canvasHeight - _deskHeight ) / 2; 
     213            final int hDeskMargin = ( canvasWidth - _deskWidth ) / 2; 
     214            vMargin = vDeskMargin + cellSize; 
     215            hMargin = hDeskMargin + cellSize; 
     216 
     217            //draw labels 
     218            drawLabels( g, nX, nY ); 
     219 
     220            //draw desk and units 
     221            for ( int _y = 0; _y < nY; _y++ ) { 
     222                for ( int _x = 0; _x < nX; _x++ ) { 
     223                    final int x = toScreenX( _x ); 
     224                    final int y = toScreenY( _y ); 
     225 
     226                    final int index = game.toIndex( _x, _y ); 
     227                    //A1 -- ÷åðíîå 
     228                    final boolean black = ( _x % 2 == 0 ) ^ ( _y % 2 != 0 ); 
     229                    final boolean highlight = highlightedCells.is( index ); 
     230                    final boolean attack = attackedCells.is( index ); 
     231                    if ( black ) { 
     232                        if ( attack ) { 
     233                            g.setColor( 150, 100, 100 ); 
     234                        } else if ( highlight ) { 
     235                            g.setColor( 100, 150, 100 ); 
     236                        } else { 
     237                            g.setColor( 100, 100, 100 ); 
     238                        } 
     239                    } else { 
     240                        if ( attack ) { 
     241                            g.setColor( 250, 200, 200 ); 
     242                        } else if ( highlight ) { 
     243                            g.setColor( 200, 250, 200 ); 
     244                        } else { 
     245                            g.setColor( 200, 200, 200 ); 
     246                        } 
     247                    } 
     248 
     249                    g.fillRect( x, y, cellSize, cellSize ); 
     250 
     251                    final IUnit unit = game.getUnit( _x, _y ); 
     252                    if ( unit != null ) { 
     253                        unit.paint( g, x, y, cellSize, cellSize ); 
     254                    } 
     255                } 
     256            } 
     257            if ( focusedCell != null ) { 
     258                g.setColor( 0, 150, 0 ); 
     259                final int x = toScreenX( focusedCell.x ); 
     260                final int y = toScreenY( focusedCell.y ); 
     261                g.drawRoundRect( x + 1, y + 1, cellSize - 2, cellSize - 2, 2, 2 ); 
     262                g.drawRoundRect( x, y, cellSize, cellSize, 2, 2 ); 
     263            } 
     264            if ( selectedCell != null ) { 
     265                g.setColor( 0, 250, 0 ); 
     266                final int x = toScreenX( selectedCell.x ); 
     267                final int y = toScreenY( selectedCell.y ); 
     268                g.drawRoundRect( x + 1, y + 1, cellSize - 2, cellSize - 2, 2, 2 ); 
     269                g.drawRoundRect( x, y, cellSize, cellSize, 2, 2 ); 
     270            } 
     271 
     272            g.setColor( 0 ); 
     273            g.drawRect( 
     274                    hMargin - cellSize, 
     275                    vMargin - cellSize, 
     276                    _deskWidth, 
     277                    _deskHeight 
     278            ); 
     279            g.drawRect( 
     280                    hMargin, 
     281                    vMargin, 
     282                    _deskWidth - cellSize * 2, 
     283                    _deskHeight - cellSize * 2 
     284            ); 
     285 
     286            drawInformers( g, availableWidth, informerHeight ); 
     287        } 
     288    } 
     289 
     290    private void drawLabels( final Graphics g, 
     291                             final int nX, 
     292                             final int nY ) { 
     293        //draw labels 
     294        { 
     295            g.setColor( LABELS_COLOR ); 
     296            final int x1 = toScreenX( -1 ); 
     297            final int x2 = toScreenX( nX ); 
     298            for ( int i = 0; i < nY; i++ ) { 
     299                final int y = toScreenY( i ); 
     300 
     301                final int baseline = y + cellSize * 3 / 4; 
     302                g.drawChar( 
     303                        ROWS[i], 
     304                        x1 + cellSize / 2, 
     305                        baseline, 
     306                        Graphics.HCENTER | Graphics.BASELINE 
     307                ); 
     308                g.drawChar( 
     309                        ROWS[i], 
     310                        x2 + cellSize / 2, 
     311                        baseline, 
     312                        Graphics.HCENTER | Graphics.BASELINE 
     313                ); 
     314            } 
     315            final int y1 = toScreenY( -1 ); 
     316            final int y2 = toScreenY( nY ); 
     317            for ( int i = 0; i < nX; i++ ) { 
     318                final int x = toScreenX( i ); 
     319 
     320                final int baseline1 = y1 + cellSize * 3 / 4; 
     321                final int baseline2 = y2 + cellSize * 3 / 4; 
     322                g.drawChar( 
     323                        COLUMNS[i], 
     324                        x + cellSize / 2, 
     325                        baseline1, 
     326                        Graphics.HCENTER | Graphics.BASELINE 
     327                ); 
     328                g.drawChar( 
     329                        COLUMNS[i], 
     330                        x + cellSize / 2, 
     331                        baseline2, 
     332                        Graphics.HCENTER | Graphics.BASELINE 
     333                ); 
     334            } 
     335        } 
     336    } 
     337 
     338    private void drawInformers( final Graphics g, 
     339                                final int width, 
     340                                final int height ) { 
     341        final int x = MARGIN; 
     342        final int canvasHeight = getHeight(); 
     343 
     344        drawInformer( g, 
     345                      x, MARGIN, 
     346                      width, height, 
     347                      Player.BLACK 
     348        ); 
     349 
     350        drawInformer( g, 
     351                      x, canvasHeight - height - 2 * MARGIN, 
     352                      width, height, 
     353                      Player.WHITE 
     354        ); 
     355    } 
     356 
     357    private void drawInformer( final Graphics g, 
     358                               final int x, 
     359                               final int y, 
     360                               final int width, 
     361                               final int height, 
     362                               final Player player ) { 
     363        final boolean active = game.getTurnOwner() == player; 
     364        final Font font = g.getFont(); 
     365 
     366        if ( active ) { 
     367            g.drawRoundRect( x, y, width, height, 3, 3 ); 
     368            g.drawRoundRect( x + 1, y + 1, width - 2, height - 2, 3, 3 ); 
     369        } else { 
     370            g.drawRoundRect( x, y, width, height, 3, 3 ); 
     371        } 
     372 
     373 
     374        final String name = game.getOwner() == player ? player.name() + "*" : player.name(); 
     375        final int inset = 2; 
     376        //if ( active ) { 
     377        //    g.setFont( 
     378        //            Font.getFont( 
     379        //                    font.getFace(), 
     380        //                    Font.STYLE_BOLD, 
     381        //                    font.getSize() 
     382        //            ) 
     383        //    ); 
     384        //} 
     385        g.drawString( name, 
     386                      x + inset, 
     387                      y + inset, 
     388                      Graphics.LEFT | Graphics.TOP 
     389        ); 
     390        g.setFont( font ); 
     391 
     392        final int nameWidth = font.stringWidth( name ); 
     393 
     394        final long msecs = game.getTiming( player ); 
     395 
     396        final long mins = msecs / 60000; 
     397        final long secs = ( msecs % 60000 ) / 1000; 
     398 
     399        final String time = ": " + mins + ":" + secs; 
     400        final int timeWidth = font.stringWidth( time ); 
     401        g.drawString( time, 
     402                      x + inset + nameWidth + inset, 
     403                      y + inset, 
     404                      Graphics.LEFT | Graphics.TOP 
     405        ); 
     406 
     407 
     408        final Vector dead = game.getDeadUnits( player.opponent() ); 
     409        final int length = dead.size(); 
     410        final int size = 10; 
     411        final int xStart = x + nameWidth + timeWidth + 3 * inset; 
     412        for ( int i = 0; i < length; i++ ) { 
     413            final IUnit u = ( IUnit )dead.elementAt( i ); 
     414            u.paint( g, 
     415                     xStart + i * size, 
     416                     y + inset, 
     417                     size, size 
     418            ); 
     419        } 
     420    } 
     421 
     422    private int toScreenX( final int x ) { 
     423        return x * cellSize + hMargin; 
     424    } 
     425 
     426    private int toScreenY( final int y ) { 
     427        return ( game.getHeight() - 1 - y ) * cellSize + vMargin; 
     428    } 
     429 
     430    private void repaintCell( final int x, 
     431                              final int y ) { 
     432        final int _x = toScreenX( x ); 
     433        final int _y = toScreenY( y ); 
     434        repaint( 
     435                _x - 1, _y - 1, 
     436                cellSize + 2, cellSize + 2 
     437        ); 
     438        //System.out.println( "queried repaint:[" + x + "," + y + "]" ); 
     439        //repaint(); 
     440    } 
     441 
     442    protected void keyPressed( final int keyCode ) { 
     443        super.keyPressed( keyCode ); 
     444        if ( listener != null && isActive() ) { 
     445            listener.keyPressed( keyCode ); 
     446        } 
     447    } 
     448 
     449    public void commandAction( final Command c, 
     450                               final Displayable displayable ) { 
     451        if ( c == midlet.helpCommand ) { 
     452            midlet.showHelp(); 
     453            //} else if( c == midlet.closeCommand ) { 
     454            //  midlet.showStartScreen(); 
     455        } else if ( listener != null && isActive() ) { 
     456            listener.commandAction( c, displayable ); 
     457        } 
     458    } 
     459 
     460    public void changed() { 
     461        if ( isShown() ) { 
     462            repaint(); 
     463        } 
     464    } 
     465 
     466    public synchronized void setStatus( final int status ) { 
     467        this.status = status; 
     468        switch ( status ) { 
     469            case ACTIVE: 
     470                midlet.display.setCurrent( this ); 
     471                Util.log.println( "status:ACTIVE" ); 
     472                break; 
     473            case WAITING_FOR_NETWORK: 
     474                showWaitMessage( MSG.getMessage( "wait.for-network" ) ); 
     475                Util.log.println( "status:WAIT_FOR_NETWORK" ); 
     476                break; 
     477            case WAITING_FOR_SYNC: 
     478                showWaitMessage( MSG.getMessage( "wait.for-sync" ) ); 
     479                Util.log.println( "status:WAIT_FOR_SYNC" ); 
     480                break; 
     481            case WAITING_FOR_OPPONENT: 
     482                showWaitMessage( MSG.getMessage( "wait.for-opponent" ) ); 
     483                Util.log.println( "status:WAIT_FOR_OPPONENT" ); 
     484                break; 
     485            case NOT_CONNECTED: 
     486                showWaitMessage( MSG.getMessage( "wait.for-connect" ) ); 
     487                Util.log.println( "status:NOT_CONNECTED" ); 
     488                //todo implement 
     489                break; 
     490        } 
     491    } 
     492 
     493    private void showWaitMessage( final String message ) { 
     494        waitScreen.setText( message ); 
     495        if ( midlet.display.getCurrent() != waitScreen ) { 
     496            midlet.display.setCurrent( waitScreen ); 
     497        } 
     498    } 
     499 
     500    public synchronized int getStatus() { 
     501        return status; 
     502    } 
     503 
     504    public boolean isActive() { 
     505        return getStatus() == ACTIVE; 
     506    } 
     507 
     508    //public void repaint(){ 
     509    //    this.repaint(); 
     510    //} 
    483511} 
  • chess/src/chess/ui/JoinGameScreen.java

    r25 r28  
    4141 
    4242        scanningNetworkAlert.setTimeout( Alert.FOREVER ); 
    43         scanningNetworkAlert.removeCommand( Alert.DISMISS_COMMAND ); 
    4443        scanningNetworkAlert.addCommand( midlet.cancelCommand ); 
    4544        scanningNetworkAlert.setCommandListener( this ); 
Note: See TracChangeset for help on using the changeset viewer.