Changeset 12 for chess

Timestamp:

02/02/09 17:05:37 (13 years ago)

Author:

BegemoT

Message:

 

Location:

chess/src/chess

Files:

• remote/impl/Remote.java (modified) (1 diff)
• remote/impl/debug/DebugRemote.java (modified) (6 diffs)
• ui/ChessMIDlet.java (modified) (1 diff)

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

@@ -116 +116 @@
 //        return new Remote();
 //        return new DummyRemote();
-        return new DebugRemote();
+        return new DebugRemote( 500, 500 );
     }
 

chess/src/chess/remote/impl/debug/DebugRemote.java

@@ -23 +23 @@
     private static final Timer TIMER = new Timer();
 
-    private static InputStream prepareLog( final Player player ) {
+    private final int networkLatency;
+    private final int userLatency;
+
+    public DebugRemote( final int networkLatency,
+                        final int userLatency ) {
+        this.networkLatency = networkLatency;
+        this.userLatency = userLatency;
+    }
+
+    private InputStream prepareLog( final Player player ) {
         final ByteArrayOutputStream out = new ByteArrayOutputStream();
         try {
             final int yPawnLine = ( player == Player.WHITE ) ? ( 1 ) : ( 6 );
             final int dir = player.getDirection();
-            putAction( player, out, 200, 0, yPawnLine, 0, yPawnLine + 2 * dir );
+            putAction( player, out, 2 * userLatency, 0, yPawnLine, 0, yPawnLine + 2 * dir );
 
-            putAction( player, out, 1200, 3, yPawnLine, 3, yPawnLine + 2 * dir );
+            putAction( player, out, 12 * userLatency, 3, yPawnLine, 3, yPawnLine + 2 * dir );
 
-            putAction( player, out, 1060, 4, yPawnLine, 4, yPawnLine + dir );
+            putAction( player, out, 10 * userLatency, 4, yPawnLine, 4, yPawnLine + dir );
 
-            putAction( player, out, 2000, 4, yPawnLine + dir, 4, yPawnLine + 2 * dir );
+            putAction( player, out, 20 * userLatency, 4, yPawnLine + dir, 4, yPawnLine + 2 * dir );
         } catch ( IOException e ) {
             e.printStackTrace();
@@ -82 +91 @@
     }
 
-    private static class AsyncProcess extends BaseAsyncProcess {
+    private class AsyncProcess extends BaseAsyncProcess {
         public AsyncProcess( final IServerListener listener ) {
             super( listener );
@@ -93 +102 @@
                     try {
                         synchronized ( this ) {
-                            wait( 350 );
+                            wait( 4 * networkLatency );
                         }
                     } catch ( InterruptedException e ) {
@@ -110 +119 @@
     }
 
-    private static class RemoteNode implements IRemoteNode {
+    private class RemoteNode implements IRemoteNode {
         private InputStream is;
         private IConnectionListener listener;
@@ -137 +146 @@
                             }
                         },
-                        200
+                        2 * networkLatency
                 );
                 if ( data instanceof SystemAction ) {
@@ -146 +155 @@
                     }
                     if ( sa.type() == SystemAction.YOUR_TURN ) {
-                        TIMER.schedule(
-                                new TimerTask() {
-                                    public void run() {
-                                        Util.log.println( "recv: emulate" );
-                                        try {
-                                            final GenericDatagram gd = new GenericDatagram( RemoteNode.this.is );
-                                            Util.log.println( "recv: " + gd.wrapped );
-                                            listener.received( gd.wrapped );
+                        try {
+                            final GenericDatagram aPacket = new GenericDatagram( RemoteNode.this.is );
+                            final GenericDatagram saPacket = new GenericDatagram( RemoteNode.this.is );
+                            Thread.sleep( 5 * networkLatency );
+                            TIMER.schedule(
+                                    new TimerTask() {
+                                        public void run() {
+                                            Util.log.println( "recv: emulate" );
 
-                                            Thread.sleep( 100 );
-                                            final GenericDatagram gd2 = new GenericDatagram( RemoteNode.this.is );
-                                            Util.log.println( "recv: " + gd2.wrapped );
-                                            listener.received( gd2.wrapped );
-                                        } catch ( Exception e ) {
-                                            e.printStackTrace();
+                                            Util.log.println( "recv: " + aPacket.wrapped );
+                                            listener.received( aPacket.wrapped );
+                                            
+                                            Util.log.println( "recv: " + saPacket.wrapped );
+                                            listener.received( saPacket.wrapped );
                                         }
-                                    }
-                                },
-                                500
-                        );
+                                    },
+                                    ( ( Action )aPacket.wrapped ).duration()
+                            );
+                        } catch ( Exception e ) {
+                            e.printStackTrace();
+                        }
+
                     }
                 }

chess/src/chess/ui/ChessMIDlet.java

@@ -109 +109 @@
         remote.waitForIncoming(
                 new IServerListener() {
+                    private boolean retValue = false;
+
                     public synchronized boolean incoming( final IRemoteNode client ) {
-                        try {
-                            client.ensureConnected();
-                            app = new App(
-                                    ChessMIDlet.this,
-                                    new Game(),
-                                    gameCanvas,
-                                    client,
-                                    player
-                            );
-                            display.setCurrent( gameCanvas );
-                            Util.log.println( "joined client" );
-                            return true;
-                        } catch ( IOException e ) {
-                            e.printStackTrace();
-                            return false;
+                        final Alert dlg = new Alert( "Connect?", client.getName(), null, AlertType.CONFIRMATION );
+                        dlg.setTimeout( Alert.FOREVER );
+                        dlg.addCommand( okCommand );
+                        dlg.addCommand( Alert.DISMISS_COMMAND );
+                        dlg.setCommandListener(
+                                new CommandListener() {
+                                    public void commandAction( final Command command,
+                                                               final Displayable displayable ) {
+                                        try {
+                                            if ( command == okCommand ) {
+                                                Util.log.println( command );
+                                                try {
+                                                    client.ensureConnected();
+                                                    app = new App(
+                                                            ChessMIDlet.this,
+                                                            new Game(),
+                                                            gameCanvas,
+                                                            client,
+                                                            player
+                                                    );
+                                                    display.setCurrent( gameCanvas );
+                                                    Util.log.println( "joined client" );
+                                                    retValue = true;
+                                                    //return true;
+                                                } catch ( IOException e ) {
+                                                    e.printStackTrace();
+                                                    retValue = false;
+                                                    //return false;
+                                                }
+                                            } else {
+                                                retValue = false;
+                                            }
+                                        } finally {
+                                            synchronized ( ChessMIDlet.this ) {
+                                                ChessMIDlet.this.notifyAll();
+                                            }
+                                        }
+                                    }
+                                }
+                        );
+                        display.setCurrent( dlg );
+                        synchronized ( ChessMIDlet.this ) {
+                            try {
+                                ChessMIDlet.this.wait();
+                            } catch ( InterruptedException e ) {
+                                e.printStackTrace();
+                            }
                         }
+                        return retValue;
                     }