Java 类com.esotericsoftware.kryonet.Server 实例源码

public PlayState(Server server, StateManager states)
{
    this.server = server;
    this.states = states;
    rewardForFisnishedQuestObserver = new RewardForFinishedQuestObserver(this, this);
    questEventsHandler = new EventsHandler(rewardForFisnishedQuestObserver);
    camera.setToOrtho(false);
    camera.viewportWidth = 3000;
    camera.viewportHeight = 1600;

    collisionMap.setScale(1);
    TiledMap map = loadMap();

    if (ServerSettings.isHeadless)
        mapRenderer = new NullOrthogonalTiledMapRenderer();
    else
        mapRenderer = new OrthogonalTiledMapRenderer(map, Assets.getBatch());

    Gdx.input.setInputProcessor(inputHandler);

    addNpcs();
    addGameObject(ObjectsIdentifiers.QUEST_BOARD, 100, 100);
}

@Override
public void handle(Connection connection, ChatMessagePacket packet)
{
    Field connectionsField = FieldUtils.getField(Server.class, "connections", true);

    Connection[] connections;
    try
    {
        connections = (Connection[])FieldUtils.readField(connectionsField, server, true);
    } catch (IllegalAccessException e)
    {
        throw new RuntimeException(e);
    }
    ChatMessageReplyPacket newPacket = new ChatMessageReplyPacket();
    Character sender = gameData.getUserCharacterByConnectionId(connection.getID());
    String nickname = sender.getNickname();
    newPacket.setMessage(packet.getMessage());
    newPacket.setNickname(nickname);
    Character character;
    for(Connection client : connections)        
        if((character = gameData.getUserCharacterByConnectionId(client.getID())) != null)
        {
            newPacket.setSourceCharacterId(character.getId());
            server.sendToTCP(client.getID(), newPacket);
        }
}

public PeaceNetworkServer(int port) {
    server = new Server();

    // Maps MAC addresses (as client IDs) to Connections
    clients = new ArrayList<Connection>();
    clients.add(null); // 0th index is reserved

    events = (Queue<PacketMessage>) new LinkedList<PacketMessage>();

    // Listen on a particular port
    this.port = port;
    try {
        server.bind(this.port);
    } catch (IOException e) {
        e.printStackTrace();
    }

    // Register a packet class. We can only send registered classes.
    server.getKryo().register(PacketMessage.class);
    server.getKryo().register(EventType.class);
    server.getKryo().register(LocationID.class);

    server.start();

    server.addListener(this);
}

public ServerConnection(ServerMaster master, int tcpPort, int udpPort) throws IOException {
    this.master = master;
    this.server = new Server();
    this.queue = new LinkedBlockingQueue<>();
    this.connectedClients = new ObjectMap<>();

    Register.registerAll(server.getKryo());
    server.start();
    server.bind(tcpPort, udpPort);
    server.addListener(new QueuedListener(this) {
        @Override
        protected void queue(Runnable runnable) {
            queue.add(runnable);
        }
    });
}

@Override
public void createServer() {
    try {
        server = new Server();
        server.start();
        server.bind(tcpPort,tcpPort-NetworkPortConfig.UDP_OFFSET);

    } catch (IOException e) {
        e.printStackTrace();
    }   
}

@Override
public void create() {
    try{

        if(true){
            // Run server
            this.server = new Server(22050, 22050);
            server.bind(7777, 7777);
            server.start(); 

            relay = new VoiceChatServer(server.getKryo());

            server.addListener(new Listener(){
                public void received(Connection connection, Object object) {
                    relay.relayVoice(connection, object, server);
                }                   
            });
        }

        this.client = new Client(22050, 22050);
        client.start();
        client.connect(5000, "localhost", 7777, 7777);

        this.sender = new VoiceChatClient(client.getKryo());
        this.sender.addReceiver(client);


    }catch(Exception e){
        e.printStackTrace();
        Gdx.app.exit();
    }   


    // Other stuff for test
    batch = new SpriteBatch();
    font = new BitmapFont();
}

/**
 * Bounces back any audio received to all clients except the one that sent it. By overriding this you can make muting systems, or filter voice chat.
 * Please note that this will only bounce audio back and will not have any effect on other messages. See the return value for more info.
 * @param connection The connection that sent the data.
 * @param message The data that they sent.
 * @param server The server to send audio to clients on.
 * @return True if any data was relayed, false if the data was not audio.
 */
