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; }