Changeset 10 for chess


Ignore:
Timestamp:
02/02/09 10:39:32 (13 years ago)
Author:
BegemoT
Message:
 
Location:
chess/src/chess
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • chess/src/chess/remote/impl/DummyRemote.java

    r9 r10  
    1515 */ 
    1616public class DummyRemote implements IRemote { 
    17         private final Timer timer = new Timer(); 
     17    private final Timer timer = new Timer(); 
    1818 
    19         public IAsyncProcess waitForIncoming( final IServerListener l ) { 
    20                 timer.schedule( 
    21                                 new TimerTask() { 
    22                                         public void run() { 
    23                                                 try { 
    24                                                         final RemoteNode client = new RemoteNode( 
    25                                                                         new DummyStreamConnection() 
    26                                                         ); 
    27                                                         l.incoming( client ); 
    28                                                 } catch( IOException e ) { 
    29                                                         e.printStackTrace(); 
    30                                                 } 
    31                                         } 
    32                                 }, 
    33                                 1000 
    34                 ); 
    35                 return null; 
    36         } 
     19    public IAsyncProcess waitForIncoming( final IServerListener l ) { 
     20        timer.schedule( 
     21                new TimerTask() { 
     22                    public void run() { 
     23                        //new DummyStreamConnection() 
     24                        final IRemoteNode client = new IRemoteNode() { 
     25                            public String getName() { 
     26                                return ""; 
     27                            } 
    3728 
    38         public void getAvailable( final boolean force, 
    39                                   final IClientListener l ) { 
    40                 timer.schedule( 
    41                                 new TimerTask() { 
    42                                         public void run() { 
    43                                                 l.finished( new IRemoteNode[0] ); 
    44                                         } 
    45                                 }, 
    46                                 100 
    47                 ); 
    48         } 
     29                            public void setListener( final IConnectionListener l ) { 
    4930 
    50         private static class DummyStreamConnection implements StreamConnection { 
    51                 public InputStream openInputStream() throws IOException { 
    52                         return new ByteArrayInputStream( new byte[] { } ); 
    53                 } 
     31                            } 
    5432 
    55                 public DataInputStream openDataInputStream() throws IOException { 
    56                         throw new RuntimeException( "Not implemented yet" ); 
    57                 } 
     33                            public void ensureConnected() throws IOException { 
    5834 
    59                 public OutputStream openOutputStream() throws IOException { 
    60                         return new ByteArrayOutputStream(); 
    61                 } 
     35                            } 
    6236 
    63                 public DataOutputStream openDataOutputStream() throws IOException { 
    64                         throw new RuntimeException( "Not implemented yet" ); 
    65                 } 
     37                            public void send( final IDatagram data ) { 
    6638 
    67                 public void close() throws IOException { 
     39                            } 
    6840 
    69                 } 
    70         } 
     41                            public void close() { 
     42 
     43                            } 
     44                        }; 
     45                        l.incoming( client ); 
     46                    } 
     47                }, 
     48                1000 
     49        ); 
     50        return null; 
     51    } 
     52 
     53    public void getAvailable( final boolean force, 
     54                              final IClientListener l ) { 
     55        timer.schedule( 
     56                new TimerTask() { 
     57                    public void run() { 
     58                        l.finished( new IRemoteNode[0] ); 
     59                    } 
     60                }, 
     61                100 
     62        ); 
     63    } 
     64 
     65    private static class DummyStreamConnection implements StreamConnection { 
     66        public InputStream openInputStream() throws IOException { 
     67            return new ByteArrayInputStream( new byte[]{ } ); 
     68        } 
     69 
     70        public DataInputStream openDataInputStream() throws IOException { 
     71            throw new RuntimeException( "Not implemented yet" ); 
     72        } 
     73 
     74        public OutputStream openOutputStream() throws IOException { 
     75            return new ByteArrayOutputStream(); 
     76        } 
     77 
     78        public DataOutputStream openDataOutputStream() throws IOException { 
     79            throw new RuntimeException( "Not implemented yet" ); 
     80        } 
     81 
     82        public void close() throws IOException { 
     83 
     84        } 
     85    } 
    7186} 
  • chess/src/chess/ui/ChessMIDlet.java

    r9 r10  
    2222 */ 
    2323public class ChessMIDlet extends MIDlet implements CommandListener, ItemCommandListener { 
    24         static { 
    25                 MSG.initLocalizationSupport(); 
    26         } 
     24    static { 
     25        MSG.initLocalizationSupport(); 
     26    } 
    2727 
    28         /* commands */ 
    29         public final Command okCommand = new Command( MSG.getMessage( "command.ok" ), Command.OK, 1 ); 
    30         public final Command exitCommand = new Command( MSG.getMessage( "command.exit" ), Command.EXIT, 1 ); 
    31         public final Command closeCommand = new Command( MSG.getMessage( "command.close" ), Command.SCREEN, 1 ); 
    32         public final Command backCommand = new Command( MSG.getMessage( "command.back" ), Command.CANCEL, 1 ); 
    33         public final Command refreshCommand = new Command( MSG.getMessage( "command.refresh" ), Command.SCREEN, 1 ); 
    34         public final Command newCommand = new Command( MSG.getMessage( "command.new" ), Command.SCREEN, 1 ); 
    35         public final Command joinCommand = new Command( MSG.getMessage( "command.join" ), Command.SCREEN, 1 ); 
    36         public final Command helpCommand = new Command( MSG.getMessage( "command.help" ), Command.HELP, 1 ); 
     28    /* commands */ 
     29    public final Command okCommand = new Command( MSG.getMessage( "command.ok" ), Command.OK, 1 ); 
     30    public final Command exitCommand = new Command( MSG.getMessage( "command.exit" ), Command.EXIT, 1 ); 
     31    public final Command closeCommand = new Command( MSG.getMessage( "command.close" ), Command.SCREEN, 1 ); 
     32    public final Command backCommand = new Command( MSG.getMessage( "command.back" ), Command.CANCEL, 1 ); 
     33    public final Command refreshCommand = new Command( MSG.getMessage( "command.refresh" ), Command.SCREEN, 1 ); 
     34    public final Command newCommand = new Command( MSG.getMessage( "command.new" ), Command.SCREEN, 1 ); 
     35    public final Command joinCommand = new Command( MSG.getMessage( "command.join" ), Command.SCREEN, 1 ); 
     36    public final Command helpCommand = new Command( MSG.getMessage( "command.help" ), Command.HELP, 1 ); 
    3737 
    38         /* GUI */ 
    39         public final Display display; 
     38    /* GUI */ 
     39    public final Display display; 
    4040 
    41         private final Screen startForm = new StartScreen( this ); 
    42         private final ChoosePlayerForm choosePlayerForm = new ChoosePlayerForm( this ); 
    43         private final Screen waitScreen = new WaitScreen( MSG.getMessage( "wait-for-bluetooth.title" ) ); 
    44         private final JoinGameScreen searchForm = new JoinGameScreen( this ); 
    45         private final GameCanvas gameCanvas = new GameCanvas( this ); 
    46         private final Screen helpScreen = new HelpScreen( this ); 
     41    private final Screen startForm = new StartScreen( this ); 
     42    private final ChoosePlayerForm choosePlayerForm = new ChoosePlayerForm( this ); 
     43    //private final Screen waitScreen = new WaitScreen( this, MSG.getMessage( "wait-for-bluetooth.title" ), ); 
     44    private final JoinGameScreen searchForm = new JoinGameScreen( this ); 
     45    private final GameCanvas gameCanvas = new GameCanvas( this ); 
     46    private final Screen helpScreen = new HelpScreen( this ); 
    4747 
    48         /* network */ 
    49         private final IRemote remote; 
     48    /* network */ 
     49    private final IRemote remote; 
    5050 
    51         /* current game application */ 
    52         private App app; 
     51    /* current game application */ 
     52    private App app; 
    5353 
    54         public ChessMIDlet() throws Exception { 
    55                 display = Display.getDisplay( this ); 
    56                 remote = Remote.create(); 
     54    public ChessMIDlet() throws Exception { 
     55        display = Display.getDisplay( this ); 
     56        remote = Remote.create(); 
    5757 
    5858 
    59         } 
     59    } 
    6060 
    61         public IRemote getRemoteManager() { 
    62                 return remote; 
    63         } 
     61    public IRemote getRemoteManager() { 
     62        return remote; 
     63    } 
    6464 
    65         public void connectToServer( final IRemoteNode server ) { 
    66                 try { 
    67                         server.ensureConnected();//todo may be nahren? 
    68                         app = new App( 
    69                                         ChessMIDlet.this, 
    70                                         new Game(), 
    71                                         gameCanvas, 
    72                                         server 
    73                         ); 
    74                         display.setCurrent( gameCanvas ); 
    75                 } catch( IOException e ) { 
    76                         e.printStackTrace(); 
    77                 } 
    78                 //display.setCurrent( gameCanvas ); 
    79         } 
     65    public void connectToServer( final IRemoteNode server ) { 
     66        try { 
     67            server.ensureConnected();//todo may be nahren? 
     68            app = new App( 
     69                    ChessMIDlet.this, 
     70                    new Game(), 
     71                    gameCanvas, 
     72                    server 
     73            ); 
     74            display.setCurrent( gameCanvas ); 
     75        } catch ( IOException e ) { 
     76            e.printStackTrace(); 
     77        } 
     78        //display.setCurrent( gameCanvas ); 
     79    } 
    8080 
    81         protected void startApp() { 
    82                 showStartScreen(); 
    83         } 
     81    protected void startApp() { 
     82        showStartScreen(); 
     83    } 
    8484 
    85         protected void pauseApp() { 
    86         } 
     85    protected void pauseApp() { 
     86    } 
    8787 
    88         protected void destroyApp( boolean unconditional ) { 
    89         } 
     88    protected void destroyApp( boolean unconditional ) { 
     89    } 
    9090 
    91         public void showStartScreen() { 
    92                 display.setCurrent( startForm ); 
    93                 Util.log.println( "start menu" ); 
    94         } 
     91    public void showStartScreen() { 
     92        display.setCurrent( startForm ); 
     93        Util.log.println( "start menu" ); 
     94    } 
    9595 
    96         protected void choosePlayer() { 
    97                 display.setCurrent( choosePlayerForm ); 
    98                 Util.log.println( "choose player" ); 
    99         } 
     96    protected void choosePlayer() { 
     97        display.setCurrent( choosePlayerForm ); 
     98        Util.log.println( "choose player" ); 
     99    } 
    100100 
    101         protected void newGame( final Player player ) { 
    102                 display.setCurrent( waitScreen ); 
    103                 Util.log.println( "new game:" + player ); 
    104                 remote.waitForIncoming( 
    105                                 new IServerListener() { 
    106                                         public synchronized boolean incoming( final IRemoteNode client ) { 
    107                                                 try { 
    108                                                         client.ensureConnected(); 
    109                                                         app = new App( 
    110                                                                         ChessMIDlet.this, 
    111                                                                         new Game(), 
    112                                                                         gameCanvas, 
    113                                                                         client, 
    114                                                                         player 
    115                                                         ); 
    116                                                         display.setCurrent( gameCanvas ); 
    117                                                         Util.log.println( "joined client" ); 
    118                                                         return true; 
    119                                                 } catch( IOException e ) { 
    120                                                         e.printStackTrace(); 
    121                                                         return false; 
    122                                                 } 
    123                                         } 
     101    protected void newGame( final Player player ) { 
     102        final WaitScreen waitScreen = new WaitScreen( 
     103                this, 
     104                MSG.getMessage( "wait-for-bluetooth.title" ), 
     105                gameCanvas 
     106        ); 
     107        display.setCurrent( waitScreen ); 
     108        Util.log.println( "new game:" + player ); 
     109        remote.waitForIncoming( 
     110                new IServerListener() { 
     111                    public synchronized boolean incoming( final IRemoteNode client ) { 
     112                        try { 
     113                            client.ensureConnected(); 
     114                            app = new App( 
     115                                    ChessMIDlet.this, 
     116                                    new Game(), 
     117                                    gameCanvas, 
     118                                    client, 
     119                                    player 
     120                            ); 
     121                            display.setCurrent( gameCanvas ); 
     122                            Util.log.println( "joined client" ); 
     123                            return true; 
     124                        } catch ( IOException e ) { 
     125                            e.printStackTrace(); 
     126                            return false; 
     127                        } 
     128                    } 
    124129 
    125                                         public void finished( final Object res ) { 
    126                                                 display.setCurrent( 
    127                                                                 new Alert( "Can't connect" ) 
    128                                                 ); 
    129                                         } 
    130                                 } 
    131                 ); 
    132         } 
     130                    public void finished( final Object res ) { 
     131                        waitScreen.finished( res ); 
     132                        //display.setCurrent( 
     133                        //        new Alert( "Can't connect" ) 
     134                        //); 
     135                    } 
     136                } 
     137        ); 
     138    } 
    133139 
    134         protected void searchGame() { 
    135                 searchForm.refresh( false ); 
    136                 display.setCurrent( searchForm ); 
    137                 Util.log.println( "search server" ); 
    138         } 
     140    protected void searchGame() { 
     141        searchForm.refresh( false ); 
     142        display.setCurrent( searchForm ); 
     143        Util.log.println( "search server" ); 
     144    } 
    139145 
    140         protected void showHelp() { 
    141                 display.setCurrent( helpScreen ); 
    142                 Util.log.println( "show help" ); 
    143         } 
     146    protected void showHelp() { 
     147        display.setCurrent( helpScreen ); 
     148        Util.log.println( "show help" ); 
     149    } 
    144150 
    145         public void exit() { 
    146                 destroyApp( true ); 
    147                 notifyDestroyed(); 
    148         } 
     151    public void exit() { 
     152        destroyApp( true ); 
     153        notifyDestroyed(); 
     154    } 
    149155 
    150         public void commandAction( final Command c, 
    151                                    final Displayable d ) { 
    152                 if( c == exitCommand ) { 
    153                         exit(); 
    154                 } else if( c == newCommand ) { 
    155                         choosePlayer(); 
    156                 } else if( c == joinCommand ) { 
    157                         searchGame(); 
    158                 } else if( c == helpCommand ) { 
    159                         showHelp(); 
    160                 } 
    161         } 
     156    public void commandAction( final Command c, 
     157                               final Displayable d ) { 
     158        if ( c == exitCommand ) { 
     159            exit(); 
     160        } else if ( c == newCommand ) { 
     161            choosePlayer(); 
     162        } else if ( c == joinCommand ) { 
     163            searchGame(); 
     164        } else if ( c == helpCommand ) { 
     165            showHelp(); 
     166        } 
     167    } 
    162168 
    163         public void commandAction( final Command command, 
    164                                    final Item item ) { 
     169    public void commandAction( final Command command, 
     170                               final Item item ) { 
    165171 
    166         } 
     172    } 
    167173 
    168174//      public static void main( String[] args ) { 
  • chess/src/chess/ui/GameCanvas.java

    r7 r10  
    1515 */ 
    1616public class GameCanvas extends Canvas implements CommandListener, IGameListener { 
    17         public static final int ACTIVE = 0; 
    18         public static final int WAITING_FOR_NETWORK = 1; 
    19         public static final int WAITING_FOR_OPPONENT = 2; 
    20         public static final int DISCONNECTED = 3; 
    21  
    22         private static final char[] COLUMNS = new char[] { 
    23                         'A', 'B', 'C', 'D', 'E', 'F', 'J', 'H' 
    24         }; 
    25         private static final char[] ROWS = new char[] { 
    26                         '1', '2', '3', '4', '5', '6', '7', '8' 
    27         }; 
    28  
    29         protected final ChessMIDlet midlet; 
    30  
    31         public final int fireKey; 
    32         public final int leftKey; 
    33         public final int rightKey; 
    34         public final int upKey; 
    35         public final int downKey; 
    36  
    37         protected Player player; 
    38         protected IGame game; 
    39  
    40         private int status = ACTIVE; 
    41  
    42         private Location focusedCell; 
    43         private Location selectedCell; 
    44  
    45         //bitwise masks -- 1 bit per cell 
    46         private final BitSet64 highlightedCells = new BitSet64(); 
    47         private final BitSet64 attackedCells = new BitSet64(); 
    48  
    49         private IUIListener listener = null; 
    50         private transient int vMargin; 
    51         private transient int hMargin; 
    52         private transient int cellSize; 
    53  
    54  
    55         private static final int MARGIN = 2; 
    56         //colors 
    57         private static final int BG_COLOR = 0xFFFFFF; 
    58         private static final int LABELS_COLOR = 0; 
    59  
    60         public GameCanvas( final ChessMIDlet midlet ) { 
    61                 this.midlet = midlet; 
    62                 fireKey = getKeyCode( FIRE ); 
    63                 leftKey = getKeyCode( LEFT ); 
    64                 rightKey = getKeyCode( RIGHT ); 
    65                 upKey = getKeyCode( UP ); 
    66                 downKey = getKeyCode( DOWN ); 
    67  
    68                 addCommand( midlet.closeCommand ); 
    69                 addCommand( midlet.helpCommand ); 
    70                 setCommandListener( this ); 
    71         } 
    72  
    73         public void init( final IGame game ) { 
    74                 this.game = game; 
    75                 game.setListener( this ); 
    76         } 
    77  
    78         public void setUIListener( final IUIListener listener ) { 
    79                 this.listener = listener; 
    80         } 
    81  
    82         public Location getFocusedCell() { 
    83                 return focusedCell; 
    84         } 
    85  
    86         public void setFocusedCell( final Location l ) { 
    87                 if( focusedCell == null && l == null ) { 
    88                         //nothing 
    89                 } else if( focusedCell == null ) { 
    90                         focusedCell = l; 
    91                         repaintCell( l.x, l.y ); 
    92                 } else if( l == null ) { 
    93                         repaintCell( focusedCell.x, focusedCell.y ); 
    94                         focusedCell = l; 
    95                 } else { 
    96                         final Location old = focusedCell; 
    97                         focusedCell = l; 
    98                         repaintCell( old.x, old.y ); 
    99                         repaintCell( l.x, l.y ); 
    100                 } 
    101         } 
    102  
    103         public Location getSelectedCell() { 
    104                 return selectedCell; 
    105         } 
    106  
    107         public void setSelectedCell( final Location l ) { 
    108                 if( selectedCell == null && l == null ) { 
    109                         //nothing 
    110                 } else if( selectedCell == null ) { 
    111                         selectedCell = l; 
    112                         repaintCell( l.x, l.y ); 
    113                 } else if( l == null ) { 
    114                         repaintCell( selectedCell.x, selectedCell.y ); 
    115                         selectedCell = l;                        
    116                 } else { 
    117                         final Location old = selectedCell; 
    118                         selectedCell = l; 
    119                         repaintCell( old.x, old.y ); 
    120                         repaintCell( l.x, l.y ); 
    121                 } 
    122         } 
    123  
    124         public void addHighlightedCell( final Location l, 
    125                                         final boolean attack ) { 
    126                 addHighlightedCell( l.x, l.y, attack ); 
    127         } 
    128  
    129         public void addHighlightedCell( final int x, 
    130                                         final int y, 
    131                                         final boolean attack ) { 
    132                 final byte index = game.toIndex( x, y ); 
    133                 if( attack ) { 
    134                         attackedCells.set( index ); 
    135                 } else { 
    136                         highlightedCells.set( index ); 
    137                 } 
    138                 repaintCell( x, y ); 
    139         } 
    140  
    141         public void clearHighlightedCells() { 
    142                 highlightedCells.clear(); 
    143                 attackedCells.clear(); 
    144                 repaint(); 
    145         } 
    146  
    147         protected void paint( final Graphics g ) { 
    148                 final int canvasWidth = getWidth(); 
    149                 final int canvasHeight = getHeight(); 
    150                 //clear 
    151                 g.setColor( BG_COLOR ); 
    152                 g.fillRect( 0, 0, canvasWidth, canvasHeight ); 
    153  
    154                 //paint desk 
    155                 if( game != null ) { 
    156                         final int width = game.getWidth(); 
    157                         final int height = game.getHeight(); 
    158  
    159                         final int deskWidth = canvasWidth - MARGIN; 
    160                         final int deskHeight = canvasHeight - MARGIN; 
    161  
    162                         //ðåçåðâèðóåì ñòîëáöû/ñòðîêè äëÿ ïîîäïèñåé 
    163                         cellSize = Math.min( 
    164                                         deskWidth / ( width + 2 ), 
    165                                         deskHeight / ( height + 2 ) 
    166                         ); 
    167  
    168                         if( cellSize < 2 ) { 
    169                                 throw new IllegalStateException( "Too small canvas" ); 
    170                         } 
    171  
    172                         final int _deskWidth = cellSize * ( width + 2 ); 
    173                         final int _deskHeight = cellSize * ( height + 2 ); 
    174  
    175                         vMargin = ( canvasHeight - _deskHeight ) / 2 + cellSize; 
    176                         hMargin = ( canvasWidth - _deskWidth ) / 2 + cellSize; 
    177  
    178                         //draw labels 
    179                         { 
    180                                 g.setColor( LABELS_COLOR ); 
    181                                 final int x1 = toScreenX( -1 ); 
    182                                 final int x2 = toScreenX( width + 1 ); 
    183                                 for( int i = 0; i < height; i++ ) { 
    184                                         final int y = toScreenY( i ); 
    185  
    186                                         final int baseline = y + cellSize * 3 / 4; 
    187                                         g.drawChar( 
    188                                                         ROWS[i], 
    189                                                         x1 + cellSize / 2, 
    190                                                         baseline, 
    191                                                         Graphics.HCENTER | Graphics.BASELINE 
    192                                         ); 
    193                                         g.drawChar( 
    194                                                         ROWS[i], 
    195                                                         x2 + cellSize / 2, 
    196                                                         baseline, 
    197                                                         Graphics.HCENTER | Graphics.BASELINE 
    198                                         ); 
    199                                 } 
    200                                 final int y1 = toScreenY( -1 ); 
    201                                 final int y2 = toScreenY( height + 1); 
    202                                 for( int i = 0; i < width; i++ ) { 
    203                                         final int x = toScreenX( i ); 
    204  
    205                                         final int baseline1 = y1 + cellSize * 3 / 4; 
    206                                         final int baseline2 = y2 + cellSize * 3 / 4; 
    207                                         g.drawChar( 
    208                                                         COLUMNS[i], 
    209                                                         x + cellSize / 2, 
    210                                                         baseline1, 
    211                                                         Graphics.HCENTER | Graphics.BASELINE 
    212                                         ); 
    213                                         g.drawChar( 
    214                                                         COLUMNS[i], 
    215                                                         x + cellSize / 2, 
    216                                                         baseline2, 
    217                                                         Graphics.HCENTER | Graphics.BASELINE 
    218                                         ); 
    219                                 } 
    220                         } 
    221  
    222                         //draw desk and units 
    223                         for( int _y = 0; _y < height; _y++ ) { 
    224                                 for( int _x = 0; _x < width; _x++ ) { 
    225                                         final int x = toScreenX( _x ); 
    226                                         final int y = toScreenY( _y ); 
    227  
    228                                         final int index = game.toIndex( _x, _y ); 
    229                                         //A1 -- ÷åðíîå 
    230                                         final boolean black = ( _x % 2 == 0 ) ^ ( _y % 2 != 0 ); 
    231                                         final boolean highlight = highlightedCells.is( index ); 
    232                                         final boolean attack = attackedCells.is( index ); 
    233                                         if( black ) { 
    234                                                 if( attack ) { 
    235                                                         g.setColor( 150, 100, 100 ); 
    236                                                 } else if( highlight ) { 
    237                                                         g.setColor( 100, 150, 100 ); 
    238                                                 } else { 
    239                                                         g.setColor( 100, 100, 100 ); 
    240                                                 } 
    241                                         } else { 
    242                                                 if( attack ) { 
    243                                                         g.setColor( 250, 200, 200 ); 
    244                                                 } else if( highlight ) { 
    245                                                         g.setColor( 200, 250, 200 ); 
    246                                                 } else { 
    247                                                         g.setColor( 200, 200, 200 ); 
    248                                                 } 
    249                                         } 
    250  
    251                                         g.fillRect( x, y, cellSize, cellSize ); 
    252  
    253                                         final IUnit unit = game.getUnit( _x, _y ); 
    254                                         if( unit != null ) { 
    255                                                 unit.paint( g, x, y, cellSize, cellSize ); 
    256                                         } 
    257                                 } 
    258                         } 
    259                         if( focusedCell != null ) { 
    260                                 g.setColor( 0, 150, 0 ); 
    261                                 final int x = toScreenX( focusedCell.x ); 
    262                                 final int y = toScreenY( focusedCell.y ); 
    263                                 g.drawRect( x + 1, y + 1, cellSize - 2, cellSize - 2 ); 
    264                                 g.drawRect( x, y, cellSize, cellSize ); 
    265                         } 
    266                         if( selectedCell != null ) { 
    267                                 g.setColor( 0, 250, 0 ); 
    268                                 final int x = toScreenX( selectedCell.x ); 
    269                                 final int y = toScreenY( selectedCell.y ); 
    270                                 g.drawRect( x + 1, y + 1, cellSize - 2, cellSize - 2 ); 
    271                                 g.drawRect( x, y, cellSize, cellSize ); 
    272                         } 
    273  
    274                         g.setColor( 0 ); 
    275                         g.drawRect( 
    276                                         hMargin - cellSize, 
    277                                         vMargin - cellSize, 
    278                                         _deskWidth, 
    279                                         _deskHeight 
    280                         ); 
    281                         g.drawRect( 
    282                                         hMargin, 
    283                                         vMargin, 
    284                                         _deskWidth - cellSize * 2, 
    285                                         _deskHeight - cellSize * 2 
    286                         ); 
    287                 } 
    288         } 
    289  
    290         private int toScreenX( final int x ) { 
    291                 return x * cellSize + hMargin; 
    292         } 
    293  
    294         private int toScreenY( final int y ) { 
    295                 return ( game.getHeight() - 1 - y ) * cellSize + hMargin; 
    296         } 
    297  
    298         private void repaintCell( final int x, 
    299                                   final int y ) { 
    300                 final int _x = x * cellSize + hMargin; 
    301                 final int _y = y * cellSize + vMargin; 
    302                 repaint( 
    303                                 _x - 1, _y - 1, 
    304                                 cellSize + 2, cellSize + 2 
    305                 ); 
    306                 //System.out.println( "queried repaint:[" + x + "," + y + "]" ); 
    307                 //repaint(); 
    308         } 
    309  
    310         protected void keyPressed( final int keyCode ) { 
    311                 super.keyPressed( keyCode ); 
    312                 if( listener != null ) { 
    313                         listener.keyPressed( keyCode ); 
    314                 } 
    315         } 
    316  
    317         public void commandAction( final Command command, 
    318                                    final Displayable displayable ) { 
    319                 if( command == midlet.helpCommand ) { 
    320                         midlet.showHelp(); 
    321                 } else if( command == midlet.closeCommand ) { 
    322                         midlet.showStartScreen(); 
    323                 } else if( listener != null ) { 
    324                         listener.commandAction( command, displayable ); 
    325                 } 
    326         } 
    327  
    328         public void changed() { 
    329                 if( isShown() ) { 
    330                         repaint(); 
    331                 } 
    332         } 
    333  
    334         private final Screen waitScreen = new WaitScreen( MSG.getMessage( "wait-for-opponent.title" ) ); 
    335  
    336         public void setStatus( final int status ) { 
    337                 this.status = status; 
    338                 //todo move it to ChessMIDlet? 
    339                 if( status != ACTIVE ) { 
    340                         midlet.display.setCurrent( waitScreen ); 
    341                 } else { 
    342                         midlet.display.setCurrent( this ); 
    343                 } 
    344         } 
    345  
    346         public int getStatus() { 
    347                 return status; 
    348         } 
    349  
    350         //public void repaint(){ 
    351         //    this.repaint(); 
    352         //} 
     17    public static final int ACTIVE = 0; 
     18    public static final int WAITING_FOR_NETWORK = 1; 
     19    public static final int WAITING_FOR_OPPONENT = 2; 
     20    public static final int DISCONNECTED = 3; 
     21 
     22    private static final char[] COLUMNS = new char[]{ 
     23            'A', 'B', 'C', 'D', 'E', 'F', 'J', 'H' 
     24    }; 
     25    private static final char[] ROWS = new char[]{ 
     26            '1', '2', '3', '4', '5', '6', '7', '8' 
     27    }; 
     28 
     29    protected final ChessMIDlet midlet; 
     30 
     31    public final int fireKey; 
     32    public final int leftKey; 
     33    public final int rightKey; 
     34    public final int upKey; 
     35    public final int downKey; 
     36 
     37    protected Player player; 
     38    protected IGame game; 
     39 
     40    private int status = ACTIVE; 
     41 
     42    private Location focusedCell; 
     43    private Location selectedCell; 
     44 
     45    //bitwise masks -- 1 bit per cell 
     46    private final BitSet64 highlightedCells = new BitSet64(); 
     47    private final BitSet64 attackedCells = new BitSet64(); 
     48 
     49    private IUIListener listener = null; 
     50    private transient int vMargin; 
     51    private transient int hMargin; 
     52    private transient int cellSize; 
     53 
     54 
     55    private static final int MARGIN = 2; 
     56    //colors 
     57    private static final int BG_COLOR = 0xFFFFFF; 
     58    private static final int LABELS_COLOR = 0; 
     59 
     60    private final Screen waitScreen; 
     61 
     62    public GameCanvas( final ChessMIDlet midlet ) { 
     63        this.midlet = midlet; 
     64        fireKey = getKeyCode( FIRE ); 
     65        leftKey = getKeyCode( LEFT ); 
     66        rightKey = getKeyCode( RIGHT ); 
     67        upKey = getKeyCode( UP ); 
     68        downKey = getKeyCode( DOWN ); 
     69 
     70        waitScreen = new WaitScreen( 
     71                midlet, 
     72                MSG.getMessage( "wait-for-opponent.title" ), 
     73                this 
     74        ); 
     75 
     76        addCommand( midlet.closeCommand ); 
     77        addCommand( midlet.helpCommand ); 
     78        setCommandListener( this ); 
     79    } 
     80 
     81    public void init( final IGame game ) { 
     82        this.game = game; 
     83        game.setListener( this ); 
     84    } 
     85 
     86    public void setUIListener( final IUIListener listener ) { 
     87        this.listener = listener; 
     88    } 
     89 
     90    public Location getFocusedCell() { 
     91        return focusedCell; 
     92    } 
     93 
     94    public void setFocusedCell( final Location l ) { 
     95        if ( focusedCell == null && l == null ) { 
     96            //nothing 
     97        } else if ( focusedCell == null ) { 
     98            focusedCell = l; 
     99            repaintCell( l.x, l.y ); 
     100        } else if ( l == null ) { 
     101            repaintCell( focusedCell.x, focusedCell.y ); 
     102            focusedCell = l; 
     103        } else { 
     104            final Location old = focusedCell; 
     105            focusedCell = l; 
     106            repaintCell( old.x, old.y ); 
     107            repaintCell( l.x, l.y ); 
     108        } 
     109    } 
     110 
     111    public Location getSelectedCell() { 
     112        return selectedCell; 
     113    } 
     114 
     115    public void setSelectedCell( final Location l ) { 
     116        if ( selectedCell == null && l == null ) { 
     117            //nothing 
     118        } else if ( selectedCell == null ) { 
     119            selectedCell = l; 
     120            repaintCell( l.x, l.y ); 
     121        } else if ( l == null ) { 
     122            repaintCell( selectedCell.x, selectedCell.y ); 
     123            selectedCell = l; 
     124        } else { 
     125            final Location old = selectedCell; 
     126            selectedCell = l; 
     127            repaintCell( old.x, old.y ); 
     128            repaintCell( l.x, l.y ); 
     129        } 
     130    } 
     131 
     132    public void addHighlightedCell( final Location l, 
     133                                    final boolean attack ) { 
     134        addHighlightedCell( l.x, l.y, attack ); 
     135    } 
     136 
     137    public void addHighlightedCell( final int x, 
     138                                    final int y, 
     139                                    final boolean attack ) { 
     140        final byte index = game.toIndex( x, y ); 
     141        if ( attack ) { 
     142            attackedCells.set( index ); 
     143        } else { 
     144            highlightedCells.set( index ); 
     145        } 
     146        repaintCell( x, y ); 
     147    } 
     148 
     149    public void clearHighlightedCells() { 
     150        highlightedCells.clear(); 
     151        attackedCells.clear(); 
     152        repaint(); 
     153    } 
     154 
     155    protected void paint( final Graphics g ) { 
     156        final int canvasWidth = getWidth(); 
     157        final int canvasHeight = getHeight(); 
     158        //clear 
     159        g.setColor( BG_COLOR ); 
     160        g.fillRect( 0, 0, canvasWidth, canvasHeight ); 
     161 
     162        //paint desk 
     163        if ( game != null ) { 
     164            final int width = game.getWidth(); 
     165            final int height = game.getHeight(); 
     166 
     167            final int deskWidth = canvasWidth - MARGIN; 
     168            final int deskHeight = canvasHeight - MARGIN; 
     169 
     170            //ðåçåðâèðóåì ñòîëáöû/ñòðîêè äëÿ ïîîäïèñåé 
     171            cellSize = Math.min( 
     172                    deskWidth / ( width + 2 ), 
     173                    deskHeight / ( height + 2 ) 
     174            ); 
     175 
     176            if ( cellSize < 2 ) { 
     177                throw new IllegalStateException( "Too small canvas" ); 
     178            } 
     179 
     180            final int _deskWidth = cellSize * ( width + 2 ); 
     181            final int _deskHeight = cellSize * ( height + 2 ); 
     182 
     183            vMargin = ( canvasHeight - _deskHeight ) / 2 + cellSize; 
     184            hMargin = ( canvasWidth - _deskWidth ) / 2 + cellSize; 
     185 
     186            //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            } 
     229 
     230            //draw desk and units 
     231            for ( int _y = 0; _y < height; _y++ ) { 
     232                for ( int _x = 0; _x < width; _x++ ) { 
     233                    final int x = toScreenX( _x ); 
     234                    final int y = toScreenY( _y ); 
     235 
     236                    final int index = game.toIndex( _x, _y ); 
     237                    //A1 -- ÷åðíîå 
     238                    final boolean black = ( _x % 2 == 0 ) ^ ( _y % 2 != 0 ); 
     239                    final boolean highlight = highlightedCells.is( index ); 
     240                    final boolean attack = attackedCells.is( index ); 
     241                    if ( black ) { 
     242                        if ( attack ) { 
     243                            g.setColor( 150, 100, 100 ); 
     244                        } else if ( highlight ) { 
     245                            g.setColor( 100, 150, 100 ); 
     246                        } else { 
     247                            g.setColor( 100, 100, 100 ); 
     248                        } 
     249                    } else { 
     250                        if ( attack ) { 
     251                            g.setColor( 250, 200, 200 ); 
     252                        } else if ( highlight ) { 
     253                            g.setColor( 200, 250, 200 ); 
     254                        } else { 
     255                            g.setColor( 200, 200, 200 ); 
     256                        } 
     257                    } 
     258 
     259                    g.fillRect( x, y, cellSize, cellSize ); 
     260 
     261                    final IUnit unit = game.getUnit( _x, _y ); 
     262                    if ( unit != null ) { 
     263                        unit.paint( g, x, y, cellSize, cellSize ); 
     264                    } 
     265                } 
     266            } 
     267            if ( focusedCell != null ) { 
     268                g.setColor( 0, 150, 0 ); 
     269                final int x = toScreenX( focusedCell.x ); 
     270                final int y = toScreenY( focusedCell.y ); 
     271                g.drawRect( x + 1, y + 1, cellSize - 2, cellSize - 2 ); 
     272                g.drawRect( x, y, cellSize, cellSize ); 
     273            } 
     274            if ( selectedCell != null ) { 
     275                g.setColor( 0, 250, 0 ); 
     276                final int x = toScreenX( selectedCell.x ); 
     277                final int y = toScreenY( selectedCell.y ); 
     278                g.drawRect( x + 1, y + 1, cellSize - 2, cellSize - 2 ); 
     279                g.drawRect( x, y, cellSize, cellSize ); 
     280            } 
     281 
     282            g.setColor( 0 ); 
     283            g.drawRect( 
     284                    hMargin - cellSize, 
     285                    vMargin - cellSize, 
     286                    _deskWidth, 
     287                    _deskHeight 
     288            ); 
     289            g.drawRect( 
     290                    hMargin, 
     291                    vMargin, 
     292                    _deskWidth - cellSize * 2, 
     293                    _deskHeight - cellSize * 2 
     294            ); 
     295        } 
     296    } 
     297 
     298    private int toScreenX( final int x ) { 
     299        return x * cellSize + hMargin; 
     300    } 
     301 
     302    private int toScreenY( final int y ) { 
     303        return ( game.getHeight() - 1 - y ) * cellSize + vMargin; 
     304    } 
     305 
     306    private void repaintCell( final int x, 
     307                              final int y ) { 
     308        final int _x = toScreenX( x ); 
     309        final int _y = toScreenY( y ); 
     310        repaint( 
     311                _x - 1, _y - 1, 
     312                cellSize + 2, cellSize + 2 
     313        ); 
     314        //System.out.println( "queried repaint:[" + x + "," + y + "]" ); 
     315        //repaint(); 
     316    } 
     317 
     318    protected void keyPressed( final int keyCode ) { 
     319        super.keyPressed( keyCode ); 
     320        if ( listener != null ) { 
     321            listener.keyPressed( keyCode ); 
     322        } 
     323    } 
     324 
     325    public void commandAction( final Command command, 
     326                               final Displayable displayable ) { 
     327        if ( command == midlet.helpCommand ) { 
     328            midlet.showHelp(); 
     329        } else if ( command == midlet.closeCommand ) { 
     330            midlet.showStartScreen(); 
     331        } else if ( listener != null ) { 
     332            listener.commandAction( command, displayable ); 
     333        } 
     334    } 
     335 
     336    public void changed() { 
     337        if ( isShown() ) { 
     338            repaint(); 
     339        } 
     340    } 
     341 
     342    public void setStatus( final int status ) { 
     343        this.status = status; 
     344        //todo move it to ChessMIDlet? 
     345        if ( status != ACTIVE ) { 
     346            midlet.display.setCurrent( waitScreen ); 
     347        } else { 
     348            midlet.display.setCurrent( this ); 
     349        } 
     350    } 
     351 
     352    public int getStatus() { 
     353        return status; 
     354    } 
     355 
     356    //public void repaint(){ 
     357    //    this.repaint(); 
     358    //} 
    353359} 
  • chess/src/chess/ui/WaitScreen.java

    r7 r10  
    11package chess.ui; 
    22 
    3 import javax.microedition.lcdui.Alert; 
     3import javax.microedition.lcdui.*; 
     4 
     5import chess.remote.IAsyncProcess; 
     6import chess.remote.IAsyncProcessListener; 
    47 
    58 
     
    1013 * Time: 11:13:19<br/> 
    1114 */ 
    12 public class WaitScreen extends Alert { 
     15public class WaitScreen extends Form implements IAsyncProcessListener { 
    1316 
    14     public WaitScreen( final String message ) { 
     17    private final ChessMIDlet midlet; 
     18    private final Displayable nextScreen; 
     19 
     20    public WaitScreen( final ChessMIDlet midlet, 
     21                       final String message, 
     22                       final Displayable nextScreen ) { 
    1523        super( message ); 
    16             setTimeout( Alert.FOREVER ); 
     24        this.midlet = midlet; 
     25        this.nextScreen = nextScreen; 
    1726    } 
    1827 
     28    public void finished( final Object result ) { 
     29        midlet.display.setCurrent( nextScreen ); 
     30    } 
    1931} 
Note: See TracChangeset for help on using the changeset viewer.