Since every class that will be send using spidermonkey has to be registered in the serializer at both the server and the client, plus you have to register it to the listeners to receive it, I made a 3 classes (1 to register classes, 1 listener class for the server, and 1 listener class for the client) to do this easily.
All you have to do is this to start the server/client:
[java]
Server server = Network.createServer( "app_name", 100, 9000, 9000 ); // name, version, tcp port, udp port
NetworkMessages.registerAll( server, new ServerListener() );
server.start();
Client client = Network.connectToServer( "app_name", 100, "localhost", 9000, 9000 ); // name, version, tcp port, udp port
NetworkMessages.registerAll( client, new ClientListener() );
client.start();
[/java]
The register class (NetworkMessages) is:
[java]
package shared._network;
import com.jme3.network.AbstractMessage;
import com.jme3.network.Client;
import com.jme3.network.ClientStateListener;
import com.jme3.network.ConnectionListener;
import com.jme3.network.MessageListener;
import com.jme3.network.Server;
import com.jme3.network.serializing.Serializer;
public class NetworkMessages
{
// register classes >>
// edit >>
private static void registerAll()
{
//register( LoginMessage.class );
//register( LoginResultMessage.class );
//register( NewCharacterMessage.class );
//register( RemoveCharacterMessage.class );
//register( MoveCharacterMessage.class );
//register( ChangeCharacterMovementKeysMessage.class );
//register( HelloMessage.class );
}
// edit <<
// dont edit >>
private static Server registerServer;
private static Client registerClient;
private static MessageListener registerListener;
private static void registerAll( Server server, Client client, MessageListener listener )
{
registerServer = server;
registerClient = client;
registerListener = listener;
registerAll();
if( registerServer != null )
if( registerListener instanceof ConnectionListener )
registerServer.addConnectionListener( (ConnectionListener) registerListener );
if( registerClient != null )
if( registerListener instanceof ClientStateListener )
registerClient.addClientStateListener( (ClientStateListener) registerListener );
}
public static void registerAll( Server server, MessageListener listener )
{
registerAll( server, null, listener );
}
public static void registerAll( Client client, MessageListener listener )
{
registerAll( null, client, listener );
}
@SuppressWarnings( "unchecked" )
private static void register( Class<? extends AbstractMessage> registerClass )
{
Serializer.registerClass( registerClass );
if( registerServer != null )
registerServer.addMessageListener( registerListener, registerClass );
if( registerClient != null )
registerClient.addMessageListener( registerListener, registerClass );
}
// dont edit <<
// register classes <<
}
[/java]
The server listener is:
[java]
package server._network;
import com.jme3.network.ConnectionListener;
import com.jme3.network.HostedConnection;
import com.jme3.network.Message;
import com.jme3.network.MessageListener;
import com.jme3.network.Server;
import java.util.logging.Logger;
public class ServerListener implements MessageListener<HostedConnection>, ConnectionListener
{
public void connectionAdded( final Server server, final HostedConnection client )
{
Logger.getLogger( "server" ).info( "Client #"+client.getId()+" connectedn" );
}
public void connectionRemoved( final Server server, final HostedConnection client )
{
Logger.getLogger( "server" ).info( "Client #"+client.getId()+" disconnectedn" );
}
public void messageReceived( final HostedConnection client, final Message message )
{
}
}
[/java]
The client listener is:
[java]
package client._network;
import com.jme3.network.Client;
import com.jme3.network.ClientStateListener;
import com.jme3.network.Message;
import com.jme3.network.MessageListener;
public class ClientListener implements MessageListener<Client>, ClientStateListener
{
public void clientConnected( final Client client )
{
}
public void clientDisconnected( final Client client, final DisconnectInfo info )
{
if( info != null ) // closed by server
{
System.out.println( "Disconnected: "+info.reason );
System.exit( 1 );
}
}
public void messageReceived( final Client client, final Message message )
{
}
}
[/java]
Advantages:
- easy to setup
- easy to update (when new message classes are added)
Disadvantages:
- to split receiver code you now have to put instanceof checks in the receive method (instead of registering the message classes to another receiver)
- registering of the message classes isn’t thread save
Lemme hear what you think of it.
PS: you may change the name of NetworkMessages to something like NetworkMessagesRegisterer, but I’m planning to do more with it than just registering message classes.