Changeset 17 for chess


Ignore:
Timestamp:
02/03/09 18:30:09 (13 years ago)
Author:
BegemoT
Message:

something different

Location:
chess
Files:
18 edited

Legend:

Unmodified
Added
Removed
  • chess/chess.jad

    r15 r17  
    1 MIDlet-Jar-Size: 849833 
     1MIDlet-Jar-Size: 850554 
    22MIDlet-Jar-URL: chess.jar 
    33MIDlet-Name: chess 
  • chess/src/chess/control/BaseController.java

    r16 r17  
    3636    private int status; 
    3737 
     38    private long lastTimeStamp = System.currentTimeMillis(); 
     39 
    3840    private BaseController( final App app, 
    3941                            final GameCanvas ui, 
     
    5961            //wait for incoming actions log 
    6062            synchronized ( this ) { 
    61                 try { 
    62                     if ( player == null ) { 
    63                         //ñòàðõóåìñÿ íà ñëó÷àé, åñëè ñîáûòèÿ óæå óñïåëè ïðèéòè 
    64                         wait(); 
     63                while ( this.player == null ) { 
     64                    try { 
     65                        //ñòðàõóåìñÿ íà ñëó÷àé, åñëè ñîáûòèÿ óæå óñïåëè ïðèéòè 
     66                        wait( 150 ); 
     67                    } catch ( InterruptedException e ) { 
     68                        e.printStackTrace(); 
    6569                    } 
    66                 } catch ( InterruptedException e ) { 
    67                     e.printStackTrace(); 
    6870                } 
    6971            } 
    7072        } 
     73        lastTimeStamp = System.currentTimeMillis(); 
    7174    } 
    7275 
     
    115118    } 
    116119 
    117     protected void processSystemAction( final SystemAction sa ) { 
     120    protected synchronized void processSystemAction( final SystemAction sa ) { 
    118121        if ( sa.type() == SystemAction.SET_PLAYER ) { 
    119             synchronized ( this ) { 
    120                 player = sa.getPlayer(); 
    121             } 
     122            player = sa.getPlayer(); 
    122123            if ( isMaster() ) { 
    123124                throw new IllegalStateException( "Master should not got SET_PLAYER commands" ); 
     
    132133                } 
    133134            } 
     135            lastTimeStamp = System.currentTimeMillis(); 
    134136            setStatus( WAITING_FOR_LOCAL ); 
    135137        } else if ( sa.type() == SystemAction.SURRENDER ) { 
     
    145147 
    146148    public synchronized void wasSent( final IDatagram data ) { 
    147         setStatus( WAITING_FOR_OPPONENT ); 
     149        if ( status == WAITING_FOR_NETWORK ) { 
     150            setStatus( WAITING_FOR_OPPONENT ); 
     151        } 
    148152    } 
    149153 
     
    184188    public void keyPressed( final int code ) { 
    185189        ui.clearHighlightedCells(); 
    186         final Location fc = ui.getFocusedCell(); 
     190        final Location prevFC = ui.getFocusedCell(); 
    187191        int x, y; 
    188         if ( fc == null ) { 
     192        if ( prevFC == null ) { 
    189193            x = y = 0; 
    190194        } else { 
    191             x = fc.x; 
    192             y = fc.y; 
     195            x = prevFC.x; 
     196            y = prevFC.y; 
    193197        } 
    194198        if ( code == ui.leftKey ) { 
     
    228232                    && unit.getOwner() == player ) { 
    229233                ui.setSelectedCell( focused ); 
    230                 ui.setFocusedCell( null ); 
     234                ui.setFocusedCell( focused ); 
    231235 
    232236                ui.addCommand( app.getMidlet().backCommand ); 
     
    236240            if ( unit != null ) { 
    237241                final Location[] domain = highlightDomain( unit ); 
    238                 final int index = findNearest( domain, x, y ); 
    239                 if ( index >= 0 ) { 
    240                     ui.setFocusedCell( domain[index] ); 
    241                 } 
     242                //final int index = findNearest( domain, x, y ); 
     243                //if ( index >= 0 ) { 
     244                //    ui.setFocusedCell( domain[index] ); 
     245                //} 
     246                final Location _fc = new Location( x, y ); 
     247                ui.setFocusedCell( _fc ); 
    242248                if ( code == ui.fireKey ) { 
    243                     final Action action = new Action( 
    244                             player, 
    245                             0, 
    246                             selectedCell, 
    247                             ui.getFocusedCell() 
    248                     ); 
    249                     game.doAction( action ); 
    250                     ui.setFocusedCell( null ); 
    251                     ui.setSelectedCell( null ); 
    252                     ui.clearHighlightedCells(); 
    253                     postAction( action ); 
     249                    if ( selectedCell.equals( _fc ) ) { 
     250                        ui.setSelectedCell( null ); 
     251                        ui.removeCommand( app.getMidlet().backCommand ); 
     252                    } else { 
     253                        boolean inDomain = false; 
     254                        for ( int i = 0; i < domain.length; i++ ) { 
     255                            final Location ld = domain[i]; 
     256                            if ( ld.equals( _fc ) ) { 
     257                                inDomain = true; 
     258                                break; 
     259                            } 
     260                        } 
     261                        if ( inDomain ) { 
     262                            final Location focusedCell = ui.getFocusedCell(); 
     263 
     264                            ui.setFocusedCell( null ); 
     265                            ui.setSelectedCell( null ); 
     266                            ui.clearHighlightedCells(); 
     267 
     268                            ui.removeCommand( app.getMidlet().backCommand ); 
     269 
     270 
     271                            postAction( selectedCell, focusedCell ); 
     272                        } 
     273                    } 
    254274                } 
    255275            } else { 
     
    258278 
    259279        } 
     280    } 
     281 
     282    private void postAction( final Location from, 
     283                             final Location to ) { 
     284        final Action action = new Action( 
     285                player, 
     286                System.currentTimeMillis() - lastTimeStamp, 
     287                from, 
     288                to 
     289        ); 
     290        game.doAction( action ); 
     291        postAction( action ); 
    260292    } 
    261293 
  • chess/src/chess/game/Action.java

    r11 r17  
    1616public class Action implements IDatagram { 
    1717    private Player player; 
     18    //âðÿä ëè êòî-òî áóäåò äóìàòü áîëüøå ìèëëèîíà ñåêóíä 
    1819    private int duration; 
    1920 
     
    2627 
    2728    public Action( final Player player, 
    28                    final int duration, 
     29                   final long duration, 
    2930                   final Location from, 
    3031                   final Location to ) { 
    3132        this.player = player; 
    32         this.duration = duration; 
     33        if ( duration > Integer.MAX_VALUE ) { 
     34            throw new IllegalArgumentException( "Too big value:" + duration ); 
     35        } 
     36        this.duration = ( int )duration; 
    3337        this.from = from; 
    3438        this.to = to; 
     
    5559    } 
    5660 
    57     public int duration() { 
     61    public long duration() { 
    5862        return duration; 
    5963    } 
  • chess/src/chess/game/Game.java

    r9 r17  
    1414 */ 
    1515public final class Game implements IGame { 
    16         private static final int SIZE = 8; 
    17  
    18  
    19         private IGameListener listener = null; 
    20  
    21         private final Vector actionsLog = new Vector( 64 ); 
    22  
    23         private final Vector[] activeUnits = new Vector[2]; 
    24         private final Vector[] deadUnits = new Vector[2]; 
    25  
    26         private final AUnit[] desk = new AUnit[SIZE * SIZE]; 
    27  
    28         public Game() { 
    29                 activeUnits[0] = new Vector( 16 ); 
    30                 activeUnits[1] = new Vector( 16 ); 
    31  
    32                 deadUnits[0] = new Vector( 16 ); 
    33                 deadUnits[1] = new Vector( 16 ); 
    34  
    35                 for( int i = 0; i < SIZE; i++ ) { 
    36                         put( new Pawn( Player.WHITE, this, new Location( i, 1 ) ) ); 
    37                         put( new Pawn( Player.BLACK, this, new Location( i, SIZE - 2 ) ) ); 
    38                 } 
    39  
    40                 final int yWhite = 0; 
    41                 final int yBlack = SIZE - 1; 
    42                 put( new Castle( Player.WHITE, this, new Location( 0, yWhite ) ) ); 
    43                 put( new Castle( Player.WHITE, this, new Location( SIZE - 1, yWhite ) ) ); 
    44                 put( new Castle( Player.BLACK, this, new Location( 0, yBlack ) ) ); 
    45                 put( new Castle( Player.BLACK, this, new Location( SIZE - 1, yBlack ) ) ); 
    46  
    47                 put( new Knight( Player.WHITE, this, new Location( 1, yWhite ) ) ); 
    48                 put( new Knight( Player.WHITE, this, new Location( SIZE - 2, yWhite ) ) ); 
    49                 put( new Knight( Player.BLACK, this, new Location( 1, yBlack ) ) ); 
    50                 put( new Knight( Player.BLACK, this, new Location( SIZE - 2, yBlack ) ) ); 
    51  
    52                 put( new Bishop( Player.WHITE, this, new Location( 2, yWhite ) ) ); 
    53                 put( new Bishop( Player.WHITE, this, new Location( SIZE - 3, yWhite ) ) ); 
    54                 put( new Bishop( Player.BLACK, this, new Location( 2, yBlack ) ) ); 
    55                 put( new Bishop( Player.BLACK, this, new Location( SIZE - 3, yBlack ) ) ); 
    56  
    57                 put( new Queen( Player.WHITE, this, new Location( 3, yWhite ) ) ); 
    58                 put( new Queen( Player.BLACK, this, new Location( 3, yBlack ) ) ); 
    59  
    60                 put( new King( Player.WHITE, this, new Location( 4, yWhite ) ) ); 
    61                 put( new King( Player.BLACK, this, new Location( 4, yBlack ) ) ); 
    62         } 
    63  
    64         public int getWidth() { 
    65                 return SIZE; 
    66         } 
    67  
    68         public int getHeight() { 
    69                 return SIZE; 
    70         } 
    71  
    72         public boolean isFree( final Location l ) { 
    73                 return isFree( l.x, l.y ); 
    74         } 
    75  
    76         public boolean isFree( final int x, 
    77                                final int y ) { 
    78                 return isFree( toIndex( x, y ) ); 
    79         } 
    80  
    81         public boolean isFree( final byte index ) { 
    82                 return desk[index] == null; 
    83         } 
    84  
    85         public boolean isValid( final Location l ) { 
    86                 return isValid( l.x, l.y ); 
    87         } 
    88  
    89         public boolean isValid( final int x, 
    90                                 final int y ) { 
    91                 return ( x >= 0 && x < SIZE ) && ( y >= 0 && y < SIZE ); 
    92         } 
    93  
    94         public boolean isValid( final byte index ) { 
    95                 return index >= 0 && index < SIZE * SIZE; 
    96         } 
    97  
    98         public Vector getActiveUnits( final Player p ) { 
    99                 return activeUnits[p.ordinal()]; 
    100         } 
    101  
    102         public Vector getDeadUnits( final Player p ) { 
    103                 return deadUnits[p.ordinal()]; 
    104         } 
    105  
    106         public IUnit getUnit( final Location l ) { 
    107                 return getUnit( l.x, l.y ); 
    108         } 
    109  
    110         public IUnit getUnit( final int x, 
    111                               final int y ) { 
    112                 return getUnit( toIndex( x, y ) ); 
    113         } 
    114  
    115         public IUnit getUnit( final byte index ) { 
    116                 return desk[index]; 
    117         } 
    118  
    119         protected void put( final int x, 
    120                             final int y, 
    121                             final AUnit unit ) { 
    122                 desk[toIndex( x, y )] = unit; 
    123                 final int player = unit.getOwner().ordinal(); 
    124                 if( activeUnits[player].contains( unit ) ) { 
    125                         throw new IllegalStateException( "Unit already here:" + unit ); 
    126                 } 
    127                 activeUnits[player].addElement( unit ); 
    128         } 
    129  
    130         protected void put( final AUnit unit ) { 
    131                 final Location l = unit.getLocation(); 
    132                 put( l.x, l.y, unit ); 
    133         } 
    134  
    135         private void kill( final IUnit victim ) { 
    136                 final byte i = toIndex( victim.getLocation() ); 
    137                 if( desk[i] != victim ) { 
    138                         throw new IllegalStateException( "Killing victim is not on it's place:" + victim ); 
    139                 } 
    140                 desk[i] = null; 
    141  
    142                 final int pIndex = victim.getOwner().ordinal(); 
    143                 activeUnits[pIndex].removeElement( victim ); 
    144                 deadUnits[pIndex].addElement( victim ); 
    145         } 
    146  
    147         private void move( final AUnit u, 
    148                            final Location from, 
    149                            final Location to ) { 
    150                 desk[toIndex( from )] = null; 
    151                 desk[toIndex( to )] = u; 
    152                 u.setLocation( to ); 
    153         } 
    154  
    155         public void doAction( final Action a ) { 
    156                 //todo Action is mutable. a.clone()? 
    157                 actionsLog.addElement( a ); 
    158                 //todo check, can we really make movement? 
    159                 final Location from = a.from(); 
    160                 final IUnit actor = getUnit( from ); 
    161                 if( actor == null ) { 
    162                         throw new IllegalStateException( "Where is no unit at " + from ); 
    163                 } 
    164                 if( actor.getOwner() != a.getPlayer() ) { 
    165                         throw new IllegalStateException( "Unit " + actor + " is not owned by " + a.getPlayer() ); 
    166                 } 
    167  
    168                 final Location to = a.to(); 
    169                 final IUnit victim = getUnit( to ); 
    170                 if( victim != null && victim.getOwner() == actor.getOwner() ) { 
    171                         throw new IllegalStateException( "Can't take own unit:" + actor + " <> " + victim ); 
    172                 } 
    173  
    174                 if( victim != null ) { 
    175                         kill( victim ); 
    176                 } 
    177                 move( ( AUnit ) actor, from, to ); 
    178  
    179                 if( listener != null ) { 
    180                         listener.changed(); 
    181                 } 
    182         } 
    183  
    184         public Vector getActionsLog() { 
    185                 return actionsLog; 
    186         } 
    187  
    188         public void setListener( final IGameListener l ) { 
    189                 this.listener = l; 
    190         } 
    191  
    192         public byte toIndex( final Location l ) { 
    193                 return toIndex( l.x, l.y ); 
    194         } 
    195  
    196         public byte toIndex( final int x, 
    197                              final int y ) { 
    198                 check( x, y ); 
    199                 return ( byte ) ( x + y * SIZE ); 
    200         } 
    201  
    202         public Location toLocation( final byte index ) { 
    203                 return new Location( 
    204                                 index % SIZE, 
    205                                 index / SIZE 
    206                 ); 
    207         } 
    208  
    209         private final void check( final int x, 
    210                                   final int y ) { 
    211                 if( Util.SAFE_MODE && !isValid( x, y ) ) { 
    212                         throw new IllegalArgumentException( "Invalid location:" + x + ", " + y + " is out of bounds!" ); 
    213                 } 
    214         } 
     16    private static final int SIZE = 8; 
     17 
     18 
     19    private IGameListener listener = null; 
     20 
     21    private final Vector actionsLog = new Vector( 64 ); 
     22 
     23    private final Vector[] activeUnits = new Vector[2]; 
     24    private final Vector[] deadUnits = new Vector[2]; 
     25 
     26    private final AUnit[] desk = new AUnit[SIZE * SIZE]; 
     27 
     28    private final long[] timings = new long[]{ 0, 0 }; 
     29 
     30    public Game() { 
     31        activeUnits[0] = new Vector( 16 ); 
     32        activeUnits[1] = new Vector( 16 ); 
     33 
     34        deadUnits[0] = new Vector( 16 ); 
     35        deadUnits[1] = new Vector( 16 ); 
     36 
     37        for ( int i = 0; i < SIZE; i++ ) { 
     38            put( new Pawn( Player.WHITE, this, new Location( i, 1 ) ) ); 
     39            put( new Pawn( Player.BLACK, this, new Location( i, SIZE - 2 ) ) ); 
     40        } 
     41 
     42        final int yWhite = 0; 
     43        final int yBlack = SIZE - 1; 
     44        put( new Castle( Player.WHITE, this, new Location( 0, yWhite ) ) ); 
     45        put( new Castle( Player.WHITE, this, new Location( SIZE - 1, yWhite ) ) ); 
     46        put( new Castle( Player.BLACK, this, new Location( 0, yBlack ) ) ); 
     47        put( new Castle( Player.BLACK, this, new Location( SIZE - 1, yBlack ) ) ); 
     48 
     49        put( new Knight( Player.WHITE, this, new Location( 1, yWhite ) ) ); 
     50        put( new Knight( Player.WHITE, this, new Location( SIZE - 2, yWhite ) ) ); 
     51        put( new Knight( Player.BLACK, this, new Location( 1, yBlack ) ) ); 
     52        put( new Knight( Player.BLACK, this, new Location( SIZE - 2, yBlack ) ) ); 
     53 
     54        put( new Bishop( Player.WHITE, this, new Location( 2, yWhite ) ) ); 
     55        put( new Bishop( Player.WHITE, this, new Location( SIZE - 3, yWhite ) ) ); 
     56        put( new Bishop( Player.BLACK, this, new Location( 2, yBlack ) ) ); 
     57        put( new Bishop( Player.BLACK, this, new Location( SIZE - 3, yBlack ) ) ); 
     58 
     59        put( new Queen( Player.WHITE, this, new Location( 3, yWhite ) ) ); 
     60        put( new Queen( Player.BLACK, this, new Location( 3, yBlack ) ) ); 
     61 
     62        put( new King( Player.WHITE, this, new Location( 4, yWhite ) ) ); 
     63        put( new King( Player.BLACK, this, new Location( 4, yBlack ) ) ); 
     64    } 
     65 
     66    public int getWidth() { 
     67        return SIZE; 
     68    } 
     69 
     70    public int getHeight() { 
     71        return SIZE; 
     72    } 
     73 
     74    public boolean isFree( final Location l ) { 
     75        return isFree( l.x, l.y ); 
     76    } 
     77 
     78    public boolean isFree( final int x, 
     79                           final int y ) { 
     80        return isFree( toIndex( x, y ) ); 
     81    } 
     82 
     83    public boolean isFree( final byte index ) { 
     84        return desk[index] == null; 
     85    } 
     86 
     87    public boolean isValid( final Location l ) { 
     88        return isValid( l.x, l.y ); 
     89    } 
     90 
     91    public boolean isValid( final int x, 
     92                            final int y ) { 
     93        return ( x >= 0 && x < SIZE ) && ( y >= 0 && y < SIZE ); 
     94    } 
     95 
     96    public boolean isValid( final byte index ) { 
     97        return index >= 0 && index < SIZE * SIZE; 
     98    } 
     99 
     100    public Vector getActiveUnits( final Player p ) { 
     101        return activeUnits[p.ordinal()]; 
     102    } 
     103 
     104    public Vector getDeadUnits( final Player p ) { 
     105        return deadUnits[p.ordinal()]; 
     106    } 
     107 
     108    public IUnit getUnit( final Location l ) { 
     109        return getUnit( l.x, l.y ); 
     110    } 
     111 
     112    public IUnit getUnit( final int x, 
     113                          final int y ) { 
     114        return getUnit( toIndex( x, y ) ); 
     115    } 
     116 
     117    public IUnit getUnit( final byte index ) { 
     118        return desk[index]; 
     119    } 
     120 
     121    protected void put( final int x, 
     122                        final int y, 
     123                        final AUnit unit ) { 
     124        desk[toIndex( x, y )] = unit; 
     125        final int player = unit.getOwner().ordinal(); 
     126        if ( activeUnits[player].contains( unit ) ) { 
     127            throw new IllegalStateException( "Unit already here:" + unit ); 
     128        } 
     129        activeUnits[player].addElement( unit ); 
     130    } 
     131 
     132    protected void put( final AUnit unit ) { 
     133        final Location l = unit.getLocation(); 
     134        put( l.x, l.y, unit ); 
     135    } 
     136 
     137    private void kill( final IUnit victim ) { 
     138        final byte i = toIndex( victim.getLocation() ); 
     139        if ( desk[i] != victim ) { 
     140            throw new IllegalStateException( "Killing victim is not on it's place:" + victim ); 
     141        } 
     142        desk[i] = null; 
     143 
     144        final int pIndex = victim.getOwner().ordinal(); 
     145        activeUnits[pIndex].removeElement( victim ); 
     146        deadUnits[pIndex].addElement( victim ); 
     147    } 
     148 
     149    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 ); 
     155    } 
     156 
     157    public void doAction( final Action a ) { 
     158        //todo Action is mutable. a.clone()? 
     159        actionsLog.addElement( a ); 
     160        //todo check, can we really make movement? 
     161        final Location from = a.from(); 
     162        final IUnit actor = getUnit( from ); 
     163        if ( actor == null ) { 
     164            throw new IllegalStateException( "Where is no unit at " + from ); 
     165        } 
     166        if ( actor.getOwner() != a.getPlayer() ) { 
     167            throw new IllegalStateException( "Unit " + actor + " is not owned by " + a.getPlayer() ); 
     168        } 
     169 
     170        final Location to = a.to(); 
     171        final IUnit victim = getUnit( to ); 
     172        if ( victim != null && victim.getOwner() == actor.getOwner() ) { 
     173            throw new IllegalStateException( "Can't take own unit:" + actor + " <> " + victim ); 
     174        } 
     175 
     176        if ( victim != null ) { 
     177            kill( victim ); 
     178        } 
     179        move( ( AUnit )actor, from, to ); 
     180 
     181        timings[a.getPlayer().ordinal()] += a.duration(); 
     182 
     183        if ( listener != null ) { 
     184            listener.changed(); 
     185        } 
     186    } 
     187 
     188    public Vector getActionsLog() { 
     189        return actionsLog; 
     190    } 
     191 
     192    public long getTiming( final Player p ) { 
     193        return timings[p.ordinal()]; 
     194    } 
     195 
     196    public void setListener( final IGameListener l ) { 
     197        this.listener = l; 
     198    } 
     199 
     200    public byte toIndex( final Location l ) { 
     201        return toIndex( l.x, l.y ); 
     202    } 
     203 
     204    public byte toIndex( final int x, 
     205                         final int y ) { 
     206        check( x, y ); 
     207        return ( byte )( x + y * SIZE ); 
     208    } 
     209 
     210    public Location toLocation( final byte index ) { 
     211        return new Location( 
     212                index % SIZE, 
     213                index / SIZE 
     214        ); 
     215    } 
     216 
     217    private final void check( final int x, 
     218                              final int y ) { 
     219        if ( Util.SAFE_MODE && !isValid( x, y ) ) { 
     220            throw new IllegalArgumentException( "Invalid location:" + x + ", " + y + " is out of bounds!" ); 
     221        } 
     222    } 
    215223} 
  • chess/src/chess/game/IGame.java

    r4 r17  
    4444                          final int y ); 
    4545 
     46    public long getTiming( final Player p ); 
     47 
    4648    public IUnit getUnit( final byte index ); 
    4749 
  • chess/src/chess/game/IUnit.java

    r5 r17  
    2222     * @return 
    2323     */ 
    24     public Location[] canMoveTo(); 
    25  
    26     /** 
    27      * @deprecated ïîêà íå î÷åâèäíî, íóæåí ëè ýòîò ìåòîä 
    28      */ 
    29     public Location[] canAttack(); 
     24    public Location[] canMoveTo();     
    3025 
    3126    /** 
  • chess/src/chess/game/units/AUnit.java

    r7 r17  
    1212 */ 
    1313public abstract class AUnit implements IUnit { 
    14         protected final Player player; 
    15         protected final IGame game; 
    16         protected Location location; 
     14    protected final Player player; 
     15    protected final IGame game; 
     16    protected Location location; 
    1717 
    18         /** Âðåìåííàÿ ïåðåìåííàÿ äëÿ ñáîðà ïîëîæåíèé â ìåòîäàõ canMoveTo/canAttack */ 
    19         protected static final transient Vector _temp = new Vector( 16 ); 
    20         protected static final Location[] EMPTY = new Location[0]; 
     18    /** 
     19     * Âðåìåííàÿ ïåðåìåííàÿ äëÿ ñáîðà ïîëîæåíèé â ìåòîäàõ canMoveTo/canAttack 
     20     */ 
     21    protected static final transient Vector _temp = new Vector( 16 ); 
     22    protected static final Location[] EMPTY = new Location[0]; 
    2123 
    22         protected AUnit( final Player player, 
    23                          final IGame game, 
    24                          final Location location ) { 
    25                 this.player = player; 
    26                 this.game = game; 
    27                 this.location = location; 
    28         } 
     24    protected AUnit( final Player player, 
     25                     final IGame game, 
     26                     final Location location ) { 
     27        this.player = player; 
     28        this.game = game; 
     29        this.location = location; 
     30    } 
    2931 
    30         public final IGame getGame() { 
    31                 return game; 
    32         } 
     32    public final IGame getGame() { 
     33        return game; 
     34    } 
    3335 
    34         public final Player getOwner() { 
    35                 return player; 
    36         } 
     36    public final Player getOwner() { 
     37        return player; 
     38    } 
    3739 
    38         public final Location getLocation() { 
    39                 return location; 
    40         } 
     40    public final Location getLocation() { 
     41        return location; 
     42    } 
    4143 
    42         public void paint( final Graphics g, 
    43                            final int x, 
    44                            final int y, 
    45                            final int width, 
    46                            final int height ) { 
    47                 final boolean white = player == Player.WHITE; 
    48                 if( white ) { 
    49                         g.setColor( 0xFFFFFF ); 
    50                 } else { 
    51                         g.setColor( 0 ); 
    52                 } 
    53                 g.drawChar( 
    54                                 getSymbol( white ), 
    55                                 x + width / 2, 
    56                                 y + height * 2 / 3, 
    57                                 Graphics.HCENTER | Graphics.BASELINE 
    58                 ); 
    59         } 
     44    public void paint( final Graphics g, 
     45                       final int x, 
     46                       final int y, 
     47                       final int width, 
     48                       final int height ) { 
     49        final boolean white = player == Player.WHITE; 
     50        if ( white ) { 
     51            g.setColor( 0xFFFFFF ); 
     52        } else { 
     53            g.setColor( 0 ); 
     54        } 
     55        final int h = g.getFont().getHeight(); 
     56        g.drawChar( 
     57                getSymbol( white ), 
     58                x + width / 2, 
     59                y + ( height + h ) / 2, 
     60                Graphics.HCENTER | Graphics.BOTTOM 
     61        ); 
     62    } 
    6063 
    61         protected abstract char getSymbol( final boolean white ); 
     64    protected abstract char getSymbol( final boolean white ); 
    6265 
    63         public void setLocation( final Location location ) { 
    64                 this.location = location; 
    65         } 
     66    public void setLocation( final Location location ) { 
     67        this.location = location; 
     68    } 
    6669 
    67         public boolean canTransform() { 
    68                 return false; 
    69         } 
     70    public boolean canTransform() { 
     71        return false; 
     72    } 
    7073 
    71         public IUnit transform() { 
    72                 throw new IllegalArgumentException( "Queen can't transform" ); 
    73         } 
     74    public IUnit transform() { 
     75        throw new IllegalArgumentException( "Queen can't transform" ); 
     76    } 
    7477 
    75         public final boolean isOpponent( final IUnit u ) { 
    76                 return u.getOwner() != player; 
    77         } 
     78    public final boolean isOpponent( final IUnit u ) { 
     79        return u.getOwner() != player; 
     80    } 
    7881 
    79         protected static Location[] convertBuffer() { 
    80                 if( _temp.isEmpty() ) { 
    81                         return EMPTY; 
    82                 } 
     82    protected static Location[] convertBuffer() { 
     83        if ( _temp.isEmpty() ) { 
     84            return EMPTY; 
     85        } 
    8386 
    84                 final Location[] res = new Location[_temp.size()]; 
    85                 _temp.copyInto( res ); 
    86                 _temp.removeAllElements(); 
    87                 return res; 
    88         } 
     87        final Location[] res = new Location[_temp.size()]; 
     88        _temp.copyInto( res ); 
     89        _temp.removeAllElements(); 
     90        return res; 
     91    } 
    8992 
    90         protected static boolean checkAndAdd( final AUnit unit, 
    91                                               final IGame game, 
    92                                               final int x, 
    93                                               final int y ) { 
    94                 if( !game.isValid( x, y ) ) { 
    95                         return false; 
    96                 } 
    97                 final IUnit u = game.getUnit( x, y ); 
    98                 if( u != null ) { 
    99                         if( unit.isOpponent( u ) ) { 
    100                                 _temp.addElement( new Location( x, y ) ); 
    101                         } 
    102                         return false; 
    103                 } else { 
    104                         _temp.addElement( new Location( x, y ) ); 
    105                 } 
    106                 return true; 
     93    protected static boolean checkAndAdd( final AUnit unit, 
     94                                          final IGame game, 
     95                                          final int x, 
     96                                          final int y ) { 
     97        if ( !game.isValid( x, y ) ) { 
     98            return false; 
     99        } 
     100        final IUnit u = game.getUnit( x, y ); 
     101        if ( u != null ) { 
     102            if ( unit.isOpponent( u ) ) { 
     103                _temp.addElement( new Location( x, y ) ); 
     104            } 
     105            return false; 
     106        } else { 
     107            _temp.addElement( new Location( x, y ) ); 
     108        } 
     109        return true; 
    107110        } 
    108111} 
  • chess/src/chess/game/units/Bishop.java

    r7 r17  
    5656        } 
    5757 
    58         public Location[] canAttack() { 
    59                 throw new IllegalStateException( "Not implemented yet" ); 
    60         } 
    61  
    62  
    6358        protected char getSymbol( final boolean white ) { 
    6459                if( white ) { 
  • chess/src/chess/game/units/Castle.java

    r7 r17  
    5050    } 
    5151 
    52     public Location[] canAttack() { 
    53         _temp.removeAllElements(); 
    54  
    55         final Location l = location; 
    56         final int width = game.getWidth(); 
    57         final int height = game.getHeight(); 
    58         for ( int x = l.x + 1; x < width; x++ ) { 
    59             if ( !game.isValid( x, l.y ) ) { 
    60                 break; 
    61             } 
    62             final IUnit unit = game.getUnit( x, l.y ); 
    63             if ( unit != null && unit.getOwner() != player ) { 
    64                 _temp.addElement( new Location( x, l.y ) ); 
    65                 break; 
    66             } 
    67         } 
    68         for ( int x = l.x - 1; x >= 0; x-- ) { 
    69             if ( !game.isValid( x, l.y ) ) { 
    70                 break; 
    71             } 
    72             final IUnit unit = game.getUnit( x, l.y ); 
    73             if ( unit != null && unit.getOwner() != player ) { 
    74                 _temp.addElement( new Location( x, l.y ) ); 
    75                 break; 
    76             } 
    77         } 
    78         for ( int y = l.y + 1; y < height; y++ ) { 
    79             if ( !game.isValid( l.x, y ) ) { 
    80                 break; 
    81             } 
    82             final IUnit unit = game.getUnit( l.x, y ); 
    83             if ( unit != null && unit.getOwner() != player ) { 
    84                 _temp.addElement( new Location( l.x, y ) ); 
    85                 break; 
    86             } 
    87         } 
    88         for ( int y = l.y - 1; y >= 0; y-- ) { 
    89             if ( !game.isValid( l.x, y ) ) { 
    90                 break; 
    91             } 
    92             final IUnit unit = game.getUnit( l.x, y ); 
    93             if ( unit != null && unit.getOwner() != player ) { 
    94                 _temp.addElement( new Location( l.x, y ) ); 
    95                 break; 
    96             } 
    97         } 
    98  
    99  
    100         final Location[] res = new Location[_temp.size()]; 
    101         _temp.copyInto( res ); 
    102         _temp.removeAllElements(); 
    103         return res; 
    104     } 
    105  
    106  
    10752        protected char getSymbol(final boolean white) { 
    10853                if( white ) { 
  • chess/src/chess/game/units/King.java

    r7 r17  
    5353                return convertBuffer(); 
    5454        } 
    55  
    56         public Location[] canAttack() { 
    57                 throw new IllegalStateException( "Not implemented yet" ); 
    58         } 
    59  
    60  
     55         
    6156        protected char getSymbol( final boolean white ) { 
    6257                if( white ) { 
  • chess/src/chess/game/units/Knight.java

    r7 r17  
    6262        } 
    6363 
    64         public Location[] canAttack() { 
    65                 fillupBuffer( location ); 
    66  
    67                 _temp.removeAllElements(); 
    68                 for( int i = 0; i < 8; i++ ) { 
    69                         final int x = xBuff[i]; 
    70                         final int y = yBuff[i]; 
    71                         if( game.isValid( x, y ) ) { 
    72                                 final IUnit u = game.getUnit( x, y ); 
    73                                 if( u != null && u.getOwner() != player ) { 
    74                                         _temp.addElement( new Location( x, y ) ); 
    75                                 } 
    76                         } 
    77                 } 
    78                 return convertBuffer(); 
    79         } 
    80  
    81  
    8264        protected char getSymbol( final boolean white ) { 
    8365                if( white ) { 
  • chess/src/chess/game/units/Pawn.java

    r7 r17  
    7474        _temp.removeAllElements(); 
    7575        return res; 
    76     } 
    77  
    78     public Location[] canAttack() { 
    79         final Location l = getLocation(); 
    80         final int dir = ( player == Player.WHITE ) ? ( 1 ) : ( -1 ); 
    81         //áåëûå ñíèçó (y=0) ââåðõ 
    82         final Location l1 = new Location( l.x + 1, l.y + dir ); 
    83         final Location l2 = new Location( l.x - 1, l.y + dir ); 
    84         final IUnit u1 = game.getUnit( l1 ); 
    85         final IUnit u2 = game.getUnit( l2 ); 
    86         final boolean l1Valid = game.isValid( l1 ) && u1 != null && u1.getOwner() != player; 
    87         final boolean l2Valid = game.isValid( l2 ) && u2 != null && u2.getOwner() != player; 
    88         if ( l1Valid && l2Valid ) { 
    89             return new Location[]{ l1, l2 }; 
    90         } else if ( l1Valid ) { 
    91             return new Location[]{ l1 }; 
    92         } else if ( l2Valid ) { 
    93             return new Location[]{ l2 }; 
    94         } else { 
    95             return EMPTY; 
    96         } 
    97     } 
     76    }     
    9877 
    9978    public boolean canTransform() { 
  • chess/src/chess/game/units/Queen.java

    r7 r17  
    7676                return convertBuffer(); 
    7777        } 
    78  
    79         public Location[] canAttack() { 
    80                 throw new IllegalStateException( "Not implemented yet" ); 
    81         } 
    82  
     78         
    8379        protected char getSymbol( final boolean white ) { 
    8480                if( white ) { 
  • chess/src/chess/remote/impl/Remote.java

    r15 r17  
    9898        //return new Remote(); 
    9999//        return new DummyRemote(); 
    100         return new DebugRemote( 500, 500 ); 
     100        return new DebugRemote( 100, 100 ); 
    101101    } 
    102102 
  • chess/src/chess/remote/impl/debug/DebugRemote.java

    r15 r17  
    8484 
    8585    public IAsyncProcess waitForIncoming( final IServerListener l ) { 
    86         return new AsyncProcess( l ); 
     86        return new ServerAsyncProcess( l ); 
    8787    } 
    8888 
     
    104104    } 
    105105 
    106     private class AsyncProcess extends BaseAsyncProcess { 
    107         public AsyncProcess( final IServerListener listener ) { 
     106    private class ServerAsyncProcess extends BaseAsyncProcess { 
     107        public ServerAsyncProcess( final IServerListener listener ) { 
    108108            super( listener ); 
    109109            start(); 
     
    112112        public void run() { 
    113113            try { 
     114                setStatus( IN_PROCESS ); 
    114115                while ( true ) { 
    115116                    try { 
     
    122123                    if ( listener.incoming( new ClientRemoteNode() ) ) { 
    123124                        Util.log.println( "emulate incoming connection: OK" ); 
     125                        setStatus( SUCCEEDED ); 
    124126                        return; 
    125127                    } 
    126128                } 
     129            } catch ( Exception ex ) { 
     130                setStatus( FAILED ); 
    127131            } finally { 
    128132                listener.finished( null ); 
     
    162166                                        player = sa.getPlayer(); 
    163167                                        is = prepareLog( player ); 
    164                                     } 
    165                                     if ( sa.type() == SystemAction.YOUR_TURN ) { 
     168                                    } else if ( sa.type() == SystemAction.YOUR_TURN ) { 
    166169                                        try { 
    167170                                            if ( is.available() > 0 ) { 
     
    189192                                            e.printStackTrace(); 
    190193                                        } 
    191  
    192194                                    } 
    193195                                } 
     
    196198                        2 * networkLatency 
    197199                ); 
    198  
    199200            } 
    200201        } 
     
    242243                                    ) 
    243244                            ); 
     245                            if ( player == Player.WHITE ) { 
     246                                packet(); 
     247                            } else { 
     248                                listener.received( 
     249                                        new SystemAction( 
     250                                                SystemAction.YOUR_TURN, 
     251                                                player 
     252                                        ) 
     253                                ); 
     254                                //èíà÷å æäåì YOUR_TURN îò áåëûõ 
     255                            } 
    244256                        } 
    245257                    }, 
    246258                    2 * networkLatency 
    247259            ); 
    248             if ( player == Player.WHITE ) { 
    249                 packet(); 
    250             } else { 
    251                 //èíà÷å æäåì YOUR_TURN îò áåëûõ 
    252             } 
    253260        } 
    254261 
  • chess/src/chess/ui/ChoosePlayerForm.java

    r14 r17  
    4141        append( blackItem ); 
    4242 
    43         addCommand( midlet.okCommand ); 
     43        //addCommand( midlet.okCommand ); 
    4444        addCommand( midlet.backCommand ); 
    4545 
  • chess/src/chess/ui/GameCanvas.java

    r15 r17  
    11package chess.ui; 
    22 
     3import java.util.Vector; 
    34import javax.microedition.lcdui.*; 
    45 
    56import chess.MSG; 
     7import chess.Util; 
    68import chess.game.*; 
    79 
     
    181183            final int _deskHeight = cellSize * ( height + 2 ); 
    182184 
    183             vMargin = ( canvasHeight - _deskHeight ) / 2 + cellSize; 
    184             hMargin = ( canvasWidth - _deskWidth ) / 2 + cellSize; 
     185            final int vDeskMargin = ( canvasHeight - _deskHeight ) / 2; 
     186            final int hDeskMargin = ( canvasWidth - _deskWidth ) / 2; 
     187            vMargin = vDeskMargin + cellSize; 
     188            hMargin = hDeskMargin + cellSize; 
    185189 
    186190            //draw labels 
    187             { 
    188                 g.setColor( LABELS_COLOR ); 
    189                 final int x1 = toScreenX( -1 ); 
    190                 final int x2 = toScreenX( width ); 
    191                 for ( int i = 0; i < height; i++ ) { 
    192                     final int y = toScreenY( i ); 
    193  
    194                     final int baseline = y + cellSize * 3 / 4; 
    195                     g.drawChar( 
    196                             ROWS[i], 
    197                             x1 + cellSize / 2, 
    198                             baseline, 
    199                             Graphics.HCENTER | Graphics.BASELINE 
    200                     ); 
    201                     g.drawChar( 
    202                             ROWS[i], 
    203                             x2 + cellSize / 2, 
    204                             baseline, 
    205                             Graphics.HCENTER | Graphics.BASELINE 
    206                     ); 
    207                 } 
    208                 final int y1 = toScreenY( -1 ); 
    209                 final int y2 = toScreenY( height ); 
    210                 for ( int i = 0; i < width; i++ ) { 
    211                     final int x = toScreenX( i ); 
    212  
    213                     final int baseline1 = y1 + cellSize * 3 / 4; 
    214                     final int baseline2 = y2 + cellSize * 3 / 4; 
    215                     g.drawChar( 
    216                             COLUMNS[i], 
    217                             x + cellSize / 2, 
    218                             baseline1, 
    219                             Graphics.HCENTER | Graphics.BASELINE 
    220                     ); 
    221                     g.drawChar( 
    222                             COLUMNS[i], 
    223                             x + cellSize / 2, 
    224                             baseline2, 
    225                             Graphics.HCENTER | Graphics.BASELINE 
    226                     ); 
    227                 } 
    228             } 
     191            drawLabels( g, width, height ); 
    229192 
    230193            //draw desk and units 
     
    293256                    _deskHeight - cellSize * 2 
    294257            ); 
     258 
     259            drawInformers( g, canvasHeight, _deskWidth, vDeskMargin, hDeskMargin ); 
     260        } 
     261    } 
     262 
     263    private void drawLabels( final Graphics g, final int width, final int height ) { 
     264        //draw labels 
     265        { 
     266            g.setColor( LABELS_COLOR ); 
     267            final int x1 = toScreenX( -1 ); 
     268            final int x2 = toScreenX( width ); 
     269            for ( int i = 0; i < height; i++ ) { 
     270                final int y = toScreenY( i ); 
     271 
     272                final int baseline = y + cellSize * 3 / 4; 
     273                g.drawChar( 
     274                        ROWS[i], 
     275                        x1 + cellSize / 2, 
     276                        baseline, 
     277                        Graphics.HCENTER | Graphics.BASELINE 
     278                ); 
     279                g.drawChar( 
     280                        ROWS[i], 
     281                        x2 + cellSize / 2, 
     282                        baseline, 
     283                        Graphics.HCENTER | Graphics.BASELINE 
     284                ); 
     285            } 
     286            final int y1 = toScreenY( -1 ); 
     287            final int y2 = toScreenY( height ); 
     288            for ( int i = 0; i < width; i++ ) { 
     289                final int x = toScreenX( i ); 
     290 
     291                final int baseline1 = y1 + cellSize * 3 / 4; 
     292                final int baseline2 = y2 + cellSize * 3 / 4; 
     293                g.drawChar( 
     294                        COLUMNS[i], 
     295                        x + cellSize / 2, 
     296                        baseline1, 
     297                        Graphics.HCENTER | Graphics.BASELINE 
     298                ); 
     299                g.drawChar( 
     300                        COLUMNS[i], 
     301                        x + cellSize / 2, 
     302                        baseline2, 
     303                        Graphics.HCENTER | Graphics.BASELINE 
     304                ); 
     305            } 
     306        } 
     307    } 
     308 
     309    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; 
     317 
     318        drawInformer( g, 
     319                      x, MARGIN, 
     320                      width, height, 
     321                      Player.BLACK 
     322        ); 
     323 
     324        drawInformer( g, 
     325                      x, canvasHeight - vDeskMargin + 1, 
     326                      width, height, 
     327                      Player.WHITE 
     328        ); 
     329    } 
     330 
     331    private void drawInformer( final Graphics g, 
     332                               final int x, 
     333                               final int y, 
     334                               final int width, 
     335                               final int height, 
     336                               final Player player ) { 
     337        g.drawRect( x, y, width, height ); 
     338        final String name = this.player == player ? player.name() + " (you)" : player.name(); 
     339        final int inset = 2; 
     340        g.drawString( name, 
     341                      x + inset, 
     342                      y + inset, 
     343                      Graphics.LEFT | Graphics.TOP 
     344        ); 
     345        final Font font = g.getFont(); 
     346        final int nameWidth = font.stringWidth( name ); 
     347 
     348        final long timing = game.getTiming( player ); 
     349 
     350        final String time = ":" + String.valueOf( timing / 1000 ) + " s"; 
     351        final int timeWidth = font.stringWidth( time ); 
     352        g.drawString( time, 
     353                      x + inset + nameWidth + inset, 
     354                      y + inset, 
     355                      Graphics.LEFT | Graphics.TOP 
     356        ); 
     357 
     358 
     359        final Vector dead = game.getDeadUnits( player.opponent() ); 
     360        final int length = dead.size(); 
     361        final int size = 10; 
     362        final int xStart = x + nameWidth + timeWidth + 3 * inset; 
     363        for ( int i = 0; i < length; i++ ) { 
     364            final IUnit u = ( IUnit )dead.elementAt( i ); 
     365            u.paint( g, 
     366                     xStart + i * size, 
     367                     y + inset, 
     368                     size, size 
     369            ); 
    295370        } 
    296371    } 
     
    345420            case ACTIVE: 
    346421                midlet.display.setCurrent( this ); 
     422                Util.log.println( "status:ACTIVE" ); 
    347423                break; 
    348424            case WAITING_FOR_NETWORK: 
     
    351427                } 
    352428                waitScreen.setText( MSG.getMessage( "wait.for-network" ) ); 
     429                Util.log.println( "status:WAIT_FOR_NETWORK" ); 
    353430                break; 
    354431            case WAITING_FOR_OPPONENT: 
     
    357434                } 
    358435                waitScreen.setText( MSG.getMessage( "wait.for-opponent" ) ); 
     436                Util.log.println( "status:WAIT_FOR_OPPONENT" ); 
    359437                break; 
    360438            case DISCONNECTED: 
     439                Util.log.println( "status:DISCONNECTED" ); 
    361440                //todo implement 
    362441        } 
  • chess/src/chess/ui/JoinGameScreen.java

    r15 r17  
    7979        //todo check process.status() and display error message 
    8080 
     81        deleteAll(); 
    8182        nodes = servers; 
    8283        if ( nodes == null || nodes.length == 0 ) { 
     
    104105        } else if ( command == midlet.okCommand ) { 
    105106            final int index = getSelectedIndex(); 
    106             if ( index >= 0 ) { 
     107            if ( index >= 0 && index < nodes.length ) { 
    107108                final IRemoteNode server = nodes[index]; 
    108109                midlet.connectToServer( server ); 
Note: See TracChangeset for help on using the changeset viewer.