Game control is hooked up to the physics object. Next I may hack in

a position feedback without SimEthereal just to show the 'bad' way to
do networking.

Author: pspeed42

sim-eth-basic/src/main/java/example/GameSessionState.java

@@ -127,11 +127,11 @@ protected void onDisable() {
      *  Notified by the server about game-session related events.
      */
     private class GameSessionObserver implements GameSessionListener {
-        public void playerJoined( int clientId, String playerName ){
+        public void playerJoined( int clientId, String playerName, int shipId ){
             getState(MessageState.class).addMessage("> " + playerName + " has joined.", ColorRGBA.Yellow);  
         }
 
-        public void playerLeft( int clientId, String playerName ) {
+        public void playerLeft( int clientId, String playerName, int shipId ) {
             getState(MessageState.class).addMessage("> " + playerName + " has left.", ColorRGBA.Yellow);  
         }
     }

sim-eth-basic/src/main/java/example/net/GameSessionListener.java

@@ -50,11 +50,11 @@ public interface GameSessionListener {
      *  Called when a new player has joined the game.
      */
     @Asynchronous   
-    public void playerJoined( int clientId, String playerName );
+    public void playerJoined( int clientId, String playerName, int shipId );
 
     /**
      *  Called when an existing player has left the game.
      */   
     @Asynchronous   
-    public void playerLeft( int clientId, String playerName );
+    public void playerLeft( int clientId, String playerName, int shipId );
 }

sim-eth-basic/src/main/java/example/net/client/GameSessionClientService.java

@@ -143,18 +143,18 @@ public void start() {
     private class GameSessionCallback implements GameSessionListener {
 
         @Override   
-        public void playerJoined( int clientId, String playerName ) {
+        public void playerJoined( int clientId, String playerName, int shipId ) {
             log.debug("playerJoined(" + clientId + ", " + playerName + ")");
             for( GameSessionListener l : listeners ) {
-                l.playerJoined(clientId, playerName);
+                l.playerJoined(clientId, playerName, shipId);
             }
         }
 
         @Override   
-        public void playerLeft( int clientId, String playerName ) {
+        public void playerLeft( int clientId, String playerName, int shipId  ) {
             log.debug("playerLeft(" + clientId + ", " + playerName + ")");
             for( GameSessionListener l : listeners ) {
-                l.playerLeft(clientId, playerName);
+                l.playerLeft(clientId, playerName, shipId);
             }
         }
     }

sim-eth-basic/src/main/java/example/net/server/GameServer.java

@@ -70,6 +70,8 @@ public class GameServer {
 
     public GameServer( int port, String description ) throws IOException {
         this.description = description;
+
+        this.systems = new GameSystemManager();
 
         // Create the SpiderMonkey server and setup our standard
         // initial hosted services 
@@ -80,14 +82,13 @@ public GameServer( int port, String description ) throws IOException {
         server.getServices().addServices(new RpcHostedService(),
                                          new RmiHostedService(),
                                          new AccountHostedService(description),
-                                         new GameSessionHostedService()
+                                         new GameSessionHostedService(systems)
                                          );
 
-        this.systems = new GameSystemManager();
         this.loop = new GameLoop(systems);
 
         // Add the various game services to the GameSystemManager
-        systems.addSystem(new SimplePhysics());
+        systems.register(SimplePhysics.class, new SimplePhysics());
 
         // Add any hosted services that require those systems to already
         // exist

sim-eth-basic/src/main/java/example/net/server/GameSessionHostedService.java

@@ -54,9 +54,12 @@
 import com.jme3.network.service.rmi.RmiRegistry;
 
 import com.simsilica.event.EventBus;
+import com.simsilica.sim.GameSystemManager;
 
 import example.net.GameSession;
 import example.net.GameSessionListener;
+import example.sim.ShipDriver;
+import example.sim.SimplePhysics;
 
 /**
  *  Provides game session management for connected players.  This is where
@@ -72,12 +75,18 @@ public class GameSessionHostedService extends AbstractHostedConnectionService {
 
     private static final String ATTRIBUTE_SESSION = "game.session";
 
+    private GameSystemManager gameSystems;
+    private SimplePhysics physics;
+
     private RmiHostedService rmiService;
     private AccountObserver accountObserver = new AccountObserver();
 
     private List<GameSessionImpl> players = new CopyOnWriteArrayList<>();
 
-    public GameSessionHostedService() {
+    public GameSessionHostedService( GameSystemManager gameSystems ) {
+    
+        this.gameSystems = gameSystems;
+    
         // We do not autohost because we want to host only when the
         // player is actually logged on.
         setAutoHost(false);
@@ -99,7 +108,18 @@ protected void onInitialize( HostedServiceManager s ) {
         // Register ourselves to listen for global account events
         EventBus.addListener(accountObserver, AccountEvent.playerLoggedOn, AccountEvent.playerLoggedOff);
     }
-    
+
+    @Override
+    public void start() {
+        super.start();
+            
+        // Get the physics system... it's not available yet when onInitialize() is called.
+        physics = gameSystems.get(SimplePhysics.class);
+        if( physics == null ) {
+            throw new RuntimeException("GameSessionHostedService requires a SimplePhysics system.");
+        }
+    }
+ 
     @Override
     public void startHostingOnConnection( HostedConnection conn ) {
 
@@ -171,19 +191,32 @@ private class GameSessionImpl implements GameSession {
 
         private HostedConnection conn;
         private GameSessionListener callback;
+        private int bodyId;
+        private ShipDriver shipDriver;
 
         public GameSessionImpl( HostedConnection conn ) {
             this.conn = conn;
+            
+            // Create a ship for the player
+            this.shipDriver = new ShipDriver(); 
+            this.bodyId = physics.createBody(shipDriver);
+        }
+ 
+        public void close() {
+            // Remove out physics body
+            physics.removeBody(bodyId);
         }
 
         public void playerJoined( GameSessionImpl player ) {            
             getCallback().playerJoined(player.conn.getId(),
-                                       AccountHostedService.getPlayerName(player.conn));
+                                       AccountHostedService.getPlayerName(player.conn),
+                                       player.bodyId);
         } 
 
         public void playerLeft( GameSessionImpl player ) {
             getCallback().playerLeft(player.conn.getId(),
-                                     AccountHostedService.getPlayerName(player.conn));
+                                     AccountHostedService.getPlayerName(player.conn),
+                                     player.bodyId);
         } 
 
         protected GameSessionListener getCallback() {
@@ -204,6 +237,7 @@ public void move( Quaternion rotation, Vector3f thrust ) {
             }
 
             // Need to forward this to the game world
+            shipDriver.applyMovementState(rotation, thrust);
         }
     }    
 }

sim-eth-basic/src/main/java/example/sim/Body.java

@@ -44,7 +44,8 @@
  *  A physical body in space.  These are modeled as a "point mass"
  *  in the sense that their orientation does not integrate, nor does
  *  it affect integration.  ie: there is no rotational acceleration
- *  or velocity.  Rotation is kept because it's convenient.
+ *  or velocity (at least not yet and there won't ever be in the true
+ *  physics sense).  Rotation is kept because it's convenient.
  *
  *  @author    Paul Speed
  */
@@ -54,12 +55,12 @@ public class Body {
 
     public int bodyId = nextBodyId.getAndIncrement();
 
-    public Quatd rotation = new Quatd();
     public Vec3d pos = new Vec3d();
     public Vec3d velocity = new Vec3d();
     public Vec3d acceleration = new Vec3d();
     public double radius = 1;
 
+    public Quatd orientation = new Quatd();
     public volatile ControlDriver driver;
 
     public Body() {
@@ -75,7 +76,8 @@ public void integrate( double stepTime ) {
 
         // Integrate position
         pos.addScaledVectorLocal(velocity, stepTime);
-        
+ 
+//System.out.println(bodyId + " pos:" + pos + "   dir:" + orientation.mult(new Vec3d(0, 0, 1)));        
         // That's it.  That's a physics engine.   
     }
 }

sim-eth-basic/src/main/java/example/sim/ShipDriver.java

@@ -0,0 +1,94 @@
+/*
+ * $Id$
+ * 
+ * Copyright (c) 2016, Simsilica, LLC
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions 
+ * are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form must reproduce the above copyright 
+ *    notice, this list of conditions and the following disclaimer in 
+ *    the documentation and/or other materials provided with the 
+ *    distribution.
+ * 
+ * 3. Neither the name of the copyright holder nor the names of its 
+ *    contributors may be used to endorse or promote products derived 
+ *    from this software without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package example.sim;
+
+import com.jme3.math.*;
+
+import com.simsilica.mathd.*;
+
+/**
+ *  Uses rotation and a 3-axis thrust vector to supply
+ *  specific velocity to a body.  We ignore the normal
+ *  physics acceleration for now and just set the velocity directly
+ *  based on our accelerated thrust values.
+ *
+ *  @author    Paul Speed
+ */
+public class ShipDriver implements ControlDriver {
+ 
+    // Keep track of what the player has provided.
+    private volatile Quaternion orientation = new Quaternion();
+    private volatile Vector3f thrust = new Vector3f();
+ 
+    private double pickup = 3;
+    
+    // The velocity in ship space, not world space    
+    private Vec3d velocity = new Vec3d();
+
+    public void applyMovementState( Quaternion orientation, Vector3f thrust ) {
+        this.orientation = orientation;
+        this.thrust = thrust;
+    } 
+ 
+    private double applyThrust( double v, double thrust, double tpf ) {
+        if( v < thrust ) {
+            v = Math.min(thrust, v + pickup * tpf);
+        } else if( v > thrust ) {
+            v = Math.max(-thrust, v - pickup * tpf);
+        }   
+        return v;
+    }
+    
+    @Override
+    public void update( double stepTime, Body body ) {
+ 
+        // Grab local versions of the player settings in case another
+        // thread sets them while we are calculating.
+        Quaternion quat = orientation;
+        Vector3f vec = thrust;
+        
+        velocity.x = applyThrust(velocity.x, vec.x, stepTime);
+        velocity.y = applyThrust(velocity.y, vec.y, stepTime);
+        velocity.z = applyThrust(velocity.z, vec.z, stepTime);
+ 
+        // Setup the current world rotation of the body 
+        body.orientation.set(quat.getX(), quat.getY(), quat.getZ(), quat.getW());
+        
+        // Apply the accelerated velocity oriented into world space       
+        body.velocity = body.orientation.mult(velocity, body.velocity);                        
+    }
+}

sim-eth-basic/src/main/java/example/sim/SimplePhysics.java

@@ -63,7 +63,12 @@ public SimplePhysics() {
     }
 
     public int createBody() {
+        return createBody(null);        
+    }
+        
+    public int createBody( ControlDriver driver ) {
         Body result = new Body();
+        result.driver = driver;
         toAdd.add(result);
         index.put(result.bodyId, result);
         return result.bodyId;