Changeset 11 for chess


Ignore:
Timestamp:
02/02/09 16:39:14 (13 years ago)
Author:
BegemoT
Message:
 
Location:
chess/src/chess
Files:
3 added
6 edited
1 moved

Legend:

Unmodified
Added
Removed

  • chess/src/chess/control/BaseController.java

    r9 r11  
    1717 */ 
    1818public abstract class BaseController implements IConnectionListener, IUIListener { 
    19         public static final int WAITING_FOR_LOCAL = 0; 
    20         public static final int WAITING_FOR_NETWORK = 1; 
    21         public static final int WAITING_FOR_OPPONENT = 2; 
    22         public static final int WAITING_CONNECT = 3; 
    23  
    24         protected final App app; 
    25         protected final GameCanvas ui; 
    26         protected final IGame game; 
    27         protected Player player; 
    28         protected final IRemoteNode node; 
    29  
    30         protected int status; 
    31  
    32         public BaseController( final App app, 
    33                                final GameCanvas ui, 
    34                                final IGame game, 
    35                                final Player player, 
    36                                final IRemoteNode node ) { 
    37                 this.app = app; 
    38                 this.ui = ui; 
    39                 this.game = game; 
    40                 this.player = player; 
    41                 this.node = node; 
    42                 node.setListener( this ); 
    43                 ui.setUIListener( this ); 
    44         } 
    45  
    46         public void received( final IDatagram data ) { 
    47                 if( data instanceof Action ) { 
    48                         processAction( ( Action ) data ); 
    49                 } else if( data instanceof SystemAction ) { 
    50                         final SystemAction sa = ( SystemAction ) data; 
    51                         processSystemAction( sa ); 
    52                 } 
    53         } 
    54  
    55         protected void processAction( final Action a ) { 
    56                 game.doAction( a ); 
    57         } 
    58  
    59         protected void processSystemAction( final SystemAction sa ) { 
    60                 if( sa.type() == SystemAction.SET_PLAYER ) { 
    61                         player = sa.getPlayer(); 
    62                         if( isMaster() ) { 
    63                                 throw new IllegalStateException( "Master should not got SET_PLAYER commands" ); 
    64                         } 
    65                 } else if( sa.type() == SystemAction.YOUR_TURN_TYPE ) { 
    66                         if( player == null ) { 
    67                                 throw new IllegalStateException( "Player == null" ); 
    68                         } 
    69                         setStatus( WAITING_FOR_LOCAL ); 
    70                 } 
    71         } 
    72  
    73         public void wasSent( final IDatagram data ) { 
    74                 setStatus( WAITING_FOR_OPPONENT ); 
    75         } 
    76  
    77         public void closed() { 
    78                 setStatus( WAITING_CONNECT ); 
    79         } 
    80  
    81         public void post( final IDatagram data ) { 
    82                 setStatus( WAITING_FOR_NETWORK ); 
    83                 node.send( data ); 
    84         } 
    85  
    86         public void setStatus( final int status ) { 
    87                 //todo 
    88                 this.status = status; 
    89                 switch( status ) { 
    90                         case WAITING_FOR_LOCAL: 
    91                                 ui.setStatus( GameCanvas.ACTIVE ); 
    92                                 break; 
    93                         case WAITING_FOR_NETWORK: 
    94                                 ui.setStatus( GameCanvas.WAITING_FOR_NETWORK ); 
    95                                 break; 
    96                         case WAITING_FOR_OPPONENT: 
    97                                 ui.setStatus( GameCanvas.WAITING_FOR_OPPONENT ); 
    98                                 break; 
    99                         case WAITING_CONNECT: 
    100                                 ui.setStatus( GameCanvas.DISCONNECTED ); 
    101                                 break; 
    102                         default: 
    103                                 throw new IllegalStateException( "Unknown status:" + status ); 
    104                 } 
    105         } 
    106  
    107         public abstract boolean isMaster(); 
    108  
    109         public void keyPressed( final int code ) { 
    110                 ui.clearHighlightedCells(); 
    111                 final Location fc = ui.getFocusedCell(); 
    112                 int x, y; 
    113                 if( fc == null ) { 
    114                         x = y = 0; 
    115                 } else { 
    116                         x = fc.x; 
    117                         y = fc.y; 
    118                 } 
    119                 if( code == ui.leftKey ) { 
    120                         x -= 1; 
    121                         if( x < 0 ) { 
    122                                 x = game.getWidth() - 1; 
    123                         } 
    124                 } else if( code == ui.rightKey ) { 
    125                         x += 1; 
    126                         if( x >= game.getWidth() ) { 
    127                                 x = 0; 
    128                         } 
    129                 } else if( code == ui.downKey ) { 
    130                         y -= 1; 
    131                         if( y < 0 ) { 
    132                                 y = game.getHeight() - 1; 
    133                         } 
    134  
    135                 } else if( code == ui.upKey ) { 
    136                         y += 1; 
    137                         if( y >= game.getHeight() ) { 
    138                                 y = 0; 
    139                         } 
    140                 } 
    141  
    142                 final Location selectedCell = ui.getSelectedCell(); 
    143                 if( selectedCell == null ) { 
    144                         final Location focused = new Location( x, y ); 
    145                         ui.setFocusedCell( focused ); 
    146                         final IUnit unit = game.getUnit( focused ); 
    147                         if( unit != null ) { 
    148                                 highlightDomain( unit ); 
    149                         } 
    150  
    151                         if( code == ui.fireKey 
    152                                         && unit != null 
    153                                         && unit.getOwner() == player ) { 
    154                                 ui.setSelectedCell( focused ); 
    155                                 ui.setFocusedCell( null ); 
    156  
    157                                 ui.addCommand( app.getMidlet().backCommand ); 
    158                         } 
    159                 } else { 
    160                         final IUnit unit = game.getUnit( selectedCell ); 
    161                         if( unit != null ) { 
    162                                 final Location[] domain = highlightDomain( unit ); 
    163                                 final int index = findNearest( domain, x, y ); 
    164                                 if( index >= 0 ) { 
    165                                         ui.setFocusedCell( domain[index] ); 
    166                                 } 
    167                                 if( code == ui.fireKey ) { 
    168                                         game.doAction( 
    169                                                         new Action( 
    170                                                                         player, 
    171                                                                         0, 
    172                                                                         selectedCell, 
    173                                                                         ui.getFocusedCell() 
    174                                                         ) 
    175                                         ); 
    176                                         ui.setFocusedCell( null ); 
    177                                         ui.setSelectedCell( null ); 
    178                                         ui.clearHighlightedCells(); 
    179                                         post( new SystemAction( SystemAction.YOUR_TURN_TYPE, player ) ); 
    180                                 } 
    181                         } else { 
    182                                 ui.setSelectedCell( null ); 
    183                         } 
    184  
    185                 } 
    186         } 
    187  
    188         private static int findNearest( final Location[] ls, 
    189                                         final int x, 
    190                                         final int y ) { 
    191                 int d = Integer.MAX_VALUE; 
    192                 int index = -1; 
    193                 for( int i = 0; i < ls.length; i++ ) { 
    194                         final Location l = ls[i]; 
    195                         final int _d = l.ldistance( x, y ); 
    196                         if( _d < d ) { 
    197                                 d = _d; 
    198                                 index = i; 
    199                         } 
    200                 } 
    201  
    202                 return index; 
    203         } 
    204  
    205         public void commandAction( final Command command, 
    206                                    final Displayable displayable ) { 
    207                 if( command == app.getMidlet().backCommand ) { 
    208                         ui.removeCommand( command ); 
    209                         ui.setSelectedCell( null ); 
    210                         ui.clearHighlightedCells(); 
    211                 } 
    212         } 
    213  
    214         private Location[] highlightDomain( final IUnit unit ) { 
    215                 final Location[] available = unit.canMoveTo(); 
    216                 for( int i = 0; i < available.length; i++ ) { 
    217                         final Location l = available[i]; 
    218                         final IUnit u = game.getUnit( l ); 
    219                         final boolean attack = u != null && unit.isOpponent( u ); 
    220                         ui.addHighlightedCell( l, attack ); 
    221                 } 
    222                 return available; 
    223         } 
     19    public static final int WAITING_FOR_LOCAL = 0; 
     20    public static final int WAITING_FOR_NETWORK = 1; 
     21    public static final int WAITING_FOR_OPPONENT = 2; 
     22    public static final int WAITING_CONNECT = 3; 
     23 
     24    protected final App app; 
     25    protected final GameCanvas ui; 
     26    protected final IGame game; 
     27    protected Player player; 
     28    protected final IRemoteNode node; 
     29 
     30    protected int status; 
     31 
     32    public BaseController( final App app, 
     33                           final GameCanvas ui, 
     34                           final IGame game, 
     35                           final Player player, 
     36                           final IRemoteNode node ) { 
     37        this.app = app; 
     38        this.ui = ui; 
     39        this.game = game; 
     40        this.player = player; 
     41        this.node = node; 
     42        node.setListener( this ); 
     43        ui.setUIListener( this ); 
     44    } 
     45 
     46    public void received( final IDatagram data ) { 
     47        if ( data instanceof Action ) { 
     48            processAction( ( Action )data ); 
     49        } else if ( data instanceof SystemAction ) { 
     50            final SystemAction sa = ( SystemAction )data; 
     51            processSystemAction( sa ); 
     52        } 
     53    } 
     54 
     55    protected void processAction( final Action a ) { 
     56        game.doAction( a ); 
     57    } 
     58 
     59    protected void processSystemAction( final SystemAction sa ) { 
     60        if ( sa.type() == SystemAction.SET_PLAYER ) { 
     61            player = sa.getPlayer(); 
     62            if ( isMaster() ) { 
     63                throw new IllegalStateException( "Master should not got SET_PLAYER commands" ); 
     64            } 
     65        } else if ( sa.type() == SystemAction.YOUR_TURN ) { 
     66            if ( player == null ) { 
     67                throw new IllegalStateException( "Player == null" ); 
     68            } 
     69            setStatus( WAITING_FOR_LOCAL ); 
     70        } 
     71    } 
     72 
     73    public void wasSent( final IDatagram data ) { 
     74        setStatus( WAITING_FOR_OPPONENT ); 
     75    } 
     76 
     77    public void closed() { 
     78        setStatus( WAITING_CONNECT ); 
     79    } 
     80 
     81    public void post( final IDatagram data ) { 
     82        setStatus( WAITING_FOR_NETWORK ); 
     83        node.send( data ); 
     84    } 
     85 
     86    public void setStatus( final int status ) { 
     87        //todo 
     88        this.status = status; 
     89        switch ( status ) { 
     90            case WAITING_FOR_LOCAL: 
     91                ui.setStatus( GameCanvas.ACTIVE ); 
     92                break; 
     93            case WAITING_FOR_NETWORK: 
     94                ui.setStatus( GameCanvas.WAITING_FOR_NETWORK ); 
     95                break; 
     96            case WAITING_FOR_OPPONENT: 
     97                ui.setStatus( GameCanvas.WAITING_FOR_OPPONENT ); 
     98                break; 
     99            case WAITING_CONNECT: 
     100                ui.setStatus( GameCanvas.DISCONNECTED ); 
     101                break; 
     102            default: 
     103                throw new IllegalStateException( "Unknown status:" + status ); 
     104        } 
     105    } 
     106 
     107    public abstract boolean isMaster(); 
     108 
     109    public void keyPressed( final int code ) { 
     110        ui.clearHighlightedCells(); 
     111        final Location fc = ui.getFocusedCell(); 
     112        int x, y; 
     113        if ( fc == null ) { 
     114            x = y = 0; 
     115        } else { 
     116            x = fc.x; 
     117            y = fc.y; 
     118        } 
     119        if ( code == ui.leftKey ) { 
     120            x -= 1; 
     121            if ( x < 0 ) { 
     122                x = game.getWidth() - 1; 
     123            } 
     124        } else if ( code == ui.rightKey ) { 
     125            x += 1; 
     126            if ( x >= game.getWidth() ) { 
     127                x = 0; 
     128            } 
     129        } else if ( code == ui.downKey ) { 
     130            y -= 1; 
     131            if ( y < 0 ) { 
     132                y = game.getHeight() - 1; 
     133            } 
     134 
     135        } else if ( code == ui.upKey ) { 
     136            y += 1; 
     137            if ( y >= game.getHeight() ) { 
     138                y = 0; 
     139            } 
     140        } 
     141 
     142        final Location selectedCell = ui.getSelectedCell(); 
     143        if ( selectedCell == null ) { 
     144            final Location focused = new Location( x, y ); 
     145            ui.setFocusedCell( focused ); 
     146            final IUnit unit = game.getUnit( focused ); 
     147            if ( unit != null ) { 
     148                highlightDomain( unit ); 
     149            } 
     150 
     151            if ( code == ui.fireKey 
     152                    && unit != null 
     153                    && unit.getOwner() == player ) { 
     154                ui.setSelectedCell( focused ); 
     155                ui.setFocusedCell( null ); 
     156 
     157                ui.addCommand( app.getMidlet().backCommand ); 
     158            } 
     159        } else { 
     160            final IUnit unit = game.getUnit( selectedCell ); 
     161            if ( unit != null ) { 
     162                final Location[] domain = highlightDomain( unit ); 
     163                final int index = findNearest( domain, x, y ); 
     164                if ( index >= 0 ) { 
     165                    ui.setFocusedCell( domain[index] ); 
     166                } 
     167                if ( code == ui.fireKey ) { 
     168                    final Action action = new Action( 
     169                            player, 
     170                            0, 
     171                            selectedCell, 
     172                            ui.getFocusedCell() 
     173                    ); 
     174                    game.doAction( action ); 
     175                    ui.setFocusedCell( null ); 
     176                    ui.setSelectedCell( null ); 
     177                    ui.clearHighlightedCells(); 
     178                    post( action ); 
     179                    post( new SystemAction( SystemAction.YOUR_TURN, player ) ); 
     180                } 
     181            } else { 
     182                ui.setSelectedCell( null ); 
     183            } 
     184 
     185        } 
     186    } 
     187 
     188    private static int findNearest( final Location[] ls, 
     189                                    final int x, 
     190                                    final int y ) { 
     191        int d = Integer.MAX_VALUE; 
     192        int index = -1; 
     193        for ( int i = 0; i < ls.length; i++ ) { 
     194            final Location l = ls[i]; 
     195            final int _d = l.ldistance( x, y ); 
     196            if ( _d < d ) { 
     197                d = _d; 
     198                index = i; 
     199            } 
     200        } 
     201 
     202        return index; 
     203    } 
     204 
     205    public void commandAction( final Command command, 
     206                               final Displayable displayable ) { 
     207        if ( command == app.getMidlet().backCommand ) { 
     208            ui.removeCommand( command ); 
     209            ui.setSelectedCell( null ); 
     210            ui.clearHighlightedCells(); 
     211        } 
     212    } 
     213 
     214    private Location[] highlightDomain( final IUnit unit ) { 
     215        final Location[] available = unit.canMoveTo(); 
     216        for ( int i = 0; i < available.length; i++ ) { 
     217            final Location l = available[i]; 
     218            final IUnit u = game.getUnit( l ); 
     219            final boolean attack = u != null && unit.isOpponent( u ); 
     220            ui.addHighlightedCell( l, attack ); 
     221        } 
     222        return available; 
     223    } 
    224224} 

  • chess/src/chess/control/MasterController.java

    r9 r11  
    4343                //todo enable ui 
    4444            } else { 
    45                 conn.send( new SystemAction( SystemAction.YOUR_TURN_TYPE, player.opponent() ) ); 
     45                conn.send( new SystemAction( SystemAction.YOUR_TURN, player.opponent() ) ); 
    4646            } 
    4747        } else { 
    … …  
    5050                //todo enable ui 
    5151            } else { 
    52                 conn.send( new SystemAction( SystemAction.YOUR_TURN_TYPE, player.opponent() ) ); 
     52                conn.send( new SystemAction( SystemAction.YOUR_TURN, player.opponent() ) ); 
    5353            } 
    5454        } 

  • chess/src/chess/control/SystemAction.java

    r9 r11  
    1717 */ 
    1818public final class SystemAction implements IDatagram { 
    19         public static final byte SET_PLAYER = 0; 
    20         public static final byte YOUR_TURN_TYPE = 1; 
     19    public static final byte SET_PLAYER = 0; 
     20    public static final byte YOUR_TURN = 1; 
    2121 
    22         private byte type; 
    23         private Player player; 
     22    private byte type; 
     23    private Player player; 
    2424 
    25         public SystemAction( final InputStream is ) throws IOException { 
    26                 read( is ); 
    27         } 
     25    public SystemAction( final InputStream is ) throws IOException { 
     26        read( is ); 
     27    } 
    2828 
    29         public SystemAction( final int type, 
    30                              final Player player ) { 
    31                 checkType( type ); 
    32                 if( player == null ) { 
    33                         throw new IllegalArgumentException( "Player can't be null" ); 
    34                 } 
    35                 this.type = ( byte ) type; 
    36                 this.player = player; 
    37         } 
     29    public SystemAction( final int type, 
     30                         final Player player ) { 
     31        checkType( type ); 
     32        if ( player == null ) { 
     33            throw new IllegalArgumentException( "Player can't be null" ); 
     34        } 
     35        this.type = ( byte )type; 
     36        this.player = player; 
     37    } 
    3838 
    39         public int type() { 
    40                 return type; 
    41         } 
     39    public int type() { 
     40        return type; 
     41    } 
    4242 
    43         public Player getPlayer() { 
    44                 return player; 
    45         } 
     43    public Player getPlayer() { 
     44        return player; 
     45    } 
    4646 
    47         public void write( final OutputStream os ) throws IOException { 
    48                 os.write( type ); 
    49                 os.write( player.ordinal() ); 
    50         } 
     47    public void write( final OutputStream os ) throws IOException { 
     48        os.write( type ); 
     49        os.write( player.ordinal() ); 
     50    } 
    5151 
    52         public void read( final InputStream is ) throws IOException { 
    53                 final int type = is.read(); 
    54                 checkType( type ); 
    55                 this.type = ( byte ) type; 
    56                 player = Player.byType( is.read() ); 
    57         } 
     52    public void read( final InputStream is ) throws IOException { 
     53        final int type = is.read(); 
     54        checkType( type ); 
     55        this.type = ( byte )type; 
     56        player = Player.byType( is.read() ); 
     57    } 
    5858 
    59         private static void checkType( final int type ) { 
    60                 if( Util.SAFE_MODE ) { 
    61                         if( type != SET_PLAYER && type != YOUR_TURN_TYPE ) { 
    62                                 throw new IllegalArgumentException( "Type " + type + " is unknown" ); 
    63                         } 
    64                 } 
    65         } 
     59    private static void checkType( final int type ) { 
     60        if ( Util.SAFE_MODE ) { 
     61            if ( type != SET_PLAYER && type != YOUR_TURN ) { 
     62                throw new IllegalArgumentException( "Type " + type + " is unknown" ); 
     63            } 
     64        } 
     65    } 
    6666 
    6767 
    68         public boolean equals( final Object o ) { 
    69                 if( this == o ) { 
    70                         return true; 
    71                 } 
    72                 if( o == null || getClass() != o.getClass() ) { 
    73                         return false; 
    74                 } 
     68    public boolean equals( final Object o ) { 
     69        if ( this == o ) { 
     70            return true; 
     71        } 
     72        if ( o == null || getClass() != o.getClass() ) { 
     73            return false; 
     74        } 
    7575 
    76                 final SystemAction that = ( SystemAction ) o; 
     76        final SystemAction that = ( SystemAction )o; 
    7777 
    78                 return player == that.player && type == that.type; 
     78        return player == that.player && type == that.type; 
    7979 
    80         } 
     80    } 
    8181 
    82         public int hashCode() { 
    83                 int result; 
    84                 result = ( int ) type; 
    85                 result = 31 * result + player.hashCode(); 
    86                 return result; 
    87         } 
     82    public int hashCode() { 
     83        int result; 
     84        result = ( int )type; 
     85        result = 31 * result + player.hashCode(); 
     86        return result; 
     87    } 
     88 
     89    public String toString() { 
     90        switch ( type ) { 
     91            case SET_PLAYER: 
     92                return "SET_PLAYER[" + player + "]"; 
     93            case YOUR_TURN: 
     94                return "YOUR_TURN[" + player + "]"; 
     95            default: 
     96                throw new IllegalArgumentException( "type is unknown:" + type ); 
     97        } 
     98    } 
    8899} 

  • chess/src/chess/game/Action.java

    r9 r11  
    1515 */ 
    1616public class Action implements IDatagram { 
    17         private Player player; 
    18         private int duration; 
     17    private Player player; 
     18    private int duration; 
    1919 
    20         private Location from; 
    21         private Location to; 
     20    private Location from; 
     21    private Location to; 
    2222 
    23         public Action( final InputStream is ) throws IOException { 
    24                 read( is ); 
    25         } 
     23    public Action( final InputStream is ) throws IOException { 
     24        read( is ); 
     25    } 
    2626 
    27         public Action( final Player player, 
    28                        final int duration, 
    29                        final Location from, 
    30                        final Location to ) { 
    31                 this.player = player; 
    32                 this.duration = duration; 
    33                 this.from = from; 
    34                 this.to = to; 
    35         } 
     27    public Action( final Player player, 
     28                   final int duration, 
     29                   final Location from, 
     30                   final Location to ) { 
     31        this.player = player; 
     32        this.duration = duration; 
     33        this.from = from; 
     34        this.to = to; 
     35    } 
    3636 
    37         public Action( final Player player, 
    38                        final int duration, 
    39                        final int xFrom, 
    40                        final int yFrom, 
    41                        final int xTo, 
    42                        final int yTo ) { 
    43                 this( player, duration, 
    44                       new Location( xFrom, yFrom ), 
    45                       new Location( xTo, yTo ) 
    46                 ); 
    47         } 
     37    public Action( final Player player, 
     38                   final int duration, 
     39                   final int xFrom, 
     40                   final int yFrom, 
     41                   final int xTo, 
     42                   final int yTo ) { 
     43        this( player, duration, 
     44              new Location( xFrom, yFrom ), 
     45              new Location( xTo, yTo ) 
     46        ); 
     47    } 
    4848 
    49         public Location from() { 
    50                 return from; 
    51         } 
     49    public Location from() { 
     50        return from; 
     51    } 
    5252 
    53         public Location to() { 
    54                 return to; 
    55         } 
     53    public Location to() { 
     54        return to; 
     55    } 
    5656 
    57         public int duration() { 
    58                 return duration; 
    59         } 
     57    public int duration() { 
     58        return duration; 
     59    } 
    6060 
    61         public Player getPlayer() { 
    62                 return player; 
    63         } 
     61    public Player getPlayer() { 
     62        return player; 
     63    } 
    6464 
    65         public void write( final OutputStream os ) throws IOException { 
    66                 os.write( player.ordinal() ); 
     65    public void write( final OutputStream os ) throws IOException { 
     66        os.write( player.ordinal() ); 
    6767 
    68                 os.write( duration ); 
    69                 os.write( duration >> 8 ); 
    70                 os.write( duration >> 16 ); 
    71                 os.write( duration >> 24 ); 
     68        os.write( duration ); 
     69        os.write( duration >> 8 ); 
     70        os.write( duration >> 16 ); 
     71        os.write( duration >> 24 ); 
    7272 
    73                 os.write( from.x ); 
    74                 os.write( from.y ); 
    75                 os.write( to.x ); 
    76                 os.write( to.y ); 
    77         } 
     73        os.write( from.x ); 
     74        os.write( from.y ); 
     75        os.write( to.x ); 
     76        os.write( to.y ); 
     77    } 
    7878 
    79         public void read( final InputStream is ) throws IOException { 
    80                 player = Player.byType( is.read() ); 
    81                 duration = is.read() | is.read() << 8 | is.read() << 16 | is.read() << 24; 
    82                 from = new Location( is.read(), is.read() ); 
    83                 to = new Location( is.read(), is.read() ); 
    84         } 
     79    public void read( final InputStream is ) throws IOException { 
     80        player = Player.byType( is.read() ); 
     81        duration = is.read() | is.read() << 8 | is.read() << 16 | is.read() << 24; 
     82        from = new Location( is.read(), is.read() ); 
     83        to = new Location( is.read(), is.read() ); 
     84    } 
    8585 
    8686 
    87         public boolean equals( final Object o ) { 
    88                 if( this == o ) { 
    89                         return true; 
    90                 } 
    91                 if( o == null || getClass() != o.getClass() ) { 
    92                         return false; 
    93                 } 
     87    public boolean equals( final Object o ) { 
     88        if ( this == o ) { 
     89            return true; 
     90        } 
     91        if ( o == null || getClass() != o.getClass() ) { 
     92            return false; 
     93        } 
    9494 
    95                 final Action action = ( Action ) o; 
     95        final Action action = ( Action )o; 
    9696 
    97                 if( duration != action.duration ) { 
    98                         return false; 
    99                 } 
    100                 if( !from.equals( action.from ) ) { 
    101                         return false; 
    102                 } 
    103                 if( !player.equals( action.player ) ) { 
    104                         return false; 
    105                 } 
    106                 if( !to.equals( action.to ) ) { 
    107                         return false; 
    108                 } 
     97        if ( duration != action.duration ) { 
     98            return false; 
     99        } 
     100        if ( !from.equals( action.from ) ) { 
     101            return false; 
     102        } 
     103        if ( !player.equals( action.player ) ) { 
     104            return false; 
     105        } 
     106        if ( !to.equals( action.to ) ) { 
     107            return false; 
     108        } 
    109109 
    110                 return true; 
    111         } 
     110        return true; 
     111    } 
    112112 
    113         public int hashCode() { 
    114                 int result; 
    115                 result = player.hashCode(); 
    116                 result = 31 * result + duration; 
    117                 result = 31 * result + from.hashCode(); 
    118                 result = 31 * result + to.hashCode(); 
    119                 return result; 
    120         } 
     113    public int hashCode() { 
     114        int result; 
     115        result = player.hashCode(); 
     116        result = 31 * result + duration; 
     117        result = 31 * result + from.hashCode(); 
     118        result = 31 * result + to.hashCode(); 
     119        return result; 
     120    } 
     121 
     122    public String toString() { 
     123        return player + ": " + from + " -> " + to + " (" + duration + " ms)"; 
     124    } 
    121125} 

  • chess/src/chess/game/Player.java

    r9 r11  
    7474                return this == BLACK; 
    7575        } 
     76 
     77    public String toString() { 
     78        return name(); 
     79    } 
    7680} 

  • chess/src/chess/remote/impl/Remote.java

    r9 r11  
    1010import chess.Util; 
    1111import chess.remote.*; 
     12import chess.remote.impl.debug.DebugRemote; 
    1213 
    1314 
    … …  
    1920 */ 
    2021public class Remote implements IRemote { 
    21         private static final String MY_SERVICE_NUMBER = "3B9FA89520078C303355AAA694238F08;name=ChessGameServer"; 
     22    private static final String MY_SERVICE_NUMBER = "3B9FA89520078C303355AAA694238F08;name=ChessGameServer"; 
    2223 
    23         private static final IRemoteNode[] EMPTY = new IRemoteNode[0]; 
     24    private static final IRemoteNode[] EMPTY = new IRemoteNode[0]; 
    2425 
    25         private final LocalDevice localDevice; 
    26         private final Vector devices = new Vector(); 
     26    private final LocalDevice localDevice; 
     27    private final Vector devices = new Vector(); 
    2728 
    28         private Remote() throws Exception { 
    29                 localDevice = LocalDevice.getLocalDevice(); 
    30                 fillupCache(); 
    31         } 
     29    private Remote() throws Exception { 
     30        localDevice = LocalDevice.getLocalDevice(); 
     31        fillupCache(); 
     32    } 
    3233 
    33         private void fillupCache() { 
    34                 final DiscoveryAgent agent = localDevice.getDiscoveryAgent(); 
    35                 final RemoteDevice[] preknownDevices = agent.retrieveDevices( DiscoveryAgent.PREKNOWN ); 
    36                 if( preknownDevices != null ) { 
    37                         for( int i = 0; i < preknownDevices.length; i++ ) { 
    38                                 final RemoteDevice device = preknownDevices[i]; 
    39                                 devices.addElement( device ); 
    40                         } 
    41                 } 
    42                 final RemoteDevice[] cachedDevices = agent.retrieveDevices( DiscoveryAgent.CACHED ); 
    43                 if( cachedDevices != null ) { 
    44                         for( int i = 0; i < cachedDevices.length; i++ ) { 
    45                                 final RemoteDevice device = cachedDevices[i]; 
    46                                 devices.addElement( device ); 
    47                         } 
    48                 } 
    49         } 
     34    private void fillupCache() { 
     35        final DiscoveryAgent agent = localDevice.getDiscoveryAgent(); 
     36        final RemoteDevice[] preknownDevices = agent.retrieveDevices( DiscoveryAgent.PREKNOWN ); 
     37        if ( preknownDevices != null ) { 
     38            for ( int i = 0; i < preknownDevices.length; i++ ) { 
     39                final RemoteDevice device = preknownDevices[i]; 
     40                devices.addElement( device ); 
     41            } 
     42        } 
     43        final RemoteDevice[] cachedDevices = agent.retrieveDevices( DiscoveryAgent.CACHED ); 
     44        if ( cachedDevices != null ) { 
     45            for ( int i = 0; i < cachedDevices.length; i++ ) { 
     46                final RemoteDevice device = cachedDevices[i]; 
     47                devices.addElement( device ); 
     48            } 
     49        } 
     50    } 
    5051 
    51         public IAsyncProcess waitForIncoming( final IServerListener l ) { 
    52                 return new WaitForIncomingThread( localDevice, l ); 
    53         } 
     52    public IAsyncProcess waitForIncoming( final IServerListener l ) { 
     53        return new WaitForIncomingThread( localDevice, l ); 
     54    } 
    5455 
    55         public void getAvailable( final boolean refresh, 
    56                                   final IClientListener l ) { 
    57                 if( refresh ) { 
    58                         //todo 
    59                         try { 
    60                                 final DiscoveryAgent agent = localDevice.getDiscoveryAgent(); 
    61                                 agent.startInquiry( 
    62                                                 DiscoveryAgent.GIAC, 
    63                                                 new DiscoveryListener() { 
    64                                                         public void deviceDiscovered( final RemoteDevice btDevice, 
    65                                                                                       final DeviceClass cod ) { 
    66                                                                 Util.log.println( "device found:" + btDevice.getBluetoothAddress() ); 
    67                                                         } 
     56    public void getAvailable( final boolean refresh, 
     57                              final IClientListener l ) { 
     58        if ( refresh ) { 
     59            //todo 
     60            try { 
     61                final DiscoveryAgent agent = localDevice.getDiscoveryAgent(); 
     62                agent.startInquiry( 
     63                        DiscoveryAgent.GIAC, 
     64                        new DiscoveryListener() { 
     65                            public void deviceDiscovered( final RemoteDevice btDevice, 
     66                                                          final DeviceClass cod ) { 
     67                                Util.log.println( "device found:" + btDevice.getBluetoothAddress() ); 
     68                            } 
    6869 
    69                                                         public void servicesDiscovered( final int transID, 
    70                                                                                         final ServiceRecord[] servRecord ) { 
     70                            public void servicesDiscovered( final int transID, 
     71                                                            final ServiceRecord[] servRecord ) { 
    7172 
    72                                                         } 
     73                            } 
    7374 
    74                                                         public void serviceSearchCompleted( final int transID, 
    75                                                                                             final int respCode ) { 
     75                            public void serviceSearchCompleted( final int transID, 
     76                                                                final int respCode ) { 
    7677 
    77                                                         } 
     78                            } 
    7879 
    79                                                         public void inquiryCompleted( final int discType ) { 
    80                                                                 devices.removeAllElements(); 
    81                                                                 fillupCache(); 
    82                                                                 l.finished( getNodes() ); 
    83                                                         } 
    84                                                 } 
    85                                 ); 
    86                         } catch( BluetoothStateException e ) { 
    87                                 e.printStackTrace(); 
    88                                 l.finished( null ); 
    89                         } 
    90                 } else { 
    91                         final IRemoteNode[] nodes = getNodes(); 
    92                         l.finished( nodes ); 
    93                 } 
    94         } 
     80                            public void inquiryCompleted( final int discType ) { 
     81                                devices.removeAllElements(); 
     82                                fillupCache(); 
     83                                l.finished( getNodes() ); 
     84                            } 
     85                        } 
     86                ); 
     87            } catch ( BluetoothStateException e ) { 
     88                e.printStackTrace(); 
     89                l.finished( null ); 
     90            } 
     91        } else { 
     92            final IRemoteNode[] nodes = getNodes(); 
     93            l.finished( nodes ); 
     94        } 
     95    } 
    9596 
    96         private IRemoteNode[] getNodes() { 
    97                 if( devices.isEmpty() ) { 
    98                         return EMPTY; 
    99                 } 
    100                 final int length = devices.size(); 
    101                 final IRemoteNode[] nodes = new IRemoteNode[length]; 
    102                 for( int i = 0; i < length; i++ ) { 
    103                         try { 
    104                                 final RemoteDevice device = ( RemoteDevice ) devices.elementAt( i ); 
    105                                 final RemoteNode node = new RemoteNode( device ); 
    106                                 nodes[i] = node; 
    107                         } catch( IOException e ) { 
    108                                 e.printStackTrace(); 
    109                         } 
    110                 } 
    111                 return nodes; 
    112         } 
     97    private IRemoteNode[] getNodes() { 
     98        if ( devices.isEmpty() ) { 
     99            return EMPTY; 
     100        } 
     101        final int length = devices.size(); 
     102        final IRemoteNode[] nodes = new IRemoteNode[length]; 
     103        for ( int i = 0; i < length; i++ ) { 
     104            try { 
     105                final RemoteDevice device = ( RemoteDevice )devices.elementAt( i ); 
     106                final RemoteNode node = new RemoteNode( device ); 
     107                nodes[i] = node; 
     108            } catch ( IOException e ) { 
     109                e.printStackTrace(); 
     110            } 
     111        } 
     112        return nodes; 
     113    } 
    113114 
    114         public static IRemote create() throws Exception { 
     115    public static IRemote create() throws Exception { 
    115116//        return new Remote(); 
    116                 return new DummyRemote(); 
    117         } 
     117//        return new DummyRemote(); 
     118        return new DebugRemote(); 
     119    } 
    118120 
    119         private static class WaitForIncomingThread extends Thread implements IAsyncProcess { 
    120                 private final IServerListener listener; 
    121                 private final LocalDevice localDevice; 
    122                 private volatile int status = -1; 
     121    private static class WaitForIncomingThread extends BaseAsyncProcess { 
     122        private final LocalDevice localDevice; 
    123123 
    124                 public WaitForIncomingThread( final LocalDevice local, 
    125                                               final IServerListener listener ) { 
    126                         this.localDevice = local; 
    127                         this.listener = listener; 
    128                         start(); 
    129                 } 
     124        public WaitForIncomingThread( final LocalDevice local, 
     125                                      final IServerListener listener ) { 
     126            super( listener ); 
     127            this.localDevice = local; 
     128            start(); 
     129        } 
    130130 
    131                 public void run() { 
    132                         try { 
    133                                 localDevice.setDiscoverable( DiscoveryAgent.GIAC ); 
    134                                 status = IN_PROCESS; 
    135                                 while( true ) { 
    136                                         try { 
    137                                                 final StreamConnectionNotifier server = ( StreamConnectionNotifier ) Connector.open( 
    138                                                                 "btspp://localhost:" + MY_SERVICE_NUMBER, 
    139                                                                 Connector.READ_WRITE, 
    140                                                                 true 
    141                                                 ); 
    142                                                 Util.log.println( "creating server and waiting for incoming" ); 
    143                                                 try { 
    144                                                         while( true ) { 
    145                                                                 // Îæèäàåì âõîäÿùåå ïîòîêîâîå ñîåäèíåíèå 
    146                                                                 final StreamConnection conn = server.acceptAndOpen(); 
    147                                                                 Util.log.println( "accepted incoming" + conn ); 
    148                                                                 final RemoteNode client = new RemoteNode( conn ); 
    149                                                                 if( listener.incoming( client ) ) { 
    150                                                                         //åñëè êëèåíò ïðèíÿò -- âûõîäèì (èãðà äîïóñêàåò òîëüêî îäíîãî ñîïåðíèêà) 
    151                                                                         Util.log.println( "client accepted -> close server" ); 
    152                                                                         status = SUCCEEDED; 
    153                                                                         return; 
    154                                                                 } 
    155                                                                 client.close(); 
    156                                                         } 
    157                                                 } catch( IOException ex ) { 
    158                                                         ex.printStackTrace(); 
    159                                                 } finally { 
    160                                                         try { 
    161                                                                 server.close(); 
    162                                                         } catch( IOException e ) { 
    163                                                                 e.printStackTrace(); 
    164                                                         } 
    165                                                 } 
    166                                         } catch( IOException ex ) { 
    167                                                 ex.printStackTrace(); 
    168                                                 status = FAILED; 
    169                                                 return; 
    170                                         } 
    171                                 } 
    172                         } catch( IOException ex ) { 
    173                                 ex.printStackTrace(); 
    174                                 status = FAILED; 
    175                         } finally { 
    176                                 listener.finished( null ); 
    177                                 Util.log.println( "server stopped" ); 
    178                         } 
    179                 } 
    180  
    181  
    182                 public int status() { 
    183                         return status; 
    184                 } 
    185  
    186                 public synchronized void interrupt( final boolean waitFor ) { 
    187                         if( isAlive() ) { 
    188                                 interrupt(); 
    189                                 if( waitFor && Thread.currentThread() != this ) { 
    190                                         try { 
    191                                                 join(); 
    192                                         } catch( InterruptedException e ) { 
    193                                                 e.printStackTrace(); 
    194                                         } 
    195                                 } 
    196                         } 
    197                 } 
    198  
    199                 public IAsyncProcessListener getListener() { 
    200                         return listener; 
    201                 } 
    202         } 
     131        public void run() { 
     132            try { 
     133                localDevice.setDiscoverable( DiscoveryAgent.GIAC ); 
     134                setStatus( IN_PROCESS ); 
     135                while ( true ) { 
     136                    try { 
     137                        final StreamConnectionNotifier server = ( StreamConnectionNotifier )Connector.open( 
     138                                "btspp://localhost:" + MY_SERVICE_NUMBER, 
     139                                Connector.READ_WRITE, 
     140                                true 
     141                        ); 
     142                        Util.log.println( "creating server and waiting for incoming" ); 
     143                        try { 
     144                            while ( true ) { 
     145                                // Îæèäàåì âõîäÿùåå ïîòîêîâîå ñîåäèíåíèå 
     146                                final StreamConnection conn = server.acceptAndOpen(); 
     147                                Util.log.println( "accepted incoming" + conn ); 
     148                                final RemoteNode client = new RemoteNode( conn ); 
     149                                if ( listener.incoming( client ) ) { 
     150                                    //åñëè êëèåíò ïðèíÿò -- âûõîäèì (èãðà äîïóñêàåò òîëüêî îäíîãî ñîïåðíèêà) 
     151                                    Util.log.println( "client accepted -> close server" ); 
     152                                    setStatus( SUCCEEDED ); 
     153                                    return; 
     154                                } 
     155                                client.close(); 
     156                            } 
     157                        } catch ( IOException ex ) { 
     158                            ex.printStackTrace(); 
     159                        } finally { 
     160                            try { 
     161                                server.close(); 
     162                            } catch ( IOException e ) { 
     163                                e.printStackTrace(); 
     164                            } 
     165                        } 
     166                    } catch ( IOException ex ) { 
     167                        ex.printStackTrace(); 
     168                        setStatus( FAILED ); 
     169                        return; 
     170                    } 
     171                } 
     172            } catch ( IOException ex ) { 
     173                ex.printStackTrace(); 
     174                setStatus( FAILED ); 
     175            } finally { 
     176                listener.finished( null ); 
     177                Util.log.println( "server stopped" ); 
     178            } 
     179        } 
     180    } 
    203181} 

  • chess/src/chess/remote/impl/debug/DummyRemote.java

    r10 r11  
    1 package chess.remote.impl; 
     1package chess.remote.impl.debug; 
    22 
    33import java.io.*; 
Note: See TracChangeset for help on using the changeset viewer.