Changeset 19 for chess


Ignore:
Timestamp:
02/04/09 17:04:21 (13 years ago)
Author:
BegemoT
Message:

many improvements

Location:
chess
Files:
3 added
21 edited
1 moved

Legend:

Unmodified
Added
Removed
  • chess/chess.jad

    r18 r19  
    1 MIDlet-1: Chess game, , chess.ui.ChessMIDlet 
    2 MIDlet-Jar-Size: 75780 
     1MIDlet-Jar-Size: 855926 
    32MIDlet-Jar-URL: chess.jar 
    43MIDlet-Name: chess 
    54MIDlet-Vendor: I am 
    65MIDlet-Version: 1.0 
    7 MicroEdition-Configuration: CLDC-1.0 
    8 MicroEdition-Profile: MIDP-2.0 
     6MicroEdition-Configuration: CLDC-1.1 
     7MicroEdition-Profile: MIDP-2.1 
  • chess/src/chess/Util.java

    r9 r19  
    22 
    33import java.io.PrintStream; 
     4import java.io.OutputStream; 
     5import java.io.IOException; 
     6import java.io.InputStream; 
     7 
     8import javax.microedition.rms.RecordStore; 
     9 
     10import chess.remote.IRemote; 
     11import chess.remote.impl.debug.DebugRemote; 
     12import chess.remote.impl.Remote; 
    413 
    514 
     
    918 */ 
    1019public final class Util { 
    11         private Util(){ 
    12         } 
     20    private Util() { 
     21    } 
    1322 
    14         public static final PrintStream log = System.out; 
     23    public static final PrintStream log = System.out; 
    1524 
    16         /** 
    17         * âêëþ÷àåò äîïîëíèòåëüíûå ïðîâåðêè íà ñòàäèè âûïîëíåíèÿ, 
    18         * ïðè ýòîì îòêëþ÷àòü èõ íà ñòàäèè ïîäãîòîâêè production 
    19         */ 
    20         public static final boolean SAFE_MODE = true; 
     25    /** 
     26    * âêëþ÷àåò äîïîëíèòåëüíûå ïðîâåðêè íà ñòàäèè âûïîëíåíèÿ, 
     27    * ïðè ýòîì îòêëþ÷àòü èõ íà ñòàäèè ïîäãîòîâêè production 
     28    */ 
     29    public static final boolean SAFE_MODE = true; 
    2130 
    22          
     31 
     32    public static IRemote create() throws Exception { 
     33        return new Remote(); 
     34        //return new DebugRemote( 100, 100 ); 
     35    } 
     36 
     37    public static void writeInt( final OutputStream os, 
     38                                 final int value ) throws IOException { 
     39        os.write( value ); 
     40        os.write( value >> 8 ); 
     41        os.write( value >> 16 ); 
     42        os.write( value >> 24 ); 
     43    } 
     44 
     45    public static int readInt( final InputStream is ) throws IOException { 
     46        return is.read() | is.read() << 8 | is.read() << 16 | is.read() << 24; 
     47    } 
     48 
     49    public static int save( final String name, 
     50                            final byte[] data ) throws Exception { 
     51        final RecordStore store = RecordStore.openRecordStore( name, true ); 
     52        try { 
     53            return store.addRecord( data, 0, data.length ); 
     54        } finally { 
     55            store.closeRecordStore(); 
     56        } 
     57    } 
    2358} 
  • chess/src/chess/control/BaseController.java

    r17 r19  
    4848        this.player = player; 
    4949        this.node = node; 
    50  
    51         master = player != null; 
     50        game.setOwner( player ); 
     51 
     52        master = ( player != null ); 
    5253 
    5354        node.setListener( this ); 
    54         node.ensureConnected(); 
     55        node.start(); 
    5556 
    5657        ui.setUIListener( this ); 
     
    6061        } else { 
    6162            //wait for incoming actions log 
    62             synchronized ( this ) { 
    63                 while ( this.player == null ) { 
    64                     try { 
    65                         //ñòðàõóåìñÿ íà ñëó÷àé, åñëè ñîáûòèÿ óæå óñïåëè ïðèéòè 
    66                         wait( 150 ); 
    67                     } catch ( InterruptedException e ) { 
    68                         e.printStackTrace(); 
    69                     } 
    70                 } 
    71             } 
     63            //synchronized ( this ) { 
     64            //    while ( this.player == null ) { 
     65            //        try { 
     66            //            //ñòðàõóåìñÿ íà ñëó÷àé, åñëè ñîáûòèÿ óæå óñïåëè ïðèéòè 
     67            //            wait( 150 ); 
     68            //        } catch ( InterruptedException e ) { 
     69            //            e.printStackTrace(); 
     70            //        } 
     71            //    } 
     72            //} 
    7273        } 
    7374        lastTimeStamp = System.currentTimeMillis(); 
     
    121122        if ( sa.type() == SystemAction.SET_PLAYER ) { 
    122123            player = sa.getPlayer(); 
     124            game.setOwner( player ); 
    123125            if ( isMaster() ) { 
    124126                throw new IllegalStateException( "Master should not got SET_PLAYER commands" ); 
  • chess/src/chess/game/Action.java

    r17 r19  
    66 
    77import chess.remote.IDatagram; 
     8import chess.Util; 
    89 
    910 
     
    1617public class Action implements IDatagram { 
    1718    private Player player; 
    18     //âðÿä ëè êòî-òî áóäåò äóìàòü áîëüøå ìèëëèîíà ñåêóíä 
     19    //âðÿä ëè êòî-òî áóäåò äóìàòü áîëüøå ìèëëèîíà ñåêóíä (~12 ñóòîê) 
    1920    private int duration; 
    2021 
    21     private Location from; 
    22     private Location to; 
     22    private int fromX; 
     23    private int fromY; 
     24 
     25    private int toX; 
     26    private int toY; 
     27 
     28    //private Location from; 
     29    //private Location to; 
    2330 
    2431    public Action( final InputStream is ) throws IOException { 
     
    3037                   final Location from, 
    3138                   final Location to ) { 
     39        this( player, duration, from.x, from.y, to.x, to.y ); 
     40    } 
     41 
     42    public Action( final Player player, 
     43                   final long duration, 
     44                   final int xFrom, 
     45                   final int yFrom, 
     46                   final int xTo, 
     47                   final int yTo ) { 
    3248        this.player = player; 
    3349        if ( duration > Integer.MAX_VALUE ) { 
     
    3551        } 
    3652        this.duration = ( int )duration; 
    37         this.from = from; 
    38         this.to = to; 
     53        this.fromX = xFrom; 
     54        this.fromY = yFrom; 
     55        this.toX = xTo; 
     56        this.toY = yTo; 
    3957    } 
    4058 
    41     public Action( final Player player, 
    42                    final int duration, 
    43                    final int xFrom, 
    44                    final int yFrom, 
    45                    final int xTo, 
    46                    final int yTo ) { 
    47         this( player, duration, 
    48               new Location( xFrom, yFrom ), 
    49               new Location( xTo, yTo ) 
    50         ); 
     59    public int fromX() { 
     60        return fromX; 
    5161    } 
    5262 
    53     public Location from() { 
    54         return from; 
     63    public int fromY() { 
     64        return fromY; 
    5565    } 
    5666 
    57     public Location to() { 
    58         return to; 
     67    public int toX() { 
     68        return toX; 
     69    } 
     70 
     71    public int toY() { 
     72        return toY; 
    5973    } 
    6074 
     
    7084        os.write( player.ordinal() ); 
    7185 
    72         os.write( duration ); 
    73         os.write( duration >> 8 ); 
    74         os.write( duration >> 16 ); 
    75         os.write( duration >> 24 ); 
     86        Util.writeInt( os, duration ); 
    7687 
    77         os.write( from.x ); 
    78         os.write( from.y ); 
    79         os.write( to.x ); 
    80         os.write( to.y ); 
     88        os.write( fromX ); 
     89        os.write( fromY ); 
     90        os.write( toX ); 
     91        os.write( toY ); 
    8192    } 
    8293 
    8394    public void read( final InputStream is ) throws IOException { 
    8495        player = Player.byType( is.read() ); 
    85         duration = is.read() | is.read() << 8 | is.read() << 16 | is.read() << 24; 
    86         from = new Location( is.read(), is.read() ); 
    87         to = new Location( is.read(), is.read() ); 
     96        duration = Util.readInt( is ); 
     97        fromX = is.read(); 
     98        fromY = is.read(); 
     99        toX = is.read(); 
     100        toY = is.read(); 
    88101    } 
    89102 
     
    97110        } 
    98111 
    99         final Action action = ( Action )o; 
     112        final Action a = ( Action )o; 
    100113 
    101         if ( duration != action.duration ) { 
     114        if ( duration != a.duration ) { 
    102115            return false; 
    103116        } 
    104         if ( !from.equals( action.from ) ) { 
    105             return false; 
    106         } 
    107         if ( !player.equals( action.player ) ) { 
    108             return false; 
    109         } 
    110         if ( !to.equals( action.to ) ) { 
     117        if ( !player.equals( a.player ) ) { 
    111118            return false; 
    112119        } 
    113120 
    114         return true; 
     121 
     122        return fromX == a.fromX && fromY == a.fromY 
     123                && toX == a.toX && toY == a.toY; 
    115124    } 
    116125 
     
    119128        result = player.hashCode(); 
    120129        result = 31 * result + duration; 
    121         result = 31 * result + from.hashCode(); 
    122         result = 31 * result + to.hashCode(); 
     130        result = 31 * result + fromX; 
     131        result = 31 * result + fromY; 
     132        result = 31 * result + toX; 
     133        result = 31 * result + toY; 
    123134        return result; 
    124135    } 
    125136 
    126137    public String toString() { 
    127         return player + ": " + from + " -> " + to + " (" + duration + " ms)"; 
     138        return player + ": [" + fromX + ", " + fromY + "] -> [" + toX + ", " + toY + "] (" + duration + " ms)"; 
    128139    } 
    129140} 
  • chess/src/chess/game/Game.java

    r17 r19  
    22 
    33import java.util.*; 
     4import java.io.InputStream; 
     5import java.io.OutputStream; 
     6import java.io.IOException; 
    47 
    58import chess.Util; 
     
    1619    private static final int SIZE = 8; 
    1720 
    18  
    1921    private IGameListener listener = null; 
    2022 
     
    2830    private final long[] timings = new long[]{ 0, 0 }; 
    2931 
     32    private Player turnOwner; 
     33 
     34    private Player owner; 
     35 
    3036    public Game() { 
     37        //this.owner = owner; 
    3138        activeUnits[0] = new Vector( 16 ); 
    3239        activeUnits[1] = new Vector( 16 ); 
     
    6269        put( new King( Player.WHITE, this, new Location( 4, yWhite ) ) ); 
    6370        put( new King( Player.BLACK, this, new Location( 4, yBlack ) ) ); 
     71 
     72        setTurnOwner( Player.WHITE ); 
     73    } 
     74 
     75    //public Game( final InputStream is ) throws IOException { 
     76    //    this(); 
     77    //    load( is ); 
     78    //} 
     79 
     80    public Player getOwner() { 
     81        return owner; 
     82    } 
     83 
     84    public void setOwner( final Player owner ) { 
     85        this.owner = owner; 
     86    } 
     87 
     88    public Player getTurnOwner() { 
     89        return turnOwner; 
     90    } 
     91 
     92    public void setTurnOwner( final Player turnOwner ) { 
     93        this.turnOwner = turnOwner; 
    6494    } 
    6595 
     
    148178 
    149179    private void move( final AUnit u, 
    150                        final Location from, 
    151                        final Location to ) { 
    152         desk[toIndex( from )] = null; 
    153         desk[toIndex( to )] = u; 
    154         u.setLocation( to ); 
     180                       final int fromX, 
     181                       final int fromY, 
     182                       final int toX, 
     183                       final int toY ) { 
     184        desk[toIndex( fromX, fromY )] = null; 
     185        desk[toIndex( toX, toY )] = u; 
     186        u.setLocation( toX, toY ); 
    155187    } 
    156188 
    157189    public void doAction( final Action a ) { 
    158190        //todo Action is mutable. a.clone()? 
     191        if ( a.getPlayer() != turnOwner ) { 
     192            throw new IllegalArgumentException( "Current turn is " + turnOwner + ", but " + a.getPlayer() + " trying to move!" ); 
     193        } 
    159194        actionsLog.addElement( a ); 
     195 
    160196        //todo check, can we really make movement? 
    161         final Location from = a.from(); 
    162         final IUnit actor = getUnit( from ); 
     197        final int fromX = a.fromX(); 
     198        final int fromY = a.fromY(); 
     199        final IUnit actor = getUnit( fromX, fromY ); 
    163200        if ( actor == null ) { 
    164             throw new IllegalStateException( "Where is no unit at " + from ); 
     201            throw new IllegalStateException( "Where is no unit at [" + fromX + ", " + fromY + "]" ); 
    165202        } 
    166203        if ( actor.getOwner() != a.getPlayer() ) { 
     
    168205        } 
    169206 
    170         final Location to = a.to(); 
    171         final IUnit victim = getUnit( to ); 
     207        final int toX = a.toX(); 
     208        final int toY = a.toY(); 
     209        final IUnit victim = getUnit( toX, toY ); 
    172210        if ( victim != null && victim.getOwner() == actor.getOwner() ) { 
    173211            throw new IllegalStateException( "Can't take own unit:" + actor + " <> " + victim ); 
     
    177215            kill( victim ); 
    178216        } 
    179         move( ( AUnit )actor, from, to ); 
     217        move( ( AUnit )actor, fromX, fromY, toX, toY ); 
    180218 
    181219        timings[a.getPlayer().ordinal()] += a.duration(); 
    182220 
     221        setTurnOwner( a.getPlayer().opponent() ); 
    183222        if ( listener != null ) { 
    184223            listener.changed(); 
     
    215254    } 
    216255 
    217     private final void check( final int x, 
    218                               final int y ) { 
     256    private void check( final int x, 
     257                        final int y ) { 
    219258        if ( Util.SAFE_MODE && !isValid( x, y ) ) { 
    220259            throw new IllegalArgumentException( "Invalid location:" + x + ", " + y + " is out of bounds!" ); 
    221260        } 
    222261    } 
     262 
     263    public void save( final OutputStream os ) throws IOException { 
     264        final int size = actionsLog.size(); 
     265        Util.writeInt( os, size ); 
     266        for ( int i = 0; i < size; i++ ) { 
     267            final Action a = ( Action )actionsLog.elementAt( i ); 
     268            a.write( os ); 
     269        } 
     270    } 
     271 
     272    public void load( final InputStream is ) throws IOException { 
     273        final int size = Util.readInt( is ); 
     274        actionsLog.ensureCapacity( size ); 
     275        for ( int i = 0; i < size; i++ ) { 
     276            final Action a = new Action( is ); 
     277            doAction( a ); 
     278        } 
     279    } 
    223280} 
  • chess/src/chess/game/IGame.java

    r17 r19  
    1010 */ 
    1111public interface IGame { 
     12    public Player getTurnOwner(); 
     13 
     14    public Player getOwner(); 
     15 
     16    public void setOwner( final Player p ); 
     17 
    1218    public int getWidth(); 
    1319 
  • chess/src/chess/game/units/AUnit.java

    r17 r19  
    6868    } 
    6969 
     70    public void setLocation( final int x, 
     71                             final int y ) { 
     72        setLocation( new Location( x, y ) ); 
     73    } 
     74 
    7075    public boolean canTransform() { 
    7176        return false; 
     
    108113        } 
    109114        return true; 
    110         } 
     115    } 
    111116} 
  • chess/src/chess/game/units/Bishop.java

    r17 r19  
    5757 
    5858        protected char getSymbol( final boolean white ) { 
    59                 if( white ) { 
    60                         return '?'; 
    61                 } else { 
    62                         return '?'; 
    63                 } 
     59                //if( white ) { 
     60                //      return '?'; 
     61                //} else { 
     62                //      return '?'; 
     63                //} 
     64        return 'B'; 
    6465        } 
    6566} 
  • chess/src/chess/game/units/Castle.java

    r17 r19  
    5151 
    5252        protected char getSymbol(final boolean white) { 
    53                 if( white ) { 
    54                         return '?'; 
    55                 } else { 
    56                         return '?'; 
    57                 } 
     53                //if( white ) { 
     54                //      return '?'; 
     55                //} else { 
     56                //      return '?'; 
     57                //} 
     58        return 'C'; 
    5859        } 
    5960} 
  • chess/src/chess/game/units/King.java

    r17 r19  
    5555         
    5656        protected char getSymbol( final boolean white ) { 
    57                 if( white ) { 
    58                         return '?'; 
    59                 } else { 
    60                         return '?'; 
    61                 } 
     57                //if( white ) { 
     58                //      return '?'; 
     59                //} else { 
     60                //      return '?'; 
     61                //} 
     62        return 'K'; 
    6263        } 
    6364 
  • chess/src/chess/game/units/Knight.java

    r17 r19  
    6363 
    6464        protected char getSymbol( final boolean white ) { 
    65                 if( white ) { 
    66                         return '?'; 
    67                 } else { 
    68                         return '?'; 
    69                 } 
     65                //if( white ) { 
     66                //      return '?'; 
     67                //} else { 
     68                //      return '?'; 
     69                //} 
     70        return 'L'; 
    7071        } 
    7172} 
  • chess/src/chess/game/units/Pawn.java

    r17 r19  
    9292 
    9393        protected char getSymbol( final boolean white ) { 
    94                 if( white ) { 
    95                         return '?'; 
    96                 } else { 
    97                         return '?'; 
    98                 } 
     94                //if( white ) { 
     95                //      return '?'; 
     96                //} else { 
     97                //      return '?'; 
     98                //} 
     99        return 'P'; 
    99100        } 
    100101} 
  • chess/src/chess/game/units/Queen.java

    r17 r19  
    1212 */ 
    1313public class Queen extends AUnit { 
    14         public Queen( final Player player, 
    15                       final IGame game, 
    16                       final Location location ) { 
    17                 super( player, game, location ); 
    18         } 
     14    public Queen( final Player player, 
     15                  final IGame game, 
     16                  final Location location ) { 
     17        super( player, game, location ); 
     18    } 
    1919 
    20         public Location[] canMoveTo() { 
    21                 _temp.removeAllElements(); 
     20    public Location[] canMoveTo() { 
     21        _temp.removeAllElements(); 
    2222 
    23                 final Location l = location; 
    24                 final int width = game.getWidth(); 
    25                 final int height = game.getHeight(); 
    26                 for( int x = l.x + 1; x < width; x++ ) { 
    27                         if( !checkAndAdd( this, game, x, l.y ) ) { 
    28                                 break; 
    29                         } 
    30                 } 
    31                 for( int x = l.x - 1; x >= 0; x-- ) { 
    32                         if( !checkAndAdd( this, game, x, l.y ) ) { 
    33                                 break; 
    34                         } 
    35                 } 
     23        final Location l = location; 
     24        final int width = game.getWidth(); 
     25        final int height = game.getHeight(); 
     26        for ( int x = l.x + 1; x < width; x++ ) { 
     27            if ( !checkAndAdd( this, game, x, l.y ) ) { 
     28                break; 
     29            } 
     30        } 
     31        for ( int x = l.x - 1; x >= 0; x-- ) { 
     32            if ( !checkAndAdd( this, game, x, l.y ) ) { 
     33                break; 
     34            } 
     35        } 
    3636 
    37                 for( int y = l.y + 1; y < height; y++ ) { 
    38                         if( !checkAndAdd( this, game, l.x, y ) ) { 
    39                                 break; 
    40                         } 
    41                 } 
    42                 for( int y = l.y - 1; y >= 0; y-- ) { 
    43                         if( !checkAndAdd( this, game, l.x, y ) ) { 
    44                                 break; 
    45                         } 
    46                 } 
     37        for ( int y = l.y + 1; y < height; y++ ) { 
     38            if ( !checkAndAdd( this, game, l.x, y ) ) { 
     39                break; 
     40            } 
     41        } 
     42        for ( int y = l.y - 1; y >= 0; y-- ) { 
     43            if ( !checkAndAdd( this, game, l.x, y ) ) { 
     44                break; 
     45            } 
     46        } 
    4747 
    48                 for( int i = 1; i < width; i++ ) { 
    49                         final int x = l.x + i; 
    50                         final int y = l.y + i; 
    51                         if( !checkAndAdd( this, game, x, y ) ) { 
    52                                 break; 
    53                         } 
    54                 } 
    55                 for( int i = 1; i < width; i++ ) { 
    56                         final int x = l.x - i; 
    57                         final int y = l.y - i; 
    58                         if( !checkAndAdd( this, game, x, y ) ) { 
    59                                 break; 
    60                         } 
    61                 } 
    62                 for( int i = 1; i < width; i++ ) { 
    63                         final int x = l.x + i; 
    64                         final int y = l.y - i; 
    65                         if( !checkAndAdd( this, game, x, y ) ) { 
    66                                 break; 
    67                         } 
    68                 } 
    69                 for( int i = 1; i < width; i++ ) { 
    70                         final int x = l.x - i; 
    71                         final int y = l.y + i; 
    72                         if( !checkAndAdd( this, game, x, y ) ) { 
    73                                 break; 
    74                         } 
    75                 } 
    76                 return convertBuffer(); 
    77         } 
    78          
    79         protected char getSymbol( final boolean white ) { 
    80                 if( white ) { 
    81                         return '?'; 
    82                 } else { 
    83                         return '?'; 
    84                 } 
    85         } 
     48        for ( int i = 1; i < width; i++ ) { 
     49            final int x = l.x + i; 
     50            final int y = l.y + i; 
     51            if ( !checkAndAdd( this, game, x, y ) ) { 
     52                break; 
     53            } 
     54        } 
     55        for ( int i = 1; i < width; i++ ) { 
     56            final int x = l.x - i; 
     57            final int y = l.y - i; 
     58            if ( !checkAndAdd( this, game, x, y ) ) { 
     59                break; 
     60            } 
     61        } 
     62        for ( int i = 1; i < width; i++ ) { 
     63            final int x = l.x + i; 
     64            final int y = l.y - i; 
     65            if ( !checkAndAdd( this, game, x, y ) ) { 
     66                break; 
     67            } 
     68        } 
     69        for ( int i = 1; i < width; i++ ) { 
     70            final int x = l.x - i; 
     71            final int y = l.y + i; 
     72            if ( !checkAndAdd( this, game, x, y ) ) { 
     73                break; 
     74            } 
     75        } 
     76        return convertBuffer(); 
     77    } 
     78 
     79    protected char getSymbol( final boolean white ) { 
     80        //if( white ) { 
     81        //      return '?'; 
     82        //} else { 
     83        //      return '?'; 
     84        //} 
     85        return 'P'; 
     86    } 
    8687} 
  • chess/src/chess/remote/IRemoteNode.java

    r9 r19  
    11package chess.remote; 
    22 
    3 import java.io.IOException; 
    43 
    54/** 
     
    1413        public void setListener( final IConnectionListener l ); 
    1514 
    16         public void ensureConnected() throws IOException; 
     15        public void start(); 
    1716 
    1817        public void send( final IDatagram data ); 
  • chess/src/chess/remote/impl/Remote.java

    r17 r19  
    2020 */ 
    2121public class Remote implements IRemote { 
    22     private static final String MY_SERVICE_NUMBER = "3B9FA89520078C303355AAA694238F08;name=ChessGameServer"; 
     22    public static final String BTSPP_SCHEME = "btspp://"; 
     23    public static final String MY_SERVICE_NUMBER = "3B9FA89520078C303355AAA694238F08;name=ChessGameServer"; 
    2324 
    2425    public static final IRemoteNode[] EMPTY = new IRemoteNode[0]; 
     
    2728    private final Vector devices = new Vector(); 
    2829 
    29     private Remote() throws Exception { 
     30    public Remote() throws Exception { 
    3031        localDevice = LocalDevice.getLocalDevice(); 
    3132        fillupCache(); 
     
    9596    } 
    9697 
    97     public static IRemote create() throws Exception { 
    98         //return new Remote(); 
    99 //        return new DummyRemote(); 
    100         return new DebugRemote( 100, 100 ); 
    101     } 
    102  
    10398    private static class WaitForIncomingThread extends BaseAsyncProcess { 
    10499        private final LocalDevice localDevice; 
     
    118113                    try { 
    119114                        final StreamConnectionNotifier server = ( StreamConnectionNotifier )Connector.open( 
    120                                 "btspp://localhost:" + MY_SERVICE_NUMBER, 
     115                                BTSPP_SCHEME +"localhost:" + MY_SERVICE_NUMBER, 
    121116                                Connector.READ_WRITE, 
    122117                                true 
     
    127122                                // Îæèäàåì âõîäÿùåå ïîòîêîâîå ñîåäèíåíèå 
    128123                                final StreamConnection conn = server.acceptAndOpen(); 
    129                                 Util.log.println( "accepted incoming" + conn ); 
     124                                Util.log.println( "accepted incoming:" + conn ); 
    130125                                final RemoteNode client = new RemoteNode( conn ); 
    131126                                if ( listener.incoming( client ) ) { 
  • chess/src/chess/remote/impl/RemoteNode.java

    r9 r19  
    2121public class RemoteNode implements IRemoteNode, Runnable { 
    2222 
    23         private String name; 
    24  
    25         private RemoteDevice device; 
    26         private IConnectionListener listener = null; 
    27         private StreamConnection connection = null; 
    28  
    29         private transient InputStream in; 
    30         private transient OutputStream out; 
    31         private transient Thread pump; 
    32  
    33         public RemoteNode( final RemoteDevice device ) throws IOException { 
    34                 this.device = device; 
    35                 name = device.getFriendlyName( false ); 
    36         } 
    37  
    38         public RemoteNode( final StreamConnection conn ) throws IOException { 
    39                 this.connection = conn; 
    40                 this.device = RemoteDevice.getRemoteDevice( connection ); 
    41                 this.name = device.getFriendlyName( true ); 
    42         } 
    43  
    44         public RemoteNode( final String name, 
    45                            final StreamConnection conn ) throws IOException { 
    46                 this.name = name; 
    47                 this.connection = conn; 
    48                 this.device = RemoteDevice.getRemoteDevice( conn ); 
    49         } 
    50  
    51         public String getName() { 
    52                 return name; 
    53         } 
    54  
    55         public void ensureConnected() throws IOException { 
    56                 if( device == null ) { 
    57                         throw new IllegalStateException( "Already closed node" ); 
    58                 } else if( connection == null ) { 
    59                         connection = ( StreamConnection ) Connector.open( device.getBluetoothAddress() ); 
    60                 } 
    61  
    62                 try { 
    63                         in = connection.openInputStream(); 
    64                 } catch( IOException ex ) { 
    65                         ex.printStackTrace(); 
    66                         throw new RuntimeException( "Bad:" + ex.getMessage() ); 
    67                 } 
    68                 try { 
    69                         out = connection.openOutputStream(); 
    70                 } catch( IOException ex ) { 
    71                         ex.printStackTrace(); 
    72                         throw new RuntimeException( "Bad:" + ex.getMessage() ); 
    73                 } 
    74                 if( pump != null && pump.isAlive() ) { 
    75                         pump.interrupt(); 
    76                 } 
    77                 pump = new Thread( this, "network pump" ); 
    78                 pump.start(); 
    79 //              return this; 
    80         } 
    81  
    82         public void setListener( final IConnectionListener l ) { 
    83                 this.listener = l; 
    84         } 
    85  
    86         public void send( final IDatagram data ) { 
    87                 if( out != null ) { 
    88                         try { 
    89                                 final GenericDatagram gdata = new GenericDatagram( data ); 
    90                                 gdata.write( out ); 
    91                         } catch( IOException ex ) { 
    92                                 ex.printStackTrace(); 
    93                                 throw new RuntimeException( ex.getMessage() ); 
    94                         } 
    95                         if( listener != null ) { 
    96                                 listener.wasSent( data ); 
    97                         } 
    98                 } 
    99         } 
    100  
    101         public void close() { 
    102                 if( in != null ) { 
    103                         try { 
    104                                 in.close(); 
    105                         } catch( IOException e ) { 
    106                                 e.printStackTrace(); 
    107                         } finally { 
    108                                 in = null; 
    109                         } 
    110                 } 
    111                 if( out != null ) { 
    112                         try { 
    113                                 out.close(); 
    114                         } catch( IOException e ) { 
    115                                 e.printStackTrace(); 
    116                         } finally { 
    117                                 out = null; 
    118                         } 
    119                 } 
    120                 if( connection != null ) { 
    121                         try { 
    122                                 connection.close(); 
    123                         } catch( IOException e ) { 
    124                                 e.printStackTrace(); 
    125                         } finally { 
    126                                 connection = null; 
    127                         } 
    128                 } 
    129                 if( listener != null ) { 
    130                         listener.closed(); 
    131                 } 
    132                 if( pump != null && pump.isAlive() ) { 
    133                         pump.interrupt(); 
    134                 } 
    135                 pump = null; 
    136                 device = null; 
    137         } 
    138  
    139  
    140         public void run() { 
    141                 try { 
    142                         while( true ) { 
    143                                 synchronized( this ) { 
    144                                         if( in.available() > 0 ) { 
    145                                                 final GenericDatagram data = new GenericDatagram( in ); 
    146                                                 if( listener != null ) { 
    147                                                         listener.received( data.wrapped ); 
    148                                                 } 
    149                                         } 
    150                                         try { 
    151                                                 wait( 100 ); 
    152                                         } catch( InterruptedException e ) { 
    153                                         } 
    154                                 } 
    155                         } 
    156                 } catch( IOException e ) { 
    157                         e.printStackTrace(); 
    158                         return; 
    159                 } 
    160         } 
    161  
    162  
    163         public String toString() { 
    164                 return getName(); 
    165         } 
     23    private String name; 
     24 
     25    private RemoteDevice device; 
     26    private IConnectionListener listener = null; 
     27    private StreamConnection connection = null; 
     28 
     29    private transient InputStream in; 
     30    private transient OutputStream out; 
     31    private transient Thread pump; 
     32 
     33    private final Object connectLock = new Object(); 
     34 
     35    public RemoteNode( final RemoteDevice device ) throws IOException { 
     36        this( device, null ); 
     37    } 
     38 
     39    public RemoteNode( final StreamConnection conn ) throws IOException { 
     40        this( null, null, conn ); 
     41    } 
     42 
     43    public RemoteNode( final RemoteDevice device, 
     44                       final StreamConnection conn ) throws IOException { 
     45        this( null, device, conn ); 
     46    } 
     47 
     48    public RemoteNode( final String name, 
     49                       final RemoteDevice device, 
     50                       final StreamConnection conn ) throws IOException { 
     51        if ( device == null && conn == null ) { 
     52            throw new IllegalArgumentException( "No-no-no, David Blein! device =null && conn = null" ); 
     53        } 
     54 
     55        if ( device == null ) { 
     56            this.device = RemoteDevice.getRemoteDevice( conn ); 
     57        } else { 
     58            this.device = device; 
     59        } 
     60        if ( name == null ) { 
     61            this.name = this.device.getFriendlyName( true ); 
     62        } else { 
     63            this.name = name; 
     64        } 
     65        connection = conn; 
     66    } 
     67 
     68    private static String getBluetoothURL( final RemoteDevice device ) { 
     69        return Remote.BTSPP_SCHEME + device.getBluetoothAddress() + ":1"; 
     70    } 
     71 
     72    public RemoteNode( final String name, 
     73                       final StreamConnection conn ) throws IOException { 
     74        this( name, null, conn ); 
     75    } 
     76 
     77    public String getName() { 
     78        return name; 
     79    } 
     80 
     81    public synchronized void start() { 
     82        checkStatus(); 
     83        if ( pump == null ) { 
     84            pump = new Thread( this, "network pump" ); 
     85            pump.start(); 
     86        } 
     87    } 
     88 
     89    private void checkStatus() { 
     90        if ( isClosed() ) { 
     91            throw new IllegalStateException( "Already closed node" ); 
     92        } 
     93    } 
     94 
     95    private boolean isClosed() { 
     96        return device == null; 
     97    } 
     98 
     99    public synchronized void setListener( final IConnectionListener l ) { 
     100        //start(); 
     101        this.listener = l; 
     102    } 
     103 
     104    public void send( final IDatagram data ) { 
     105        //start(); 
     106        checkStatus(); 
     107        synchronized ( connectLock ) { 
     108            while ( out == null ) { 
     109                try { 
     110                    connectLock.wait(); 
     111                } catch ( InterruptedException e ) { 
     112                    e.printStackTrace(); 
     113                } 
     114            } 
     115        } 
     116        synchronized ( this ) { 
     117            try { 
     118                final GenericDatagram gdata = new GenericDatagram( data ); 
     119                gdata.write( out ); 
     120            } catch ( IOException ex ) { 
     121                ex.printStackTrace(); 
     122                throw new RuntimeException( ex.getMessage() ); 
     123            } 
     124            if ( listener != null ) { 
     125                listener.wasSent( data ); 
     126            } 
     127        } 
     128    } 
     129 
     130    public synchronized void close() { 
     131        if ( isClosed() ) { 
     132            return; 
     133        } 
     134        if ( pump != null && pump.isAlive() ) { 
     135            pump.interrupt(); 
     136            if ( pump != Thread.currentThread() ) { 
     137                try { 
     138                    pump.join(); 
     139                } catch ( InterruptedException e ) { 
     140                    e.printStackTrace(); 
     141                } 
     142            } 
     143        } 
     144        if ( in != null ) { 
     145            synchronized ( in ) { 
     146                try { 
     147                    in.close(); 
     148                } catch ( IOException e ) { 
     149                    e.printStackTrace(); 
     150                } finally { 
     151                    in = null; 
     152                } 
     153            } 
     154        } 
     155        if ( out != null ) { 
     156            synchronized ( out ) { 
     157                try { 
     158                    out.close(); 
     159                } catch ( IOException e ) { 
     160                    e.printStackTrace(); 
     161                } finally { 
     162                    out = null; 
     163                } 
     164            } 
     165        } 
     166        if ( connection != null ) { 
     167            try { 
     168                connection.close(); 
     169            } catch ( IOException e ) { 
     170                e.printStackTrace(); 
     171            } finally { 
     172                connection = null; 
     173            } 
     174        } 
     175        if ( listener != null ) { 
     176            listener.closed(); 
     177        } 
     178        pump = null; 
     179        device = null; 
     180    } 
     181 
     182 
     183    public void run() { 
     184        try { 
     185            synchronized ( this ) { 
     186                if ( isClosed() ) { 
     187                    return; 
     188                } 
     189                ensurePipelineOpened(); 
     190            } 
     191            synchronized ( connectLock ) { 
     192                connectLock.notifyAll(); 
     193            } 
     194            while ( !isClosed() ) { 
     195                synchronized ( this ) { 
     196                    final int timeout; 
     197                    if ( in.available() > 0 ) { 
     198                        final GenericDatagram data = new GenericDatagram( in ); 
     199                        if ( listener != null ) { 
     200                            listener.received( data.wrapped ); 
     201                        } 
     202                        timeout = 50; 
     203                    } else { 
     204                        timeout = 250; 
     205                    } 
     206                    try { 
     207                        wait( timeout ); 
     208                    } catch ( InterruptedException e ) { 
     209                    } 
     210                } 
     211            } 
     212        } catch ( Throwable e ) { 
     213            e.printStackTrace(); 
     214            return; 
     215        } finally { 
     216            pump = null; 
     217            close(); 
     218        } 
     219    } 
     220 
     221    private void ensurePipelineOpened() throws IOException { 
     222        if ( connection == null ) { 
     223            final String addr = getBluetoothURL( device ); 
     224            connection = ( StreamConnection )Connector.open( addr ); 
     225        } 
     226        if ( in == null ) { 
     227            try { 
     228                in = connection.openInputStream(); 
     229            } catch ( IOException ex ) { 
     230                ex.printStackTrace(); 
     231                throw new RuntimeException( "Can't open input stream:" + ex.getMessage() ); 
     232            } 
     233        } 
     234        if ( out == null ) { 
     235            try { 
     236                out = connection.openOutputStream(); 
     237            } catch ( IOException ex ) { 
     238                ex.printStackTrace(); 
     239                throw new RuntimeException( "Can't open output stream:" + ex.getMessage() ); 
     240            } 
     241        } 
     242    } 
     243 
     244 
     245    public String toString() { 
     246        return getName(); 
     247    } 
    166248} 
  • chess/src/chess/remote/impl/debug/DebugRemote.java

    r17 r19  
    149149        } 
    150150 
    151         public void ensureConnected() throws IOException { 
     151        public void start() { 
    152152 
    153153        } 
     
    225225        } 
    226226 
    227         public void ensureConnected() throws IOException { 
     227        public void start() { 
    228228            if ( listener == null ) { 
    229                 throw new IllegalStateException( "listener can't be null in ensureConnected!" ); 
     229                throw new IllegalStateException( "listener can't be null in start!" ); 
    230230            } 
    231231            //ïîñûëàåì íà÷àëüíóþ ïîñëåäîâàòåëüíîñòü -- 
  • chess/src/chess/ui/ChessMIDlet.java

    r15 r19  
    1010import chess.game.Player; 
    1111import chess.remote.*; 
    12 import chess.remote.impl.Remote; 
    1312 
    1413 
     
    4039 
    4140    public final Screen startForm = new StartMenuScreen( this ); 
    42     private final Screen choosePlayerForm = new ChoosePlayerForm( this ); 
     41    private final Screen choosePlayerForm = new ChoosePlayerScreen( this ); 
    4342    private final GameCanvas gameCanvas = new GameCanvas( this ); 
    4443    private final WaitScreen waitScreen = new WaitScreen( 
     
    5958    public ChessMIDlet() throws Exception { 
    6059        display = Display.getDisplay( this ); 
    61         remote = Remote.create(); 
     60        remote = Util.create(); 
    6261 
    6362        waitScreen.addCommand( cancelCommand ); 
     
    7170    public void connectToServer( final IRemoteNode server ) { 
    7271        try { 
     72            display.setCurrent( gameCanvas ); 
    7373            app = new App( 
    7474                    ChessMIDlet.this, 
     
    7777                    server 
    7878            ); 
    79             display.setCurrent( gameCanvas ); 
    8079        } catch ( Exception e ) { 
    8180            e.printStackTrace(); 
     
    188187 
    189188    protected void searchGame() { 
     189        display.setCurrent( searchForm ); 
    190190        searchForm.refresh( false ); 
    191         display.setCurrent( searchForm ); 
    192191        Util.log.println( "search server" ); 
    193192    } 
  • chess/src/chess/ui/ChoosePlayerScreen.java

    r18 r19  
    1111 *         created 31.01.2009 at 19:29:43 
    1212 */ 
    13 public class ChoosePlayerForm extends Form implements CommandListener, ItemCommandListener { 
    14     private final ChessMIDlet midlet; 
     13public class ChoosePlayerScreen extends BaseListScreen implements IChoiceListener { 
     14    public ChoosePlayerScreen( final ChessMIDlet midlet ) { 
     15        super( midlet, MSG.getMessage( "choose-player.title" ) ); 
     16        addItem( Player.WHITE.name() ); 
     17        addItem( Player.BLACK.name() ); 
     18        setChoiceListener( this ); 
    1519 
    16     private final StringItem whiteItem = new StringItem( 
    17             Player.WHITE.name(), 
    18             "", 
    19             StringItem.BUTTON 
    20     ); 
    21     private final StringItem blackItem = new StringItem( 
    22             Player.BLACK.name(), 
    23             "", 
    24             StringItem.BUTTON 
    25     ); 
    26  
    27     public ChoosePlayerForm( final ChessMIDlet midlet ) { 
    28         super( MSG.getMessage( "choose-player.title" ) ); 
    29         this.midlet = midlet; 
    30  
    31  
    32         whiteItem.setDefaultCommand( midlet.okCommand ); 
    33         whiteItem.setItemCommandListener( this ); 
    34         whiteItem.setLayout( Item.LAYOUT_EXPAND | Item.LAYOUT_VEXPAND ); 
    35  
    36         blackItem.setDefaultCommand( midlet.okCommand ); 
    37         blackItem.setItemCommandListener( this ); 
    38         blackItem.setLayout( Item.LAYOUT_EXPAND | Item.LAYOUT_VEXPAND ); 
    39  
    40         append( whiteItem ); 
    41         append( blackItem ); 
    42  
    43         //addCommand( midlet.okCommand ); 
    4420        addCommand( midlet.backCommand ); 
    45  
    46         setCommandListener( this ); 
    4721    } 
    4822 
    49  
    50     public void commandAction( final Command command, 
    51                                final Displayable displayable ) { 
    52         /*if ( command == midlet.okCommand ) { 
    53             final int index = getSelectedIndex(); 
    54             if ( index >= 0 ) { 
    55                 midlet.newGame( Player.byType( index ) ); 
     23    public void choosed( final Command c, 
     24                         final int selectedIndex ) { 
     25        if ( c == midlet.okCommand ) { 
     26            switch ( selectedIndex ) { 
     27                case 0: 
     28                    midlet.newGame( Player.WHITE ); 
     29                    return; 
     30                case 1: 
     31                    midlet.newGame( Player.BLACK ); 
     32                    return; 
    5633            } 
    57         } else */ 
    58         if ( command == midlet.backCommand ) { 
     34        } else if ( c == midlet.backCommand ) { 
    5935            midlet.showStartScreen(); 
    6036        } 
    6137    } 
    62  
    63     public void commandAction( final Command command, 
    64                                final Item item ) { 
    65         if ( command == midlet.okCommand ) { 
    66             if ( item == whiteItem ) { 
    67                 midlet.newGame( Player.WHITE ); 
    68             } else if ( item == blackItem ) { 
    69                 midlet.newGame( Player.BLACK ); 
    70             } 
    71         } 
    72     } 
    7338} 
  • chess/src/chess/ui/GameCanvas.java

    r17 r19  
    3737    public final int downKey; 
    3838 
    39     protected Player player; 
     39    //protected Player player; 
    4040    protected IGame game; 
    4141 
     
    5555 
    5656 
    57     private static final int MARGIN = 2; 
     57    private static final int MARGIN = 1; 
    5858    //colors 
    5959    private static final int BG_COLOR = 0xFFFFFF; 
     
    164164        //paint desk 
    165165        if ( game != null ) { 
    166             final int width = game.getWidth(); 
    167             final int height = game.getHeight(); 
    168  
    169             final int deskWidth = canvasWidth - MARGIN; 
    170             final int deskHeight = canvasHeight - MARGIN; 
    171  
    172             //ðåçåðâèðóåì ñòîëáöû/ñòðîêè äëÿ ïîîäïèñåé 
     166            final int nX = game.getWidth(); 
     167            final int nY = game.getHeight(); 
     168 
     169            final int availableWidth = canvasWidth - 2 * MARGIN; 
     170            final int availableHeight = canvasHeight - 2 * MARGIN; 
     171 
     172            final Font font = g.getFont(); 
     173            final int fontHeight = font.getHeight(); 
     174 
     175            //ðåçåðâèðóåì ìåñòî ïîä èíôîðìåðû: 2 * (âûñîòîé rows ñòðîê + îòñòóïû ) 
     176            //ñ÷èòàåì, ñêîëüêî íóæíî ñòðî÷åê, ÷òîáû íàïèñàòü "Áåëûå: 1235 ñåê <ñïèñîê âçÿòûõ ôèãóð>" 
     177            final int charWidth = font.charWidth( 'W' ); 
     178            final int chars = Math.max( 
     179                    Player.WHITE.name().length(), 
     180                    Player.BLACK.name().length() 
     181            ) + ": 99999 sec".length() + 16/*16 units per player*/; 
     182 
     183            final int rows = ( int )Math.floor( availableWidth / ( 1.0f * charWidth * chars ) ) + 1; 
     184            final int informerHeight = rows * fontHeight; 
     185 
     186            final int _availableHeight = availableHeight - 2 * ( informerHeight + MARGIN ); 
     187 
     188            //ðåçåðâèðóåì 2 ñòîëáöà è 2 ñòðîêè äëÿ ïîäïèñåé 
    173189            cellSize = Math.min( 
    174                     deskWidth / ( width + 2 ), 
    175                     deskHeight / ( height + 2 ) 
     190                    availableWidth / ( nX + 2 ), 
     191                    _availableHeight / ( nY + 2 ) 
    176192            ); 
    177193 
     
    180196            } 
    181197 
    182             final int _deskWidth = cellSize * ( width + 2 ); 
    183             final int _deskHeight = cellSize * ( height + 2 ); 
     198            final int _deskWidth = cellSize * ( nX + 2 ); 
     199            final int _deskHeight = cellSize * ( nY + 2 ); 
    184200 
    185201            final int vDeskMargin = ( canvasHeight - _deskHeight ) / 2; 
     
    189205 
    190206            //draw labels 
    191             drawLabels( g, width, height ); 
     207            drawLabels( g, nX, nY ); 
    192208 
    193209            //draw desk and units 
    194             for ( int _y = 0; _y < height; _y++ ) { 
    195                 for ( int _x = 0; _x < width; _x++ ) { 
     210            for ( int _y = 0; _y < nY; _y++ ) { 
     211                for ( int _x = 0; _x < nX; _x++ ) { 
    196212                    final int x = toScreenX( _x ); 
    197213                    final int y = toScreenY( _y ); 
     
    232248                final int x = toScreenX( focusedCell.x ); 
    233249                final int y = toScreenY( focusedCell.y ); 
    234                 g.drawRect( x + 1, y + 1, cellSize - 2, cellSize - 2 ); 
    235                 g.drawRect( x, y, cellSize, cellSize ); 
     250                g.drawRoundRect( x + 1, y + 1, cellSize - 2, cellSize - 2, 2, 2 ); 
     251                g.drawRoundRect( x, y, cellSize, cellSize, 2, 2 ); 
    236252            } 
    237253            if ( selectedCell != null ) { 
     
    239255                final int x = toScreenX( selectedCell.x ); 
    240256                final int y = toScreenY( selectedCell.y ); 
    241                 g.drawRect( x + 1, y + 1, cellSize - 2, cellSize - 2 ); 
    242                 g.drawRect( x, y, cellSize, cellSize ); 
     257                g.drawRoundRect( x + 1, y + 1, cellSize - 2, cellSize - 2, 2, 2 ); 
     258                g.drawRoundRect( x, y, cellSize, cellSize, 2, 2 ); 
    243259            } 
    244260 
     
    257273            ); 
    258274 
    259             drawInformers( g, canvasHeight, _deskWidth, vDeskMargin, hDeskMargin ); 
    260         } 
    261     } 
    262  
    263     private void drawLabels( final Graphics g, final int width, final int height ) { 
     275            drawInformers( g, availableWidth, informerHeight ); 
     276        } 
     277    } 
     278 
     279    private void drawLabels( final Graphics g, 
     280                             final int nX, 
     281                             final int nY ) { 
    264282        //draw labels 
    265283        { 
    266284            g.setColor( LABELS_COLOR ); 
    267285            final int x1 = toScreenX( -1 ); 
    268             final int x2 = toScreenX( width ); 
    269             for ( int i = 0; i < height; i++ ) { 
     286            final int x2 = toScreenX( nX ); 
     287            for ( int i = 0; i < nY; i++ ) { 
    270288                final int y = toScreenY( i ); 
    271289 
     
    285303            } 
    286304            final int y1 = toScreenY( -1 ); 
    287             final int y2 = toScreenY( height ); 
    288             for ( int i = 0; i < width; i++ ) { 
     305            final int y2 = toScreenY( nY ); 
     306            for ( int i = 0; i < nX; i++ ) { 
    289307                final int x = toScreenX( i ); 
    290308 
     
    308326 
    309327    private void drawInformers( final Graphics g, 
    310                                 final int canvasHeight, 
    311                                 final int _deskWidth, 
    312                                 final int vDeskMargin, 
    313                                 final int hDeskMargin ) { 
    314         final int height = vDeskMargin - MARGIN - 2; 
    315         final int x = hDeskMargin; 
    316         final int width = _deskWidth; 
     328                                final int width, 
     329                                final int height ) { 
     330        final int x = MARGIN; 
     331        final int canvasHeight = getHeight(); 
    317332 
    318333        drawInformer( g, 
     
    323338 
    324339        drawInformer( g, 
    325                       x, canvasHeight - vDeskMargin + 1, 
     340                      x, canvasHeight - height - 2 * MARGIN, 
    326341                      width, height, 
    327342                      Player.WHITE 
     
    336351                               final Player player ) { 
    337352        g.drawRect( x, y, width, height ); 
    338         final String name = this.player == player ? player.name() + " (you)" : player.name(); 
     353        final String name = game.getOwner() == player ? player.name() + " (you)" : player.name(); 
    339354        final int inset = 2; 
    340355        g.drawString( name, 
     
    348363        final long timing = game.getTiming( player ); 
    349364 
    350         final String time = ":" + String.valueOf( timing / 1000 ) + " s"; 
     365        final String time = ": " + String.valueOf( timing / 1000 ) + " s"; 
    351366        final int timeWidth = font.stringWidth( time ); 
    352367        g.drawString( time, 
  • chess/src/chess/ui/JoinGameScreen.java

    r17 r19  
    1414 * Time: 15:30:43<br/> 
    1515 */ 
    16 public class JoinGameScreen extends List implements CommandListener, IClientListener { 
    17     private final ChessMIDlet midlet; 
     16public class JoinGameScreen extends BaseListScreen implements IChoiceListener, IClientListener { 
     17    //private final ChessMIDlet midlet; 
    1818 
    1919    private IRemoteNode[] nodes; 
     
    3737 
    3838    public JoinGameScreen( final ChessMIDlet midlet ) { 
    39         super( MSG.getMessage( "join-game.title" ), Choice.IMPLICIT ); 
    40         this.midlet = midlet; 
     39        super( midlet, MSG.getMessage( "join-game.title" ) ); 
     40        //this.midlet = midlet; 
    4141 
    4242        scanningNetworkAlert.setTimeout( Alert.FOREVER ); 
     
    4848        scanningNetworkAlert.setCommandListener( this ); 
    4949 
    50         addCommand( midlet.okCommand ); 
     50        //addCommand( midlet.okCommand ); 
    5151        addCommand( midlet.refreshCommand ); 
    5252        addCommand( midlet.backCommand ); 
    5353 
    54         setSelectCommand( midlet.okCommand ); 
     54        //setSelectCommand( midlet.okCommand ); 
    5555 
    56         setCommandListener( this ); 
     56        //setCommandListener( this ); 
     57        setChoiceListener( this ); 
    5758    } 
    5859 
     
    7980        //todo check process.status() and display error message 
    8081 
    81         deleteAll(); 
     82        removeAllItems(); 
    8283        nodes = servers; 
    8384        if ( nodes == null || nodes.length == 0 ) { 
     
    8687            for ( int i = 0; i < nodes.length; i++ ) { 
    8788                final IRemoteNode node = nodes[i]; 
    88                 append( node.getName(), null ); 
     89                addItem( node.getName() ); 
    8990            } 
    9091            midlet.display.setCurrent( this ); 
     
    101102                } 
    102103            } 
    103         } else if ( command == midlet.backCommand ) { 
    104             midlet.showStartScreen(); 
    105         } else if ( command == midlet.okCommand ) { 
    106             final int index = getSelectedIndex(); 
    107             if ( index >= 0 && index < nodes.length ) { 
    108                 final IRemoteNode server = nodes[index]; 
     104        }  
     105        super.commandAction( command, displayable ); 
     106    } 
     107 
     108    public void choosed( final Command c, 
     109                         final int selectedIndex ) { 
     110        if ( c == getDefaultCommand() ) { 
     111            if ( selectedIndex >= 0 && selectedIndex < nodes.length ) { 
     112                final IRemoteNode server = nodes[selectedIndex]; 
    109113                midlet.connectToServer( server ); 
    110114            } 
    111         } else if ( command == midlet.refreshCommand ) { 
     115        } else if ( c == midlet.backCommand ) { 
     116            midlet.showStartScreen(); 
     117        } else if ( c == midlet.refreshCommand ) { 
    112118            refresh( true ); 
    113119        } 
  • chess/src/chess/ui/StartMenuScreen.java

    r15 r19  
    1111 * Time: 15:20:49<br/> 
    1212 */ 
    13 public class StartMenuScreen extends Form implements /*CommandListener, */ItemCommandListener { 
    14     private final ChessMIDlet midlet; 
     13public class StartMenuScreen extends BaseListScreen implements IChoiceListener { 
     14    public StartMenuScreen( final ChessMIDlet midlet ) { 
     15        super( midlet, MSG.getMessage( "start-menu.title" ) ); 
    1516 
    16     private final StringItem newGameItem = new StringItem( 
    17             MSG.getMessage( "start-menu.new-game" ), 
    18             "", 
    19             StringItem.BUTTON 
    20     ); 
    21     private final StringItem joinGameItem = new StringItem( 
    22             MSG.getMessage( "start-menu.join-game" ), 
    23             "", 
    24             StringItem.BUTTON 
    25     ); 
    26     private final StringItem helpItem = new StringItem( 
    27             MSG.getMessage( "start-menu.help" ), 
    28             "", 
    29             StringItem.BUTTON 
    30     ); 
    31     private final StringItem exitItem = new StringItem( 
    32             MSG.getMessage( "start-menu.exit" ), 
    33             "", 
    34             StringItem.BUTTON 
    35     ); 
     17        addItem( MSG.getMessage( "start-menu.new-game" ) ); 
     18        addItem( MSG.getMessage( "start-menu.join-game" ) ); 
     19        addItem( MSG.getMessage( "start-menu.help" ) ); 
     20        addItem( MSG.getMessage( "start-menu.exit" ) ); 
    3621 
    37     public StartMenuScreen( final ChessMIDlet midlet ) { 
    38         super( MSG.getMessage( "start-menu.title" ) ); 
    39         this.midlet = midlet; 
    40  
    41         newGameItem.setDefaultCommand( midlet.okCommand ); 
    42         newGameItem.setItemCommandListener( this ); 
    43         newGameItem.setLayout( Item.LAYOUT_EXPAND | Item.LAYOUT_VEXPAND ); 
    44  
    45         joinGameItem.setDefaultCommand( midlet.okCommand ); 
    46         joinGameItem.setItemCommandListener( this ); 
    47         joinGameItem.setLayout( Item.LAYOUT_EXPAND | Item.LAYOUT_VEXPAND ); 
    48  
    49         helpItem.setDefaultCommand( midlet.okCommand ); 
    50         helpItem.setItemCommandListener( this ); 
    51         helpItem.setLayout( Item.LAYOUT_EXPAND | Item.LAYOUT_VEXPAND ); 
    52  
    53         exitItem.setDefaultCommand( midlet.okCommand ); 
    54         exitItem.setItemCommandListener( this ); 
    55         exitItem.setLayout( Item.LAYOUT_EXPAND | Item.LAYOUT_VEXPAND ); 
    56  
    57         append( newGameItem ); 
    58         append( joinGameItem ); 
    59         append( helpItem ); 
    60         append( exitItem ); 
     22        setChoiceListener( this ); 
    6123    } 
    6224 
    63     /*public void commandAction( final Command command, 
    64                                final Displayable displayable ) { 
    65         if ( command == midlet.okCommand ) { 
    66             //final int index = getSelectedIndex(); 
    67             //switch ( index ) { 
    68             //    case 0: 
    69             //        midlet.choosePlayer(); 
    70             //        return; 
    71             //    case 1: 
    72             //        midlet.searchGame(); 
    73             //        return; 
    74             //    case 2: 
    75             //        midlet.showHelp(); 
    76             //        return; 
    77             //} 
    78         } else { 
    79             midlet.exitGame(); 
    80         } 
    81     }*/ 
    82  
    83     public void commandAction( final Command command, 
    84                                final Item item ) { 
    85         if ( command == midlet.okCommand ) { 
    86             if ( item == newGameItem ) { 
    87                 midlet.choosePlayer(); 
    88             } else if ( item == joinGameItem ) { 
    89                 midlet.searchGame(); 
    90             } else if ( item == helpItem ) { 
    91                 midlet.showHelp(); 
    92             } else if ( item == exitItem ) { 
    93                 midlet.exitGame(); 
     25    public void choosed( final Command c, 
     26                         final int selectedIndex ) { 
     27        if ( c == midlet.okCommand ) { 
     28            switch ( selectedIndex ) { 
     29                case 0: 
     30                    midlet.choosePlayer(); 
     31                    return; 
     32                case 1: 
     33                    midlet.searchGame(); 
     34                    return; 
     35                case 2: 
     36                    midlet.showHelp(); 
     37                    return; 
     38                case 3: 
     39                    midlet.exitGame(); 
     40                    return; 
    9441            } 
    9542        } 
Note: See TracChangeset for help on using the changeset viewer.