Changeset 12 for chess


Ignore:
Timestamp:
02/02/09 17:05:37 (13 years ago)
Author:
BegemoT
Message:
 
Location:
chess/src/chess
Files:
3 edited

Legend:

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

    r11 r12  
    116116//        return new Remote(); 
    117117//        return new DummyRemote(); 
    118         return new DebugRemote(); 
     118        return new DebugRemote( 500, 500 ); 
    119119    } 
    120120 
  • chess/src/chess/remote/impl/debug/DebugRemote.java

    r11 r12  
    2323    private static final Timer TIMER = new Timer(); 
    2424 
    25     private static InputStream prepareLog( final Player player ) { 
     25    private final int networkLatency; 
     26    private final int userLatency; 
     27 
     28    public DebugRemote( final int networkLatency, 
     29                        final int userLatency ) { 
     30        this.networkLatency = networkLatency; 
     31        this.userLatency = userLatency; 
     32    } 
     33 
     34    private InputStream prepareLog( final Player player ) { 
    2635        final ByteArrayOutputStream out = new ByteArrayOutputStream(); 
    2736        try { 
    2837            final int yPawnLine = ( player == Player.WHITE ) ? ( 1 ) : ( 6 ); 
    2938            final int dir = player.getDirection(); 
    30             putAction( player, out, 200, 0, yPawnLine, 0, yPawnLine + 2 * dir ); 
     39            putAction( player, out, 2 * userLatency, 0, yPawnLine, 0, yPawnLine + 2 * dir ); 
    3140 
    32             putAction( player, out, 1200, 3, yPawnLine, 3, yPawnLine + 2 * dir ); 
     41            putAction( player, out, 12 * userLatency, 3, yPawnLine, 3, yPawnLine + 2 * dir ); 
    3342 
    34             putAction( player, out, 1060, 4, yPawnLine, 4, yPawnLine + dir ); 
     43            putAction( player, out, 10 * userLatency, 4, yPawnLine, 4, yPawnLine + dir ); 
    3544 
    36             putAction( player, out, 2000, 4, yPawnLine + dir, 4, yPawnLine + 2 * dir ); 
     45            putAction( player, out, 20 * userLatency, 4, yPawnLine + dir, 4, yPawnLine + 2 * dir ); 
    3746        } catch ( IOException e ) { 
    3847            e.printStackTrace(); 
     
    8291    } 
    8392 
    84     private static class AsyncProcess extends BaseAsyncProcess { 
     93    private class AsyncProcess extends BaseAsyncProcess { 
    8594        public AsyncProcess( final IServerListener listener ) { 
    8695            super( listener ); 
     
    93102                    try { 
    94103                        synchronized ( this ) { 
    95                             wait( 350 ); 
     104                            wait( 4 * networkLatency ); 
    96105                        } 
    97106                    } catch ( InterruptedException e ) { 
     
    110119    } 
    111120 
    112     private static class RemoteNode implements IRemoteNode { 
     121    private class RemoteNode implements IRemoteNode { 
    113122        private InputStream is; 
    114123        private IConnectionListener listener; 
     
    137146                            } 
    138147                        }, 
    139                         200 
     148                        2 * networkLatency 
    140149                ); 
    141150                if ( data instanceof SystemAction ) { 
     
    146155                    } 
    147156                    if ( sa.type() == SystemAction.YOUR_TURN ) { 
    148                         TIMER.schedule( 
    149                                 new TimerTask() { 
    150                                     public void run() { 
    151                                         Util.log.println( "recv: emulate" ); 
    152                                         try { 
    153                                             final GenericDatagram gd = new GenericDatagram( RemoteNode.this.is ); 
    154                                             Util.log.println( "recv: " + gd.wrapped ); 
    155                                             listener.received( gd.wrapped ); 
     157                        try { 
     158                            final GenericDatagram aPacket = new GenericDatagram( RemoteNode.this.is ); 
     159                            final GenericDatagram saPacket = new GenericDatagram( RemoteNode.this.is ); 
     160                            Thread.sleep( 5 * networkLatency ); 
     161                            TIMER.schedule( 
     162                                    new TimerTask() { 
     163                                        public void run() { 
     164                                            Util.log.println( "recv: emulate" ); 
    156165 
    157                                             Thread.sleep( 100 ); 
    158                                             final GenericDatagram gd2 = new GenericDatagram( RemoteNode.this.is ); 
    159                                             Util.log.println( "recv: " + gd2.wrapped ); 
    160                                             listener.received( gd2.wrapped ); 
    161                                         } catch ( Exception e ) { 
    162                                             e.printStackTrace(); 
     166                                            Util.log.println( "recv: " + aPacket.wrapped ); 
     167                                            listener.received( aPacket.wrapped ); 
     168                                             
     169                                            Util.log.println( "recv: " + saPacket.wrapped ); 
     170                                            listener.received( saPacket.wrapped ); 
    163171                                        } 
    164                                     } 
    165                                 }, 
    166                                 500 
    167                         ); 
     172                                    }, 
     173                                    ( ( Action )aPacket.wrapped ).duration() 
     174                            ); 
     175                        } catch ( Exception e ) { 
     176                            e.printStackTrace(); 
     177                        } 
     178 
    168179                    } 
    169180                } 
  • chess/src/chess/ui/ChessMIDlet.java

    r10 r12  
    109109        remote.waitForIncoming( 
    110110                new IServerListener() { 
     111                    private boolean retValue = false; 
     112 
    111113                    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; 
     114                        final Alert dlg = new Alert( "Connect?", client.getName(), null, AlertType.CONFIRMATION ); 
     115                        dlg.setTimeout( Alert.FOREVER ); 
     116                        dlg.addCommand( okCommand ); 
     117                        dlg.addCommand( Alert.DISMISS_COMMAND ); 
     118                        dlg.setCommandListener( 
     119                                new CommandListener() { 
     120                                    public void commandAction( final Command command, 
     121                                                               final Displayable displayable ) { 
     122                                        try { 
     123                                            if ( command == okCommand ) { 
     124                                                Util.log.println( command ); 
     125                                                try { 
     126                                                    client.ensureConnected(); 
     127                                                    app = new App( 
     128                                                            ChessMIDlet.this, 
     129                                                            new Game(), 
     130                                                            gameCanvas, 
     131                                                            client, 
     132                                                            player 
     133                                                    ); 
     134                                                    display.setCurrent( gameCanvas ); 
     135                                                    Util.log.println( "joined client" ); 
     136                                                    retValue = true; 
     137                                                    //return true; 
     138                                                } catch ( IOException e ) { 
     139                                                    e.printStackTrace(); 
     140                                                    retValue = false; 
     141                                                    //return false; 
     142                                                } 
     143                                            } else { 
     144                                                retValue = false; 
     145                                            } 
     146                                        } finally { 
     147                                            synchronized ( ChessMIDlet.this ) { 
     148                                                ChessMIDlet.this.notifyAll(); 
     149                                            } 
     150                                        } 
     151                                    } 
     152                                } 
     153                        ); 
     154                        display.setCurrent( dlg ); 
     155                        synchronized ( ChessMIDlet.this ) { 
     156                            try { 
     157                                ChessMIDlet.this.wait(); 
     158                            } catch ( InterruptedException e ) { 
     159                                e.printStackTrace(); 
     160                            } 
    127161                        } 
     162                        return retValue; 
    128163                    } 
    129164 
Note: See TracChangeset for help on using the changeset viewer.