public boolean relayVoice(Connection connection, Object message, Server server){

    if(message instanceof VoiceNetData){

        server.sendToAllExceptUDP(connection.getID(), message);

        return true;
    }else{
        return false;
    }       
}

private Server initializeServer()
{
    server = new Server();
    Kryo serverKryo = server.getKryo();
    serverKryo = PacketsRegisterer.registerPackets(serverKryo);
    return server;
}

public ServerListener(Map<Integer, UserInfo> loggedUsersKeyUserId,
        Map<Integer, User> authenticatedClientsKeyClientId, Server server, PlayState playState)
{
    this.authenticatedClientsKeyClientId = authenticatedClientsKeyClientId;
    packetHandlersFactory = new PacketHandlerFactory(loggedUsersKeyUserId, authenticatedClientsKeyClientId, server,
            playState);
}

public CharacterChangePacketHandler(Map<Integer, UserInfo> loggedUsersKeyUserId,
        Map<Integer, User> authenticatedClientsKeyClientId, PlayState playState, Server server)
{
    this.loggedUsersKeyUserId = loggedUsersKeyUserId;
    this.authenticatedClientsKeyClientId = authenticatedClientsKeyClientId;
    this.playState = playState;
    this.server = server;
}

public AuthenticationPacketHandler(Map<Integer, UserInfo> loggedUsersKeyUserId,
        Map<Integer, User> authenticatedClientsKeyClientId,
        Server server, PlayState playState)
{
    this.loggedUsersKeyUserId = loggedUsersKeyUserId;
    this.authenticatedClientsKeyClientId = authenticatedClientsKeyClientId;
    this.server = server;
    this.playState = playState;
}

public UserCharacterDataPacketHandler(Map<Integer, UserInfo> loggedUsersKeyUserId, Server server,
        PlayState playState)
{
    this.loggedUsersKeyUserId = loggedUsersKeyUserId;
    this.server = server;
    this.playState = playState;
}

public LogoutPacketHandler(Map<Integer, UserInfo> loggedUsersKeyUserId,
        Map<Integer, User> authenticatedClientsKeyClientId, Server server, PlayState playState)
{
    this.loggedUsersKeyUserId = loggedUsersKeyUserId;
    this.authenticatedClientsKeyClientId = authenticatedClientsKeyClientId;
    this.server = server;
    this.playState = playState;
}

public KryonetServer(ServerEnvironment serverEnvironment, int tcpPort, int udpPort) {
    super();

    this.serverEnvironment = serverEnvironment;
    this.tcpPort = tcpPort;
    this.udpPort = udpPort;

    server = new Server(DEFAULT_BUFFER_SIZE, DEFAULT_BUFFER_SIZE);

    kryo = server.getKryo();
    setup(kryo);

    server.addListener(new AddingListener());
}

@Override
public Server get() {
    Server server = new Server() {
        @Override
        protected Connection newConnection() {
            return new NamedConnection();
        }
    };
    ChatUtil.registerClasses(server);
    serverKryoListener.setServer(server);
    server.addListener(serverKryoListener);
    return server;
}

public ChatServer() throws IOException {
    server = new Server();
    users = new HashMap<>();
    registerPackets();
    ServerListener serverListener = new ServerListener(this);
    server.addListener(serverListener);
    server.bind(25566, 25567);
    server.start();
}

public KryonetTransportLayer (RavNetwork net) {
    super(net);
    server = new Server(bufferSize, bufferSize);
    client = new Client(bufferSize, bufferSize);

    serverListener = new ServerListener(this);
    clientListener = new ClientListener(this);

    server.addListener(serverListener);
    client.addListener(clientListener);

    register(server.getKryo());
    register(client.getKryo());
    register(streamKryo);
}

public ServerNetworkController() {
    server = new Server();
    server.start();
    try {
        server.bind(Variables.port);
    }
    catch (IOException e) {
        System.out.println("[Error] Could not bind server. Another server is probably open on the same port. Exiting.");
        System.exit(1);
    }
    server.getKryo().setRegistrationRequired(false);
    ListenerList.addListeners(server);
}

public void setServer(boolean isServer) {
        this.isServer = isServer;
        try {
            if (isServer) {
                server = new Server();
                NetworkRegisterer.register(server);
                serverListener = new LobbyServerListener();
                server.addListener(serverListener);
                server.start();
                server.bind(Constants.DISCOVERY_TCP_PORT,
                            Constants.DISCOVERY_UDP_PORT);
//                Thread.currentThread().sleep(200);
            }

            client = new Client();
            NetworkRegisterer.register(client);
            client.start();
            clientListener = new LobbyClientListener();
            client.addListener(clientListener);
            client.connect(5000, host, 
                    Constants.DISCOVERY_TCP_PORT,
                    Constants.DISCOVERY_UDP_PORT);
        } catch (Exception e) {
            currentButton = backButton;
            markForDispose = true;
            e.printStackTrace();
        }
        addAllButtons();
    }

public void startServer(boolean lonely) {
    isServer = true;
    if (!lonely) {
        server = new Server();
        NetworkRegisterer.register(server);
        server.start();
        try {
            server.bind(Constants.GAME_TCP_PORT,
                    Constants.GAME_UDP_PORT);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

private Server establisServer(int port) throws IOException{
    Server lServer = new Server();
    lServer.addListener(listener);

    Network.registerClasses(lServer.getKryo());

    lServer.start();
    lServer.bind(port);

    return lServer;
}

@Override
public void disconnected(Connection connection) {
    System.out.println(connection + " has disconnected.");
    for (Player p : players) {
        if (connection.equals(p.getConnection())) {
            long id = p.getControlledEntity().getComponent(CId.class).getID();
            p.getControlledEntity().deleteFromWorld();
            Disconnected action = new Disconnected();
            action.setID(id);
            ((Server) AppUtil.endpoint).sendToAllExceptTCP(p.getConnection().getID(), action);
        }
    }
}

@Override
public void runServer() {
    CInventory inv = getPlayer().getControlledEntity().getComponent(CInventory.class);
    Entity item = inv.getItemByID(itemID.getID());
    if (item == null) {
        successful = false;
    }
    if (successful && inv.tryMoveItem(item, xTo, yTo)) {
        Server server = ((Server)AppUtil.endpoint);
        MoveItemSimple action = new MoveItemSimple();
        action.setID(itemID);
        action.setXY(xTo, yTo);
        server.sendToTCP(getPlayer().getConnection().getID(), action);
    }
}

/**
 * Starts the server up 
 * <p><b> Please note </b>  At this state nobody should yet connect
 * @see SOGServer.launch()
 */
public void host() {
    // Attempting to launch server with port 8080
    System.out.println("Launching the server..");
    server = new Server();
    AppUtil.endpoint = server;
    registerClasses(server.getKryo());

    server.addListener(new ServerListener());

    try {
        server.bind(port);
    } catch (IOException e) {
        System.err.println("An Error was detected while attempting to bind port " + port + "!");
        e.printStackTrace();
        return;
    }
    server.start();

    // This makes so the server stops once the server's actual process ends
    Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
        @Override
        public void run() {
            SOGServer.this.stopServer();
        }
    }));
}

/**
 * @see com.comcast.viper.flume2storm.connection.sender.EventSender#start()
 */
public synchronized boolean start() {
  if (getStatus().isOn()) {
    LOG.warn("Already started");
    return true;
  }
  LOG.trace("Starting KryoNet event distributor...");
  setStatus(KryoNetEventSenderStatus.STARTING);
  senderStrategy = new KryoNetSimpleRealtimeStrategy(this, kryoNetParameters.getMaxRetries(),
      connectionParameters.getWriteBufferSize(), connectionParameters.getObjectBufferSize());
  stats.reset();
  try {
    LOG.debug("Creating Kryo server with connection parameters: {}", connectionParameters);
    server = new Server(connectionParameters.getWriteBufferSize(), connectionParameters.getObjectBufferSize());
    KryoUtil.register(server.getKryo());
    server.addListener(clientListener);
    LOG.trace("Binding Kryo server...");
    server.bind(connectionParameters.getPort());
    LOG.debug("Starting Kryo server...");
    server.start();
    LOG.info("Kryo Flume server started successfully with {}", connectionParameters);
    setStatus(KryoNetEventSenderStatus.STARTED);
    return true;
  } catch (final Exception e) {
    LOG.error("Failed to start server with " + connectionParameters, e);
    stop();
    return false;
  }
}

/**
 * Create server marshal handler.
 *
 * @param host bind ip
 * @param port bind port (tcp and udp)
 */
public KryonetServerMarshalStrategy(String host, int port) {
    this.host = host;
    this.port = port;

    endpoint = new Server() {
        @Override
        protected Connection newConnection() {
            return super.newConnection();
        }
    };
}

@Override
protected void connectEndpoint() {
    try {
        ((Server)endpoint).bind(new InetSocketAddress(host, port), new InetSocketAddress(host, port+1));
        state = MarshalState.STARTED;
    } catch (IOException e) {
        e.printStackTrace();
        state = MarshalState.FAILED_TO_START;
    }
}

public NetServer() {
    clientMap = new ObjectMap<>();
    server = new Server(NetManager.writeBufferSize, NetManager.objectBufferSize);
    NetManager.registerKryoClasses(server.getKryo());
    try {
        server.bind(NetManager.tcpPort, NetManager.udpPort);
        server.start();
        server.addListener(createListener(simulateLag));
        Log.debug("server is listening at: " + NetManager.host + ":" + NetManager.tcpPort);
    } catch (IOException e) {
        Log.error(e.toString());
        throw new GdxRuntimeException(e);
    }
}

public Project_Java_School_Server() throws IOException {
    server = new Server();
    registerPackets();
    server.addListener(new NetworkListener());
    server.bind(6789);
    server.start();

    System.out
            .println(" Le serveur est en ligne ! on attend la connection ");

    // on doit le connecter � la bdd ! 

}

public NetworkServer(int ID)
{
    id = ID;

    server = new Server();
    serverListener = new NetworkServerListener(new Listener(), this);
    NetworkManager.registerPackets(server.getKryo());

    server.start();
    server.addListener(serverListener);
}

public void host(int port) {
    this.server = new Server();
    this.registerClasses(this.server.getKryo());

    this.server.addListener(new ServerListener());

    try {
        this.server.bind(port);
    } catch (IOException e) {
        e.printStackTrace();
    }
    this.server.start();
}

public static void init(Server server) {
    initHelper(server.getKryo());
}

public Server getServer() {
    return server;
}

public TDServer() throws IOException {
    sessions = new HashMap<String, Session>();
    server = new Server() {
        //@Override
        //protected Connection newConnection() {
        //    return new TDConnection();
        //}
    };
    Networking.register(server);
    /*server.addListener(new Listener() {
        @Override
        public void received(Connection c, Object o) {
            //TDConnection connection = ((TDConnection) c);

            if(o instanceof RegisterClient) {
                //connection.id = ((RegisterClient)o).id;
                server.sendToTCP(c.getID(), new RegisterServer());
            }

            if(o instanceof CreateShare) {
                String id = getFreeId();
                sessions.put(id, new Session(c));
                c.sendTCP(new ConfirmSession(id));
            }

            if(o instanceof ViewShare ) {
                if(sessions.containsKey(((ViewShare) o).session))
                    sessions.get(((ViewShare) o).session).client = c;
            }

            if(o instanceof EntityPacket) {
                if(sessions.get(((EntityPacket) o).session).client != null)
                    sessions.get(((EntityPacket) o).session).client.sendTCP(o);
            }
        }

        @Override
        public void connected(Connection connection) {

        }

        @Override
        public void disconnected(Connection connection) {

        }

        @Override
        public void idle(Connection connection) {

        }
    });*/
    server.bind(Networking.PORT);
    server.start();
}

public OpenContainerPacketHandler(Server server, PlayState playState)
{
    this.playState = playState;
}

public TakeItemFromContainerPacketHandler(GameDataRetriever gameData, Server server, PlayState playState)
{
    this.gameData = gameData;
    this.server = server;
    this.playState = playState;
}

public ItemUsagePacketHandler(GameDataRetriever gameData, PlayState playState, Server server)
{
    this.gameData = gameData;
    this.playState = playState;
}

public TakingGoldFromContainerPacketHandler(GameDataRetriever gameData, Server server, PlayState playState)
{
    this.gameData = gameData;
    this.server = server;
    this.playState = playState;
}

public CharacterCreationPacketHandler(Map<Integer, User> authenticatedClientsKeyClientId, Server server)
{
    this.authenticatedClientsKeyClientId = authenticatedClientsKeyClientId;
    this.server = server;
}

public ChatMessagePacketHandler(Server server, GameDataRetriever gameData)
{
    this.server = server;
    this.gameData = gameData;
}