private synchronized void onNewConnection(Connection con) { Gdx.app.log("Server", "Client connected"); Player p = PlayerUtils.getRandomPlayer(players.values()); players.put(playersJoinedCount, p); clients.put(playersJoinedCount, new ServerPlayer(p)); connections.put(playersJoinedCount, con); // Inform the other clients server.sendToAllExceptTCP(con.getID(), new PlayerJoinedMessage( playersJoinedCount, players.get(playersJoinedCount))); // Send the setup response con.sendTCP( new GameSetupMessage(players, playersJoinedCount, settings)); playersJoinedCount++; }
private GameResponse getRandomGame(Connection connection, Account account) { Game randomGame = null; // Go through the games if (gamesMap != null) { for (Game game : gamesMap.values()) { // If there's a game currently waiting for more players, that's the one to return if (!game.isInProgress() && game.getPlayerCount() < Config.MAX_PLAYERS) { // Add the player to the game game.addPlayer(account, connection.getID()); gamesMap.put(account.getUsername(), game); randomGame = game; } } } return GameResponse.newInstance(randomGame); }
public LoginScreen(CatanGame pGame) { aGame = pGame; listener = new Listener() { @Override public void received(Connection connection, Object object) { if (object instanceof LoginResponse) { Gdx.app.postRunnable(() -> { // Handle the login response from the server if (((LoginResponse) object).success) { // Cache the account used to login successfully AccountManager.writeLocalAccount(account); CatanGame.account = account; // Move on to the main screen aGame.switchScreen(ScreenKind.MAIN_MENU); } else { errorMessageLabel.setText(ERROR_USERNAME); } }); } } }; }
private void handleCreateMotorMessage(final Connection conn, final CreateMotorMessage msg) { Thread createMotor = new Thread(){ @Override public void run(){ LocalEV3.get().getLED().setPattern(9); if(motorPorts.containsKey(msg.getPort())){ if(createMotorEndpoint( motorPorts.get(msg.getPort()),msg.getMotorType(),msg.getNetworkPort() )){ conn.sendTCP(BrickMessages.createEndpointCreatedMessage(true, msg.getPort(), "Motor endpoint created: "+msg.getPort(), false, true)); }else{ isBlocked = true; System.out.println("System got blocked by handleCreateMotorMethod"); conn.sendTCP(BrickMessages.createEndpointCreatedMessage(false, msg.getPort(), "Motor endpoint not created: "+msg.getPort(), false, true)); } }else{ conn.sendTCP(BrickMessages.createEndpointCreatedMessage(false, msg.getPort(), "Port not found!"+msg.getPort(), false, true)); } } }; creationThreads.add(createMotor); //createMotor.start(); }
@Override public void received(Connection connection, Object object){ /** Message if the Endpoint-creation was successful or not **/ System.out.println("Local-EV3MotorManager: received a message!"); if(object.getClass() == BrickMessages.EndpointCreatedMessage.class){ BrickMessages.EndpointCreatedMessage ecmsg = (BrickMessages.EndpointCreatedMessage)object; System.out.println("Local-EV3MotorManager: Received a EndpointCreatedMessage! -> "+ecmsg.toString()); if(ecmsg.isMotor()){ if(ecmsg.isSuccess()){ System.out.println("Local-EV3MotorManager: isSuccess at port "+ecmsg.getPort()+"#"); if(motors.containsKey(EV3MotorPort.getPort(ecmsg.getPort()))){ System.out.println("Local-EV3MotorManager: Endpoint creation successfull - connect to endpoint!"); endpoints.get(EV3MotorPort.getPort(ecmsg.getPort())).connect(); }else{ System.out.println("Local-EV3MotorManager: Sensor does not exist"); } }else{ //TODO Tell Sensor/Motor Manager that endpoint creation failed } } } }
@Override public void received(Connection connection, Object object) { System.out.println("Local-EV3Display: Received Message "+object.toString()); if(object.getClass() == BrickMessages.EndpointCreatedMessage.class){ BrickMessages.EndpointCreatedMessage msg = (EndpointCreatedMessage) object; if(!msg.isMotor() && !msg.isSensor()){ if(msg.isSuccess() && msg.getMsg().equals("DISPLAY")){ connect(); System.out.println("EV3-Display: connecting to endpoint!"); } } return; } if(object.getClass() == DisplayMessages.HelloDisplay.class){ ready = true; } }
@Override public void show() { super.show(); entities = new HashMap<Integer, EntityPacket.EntityRender>(); game.getClient().sendTCP(new ViewShare("696969")); game.getClient().addListener(new Listener() { @Override public void received(Connection connection, Object o) { if(o instanceof EntityPacket) Gdx.app.log("Entities", "Session" + ((EntityPacket) o).session); } }); }
/** * Makes this chat client process and respond to audio sent from the server. If this message is not called, you will not hear anything * from the server! * @param client The client that audio data will be sent to from the server. Just use the normal client. */ public void addReceiver(Client client){ if(this.player == null) this.createPlayer(); client.addListener(new Listener(){ public void received(Connection connection, Object object) { // Only read objects of the correct type. if(object instanceof VoiceNetData){ // Read data VoiceNetData message = (VoiceNetData)object; short[] data = message.getData(); // Play audio processAudio(data, connection, message); } } }); }
@Override public void handle(Connection connection, RetrieveItemRewardPacket packet) { Character character = gameDataRetreiver.getUserCharacterByConnectionId(connection.getID()); CharactersQuests quest = findSuiteQuest(character.getQuests(), packet.getQuestName()); CharactersQuestsItemReward itemReward = findSuiteItemReward(quest.getItemsReward(), packet.getItemIdentifier()); PlayerCharacter player = (PlayerCharacter) gameContainer.getObject(character.getId()); InventoryPosition inventoryPosition = new InventoryPosition(packet.getDesiredInventoryPage(), packet.getDesiredInventoryX(), packet.getDesiredInventoryY()); Item gameItem; if (itemReward.getNumberOfItems() == packet.getNumberOfItems()) gameItem = GameItemsFactory.produce(itemReward.getItemIdentifier(), itemReward.getNumberOfItems(), IdSupplier.getId(), inventoryPosition); else throw new NotImplementedException("Not implemented yet"); player.addItemAllowStacking(gameItem); connection.sendTCP(PacketsMaker.makeItemRewardRemovePacket(packet.getItemIdentifier(), itemReward.getNumberOfItems())); connection.sendTCP(PacketsMaker.makeItemPacket(gameItem)); }
@Override public void handle(Connection connection, RetrieveGoldRewardPacket packet) { Character character = gameDataRetriever.getUserCharacterByConnectionId(connection.getID()); CharactersQuests quest = findSuiteQuest(character.getQuests(), packet.getQuestName()); int goldReward = quest.getGoldReward(); if (goldReward > 0) { quest.setGoldReward(0); character.setGold(character.getGold() + goldReward); packetsSender.sendTo(connection.getID(), PacketsMaker.makeGoldReceivePacket(goldReward)); packetsSender.sendTo(connection.getID(), PacketsMaker.makeQuestRewardGoldRemovalPacket(goldReward)); } else packetsSender.sendTo(connection.getID(), PacketsMaker.makeUnacceptableOperationPacket("There is no gold left!")); }
private void clientBoardClickProperHandle(Connection connection, GameObject target, PlayerCharacter source) { // TODO: refactor, implement collicion detection on clent side, so he // can tell what he wants to do directly if (target instanceof ShopNpc) sendShopItemsInfo(connection, (ShopNpc) target); else if (target instanceof QuestDialogNpc) propagateQuestDialogEvent((QuestDialogNpc) target, source); else if (target instanceof Monster) tryToTargetMonster(connection, (Monster) target, source); else if (target instanceof QuestBoard) sendQuestBoardInfo(connection, (QuestBoard) target); else if (target.getClass().getSimpleName().contains("NullGameObject")) ;//ignore else throw new NotImplementedException("Not implemented"); }
@Override public void handle(Connection connection, ItemUsagePacket packet) { int characterId = gameData.getCharacterIdByConnectionId(connection.getID()); PlayerCharacter itemUser = (PlayerCharacter)playState.getObject(characterId); if(itemUser == null) throw new PlayerUsingItemNotFoundException(); Monster target = (Monster)playState.getObject(packet.getTargetId()); try { itemUser.useItem(packet.getItemId(), target, (PacketsSender)playState); connection.sendTCP(packet); } catch(OutOfStockException e) { connection.sendTCP(PacketsMaker.makeUnacceptableOperationPacket("Your item stack was depleted")); } }
@Override public void handle(Connection connection, TakingGoldFromContainerPacket packet) { long characterId = gameData.getCharacterIdByConnectionId(connection.getID()); PlayerCharacter player = (PlayerCharacter)playState.getObject(characterId); GameContainer container = playState.getContainer(packet.getContainerId()); int gold = container.getGoldAmount(); if(gold > 0) { connection.sendTCP(PacketsMaker.makeGoldReceivePacket(gold)); server.sendToAllTCP(PacketsMaker.makeContainerGoldRemovalPacket(packet.getContainerId(), gold)); container.setGoldAmount(0); player.addGold(gold); } else connection.sendTCP(PacketsMaker.makeUnacceptableOperationPacket("There is no gold left in this container")); }
@Override public void handle(Connection connection, ScriptCodePacket packet) { User user = authenticatedClientsKeyClientId.get(connection.getID()); if(!user.getRole().equals(UserRole.ADMIN)) { connection.sendTCP(PacketsMaker.makeScriptExecutionErrorPacket("You must be admin to do that")); return; } try { Object result = playState.executeCode(packet.getCode(), user.getId()); if(result != null) connection.sendTCP(PacketsMaker.makeScriptResultInfoPacket(result.toString())); }catch(ScriptException e) { connection.sendTCP(PacketsMaker.makeScriptExecutionErrorPacket(e.getMessage())); } }
@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); } }
private void userChoosenCharcter(int userCharacterId, Connection connection) { Character character = characterRepo.findOneAndFetchEverythingRelated(userCharacterId); UserInfo info = loggedUsersKeyUserId.get(character.getUser().getId()); info.userCharacter = character; int clientId = connection.getID(); sendCurrentGameObjectsInfo(connection); PlayerCharacter newPlayer = new PlayerCharacter(character, playState, clientId); Collection<Item> playerItems = getPlayerItems(newPlayer); playerItems.forEach((item) -> newPlayer.addItemDenyStacking(item)); playState.add(newPlayer); server.sendToAllExceptTCP(clientId, PacketsMaker.makeCreationPacket(newPlayer)); sendItemsDataToClient(playerItems, connection); sendItemQuickAccessBarConfigToClient(character.getItemQuickAccessBarConfig().values(), connection); sendSpellQuickAccessBarConfigToClient(character.getSpellQuickAccessBarConfig().values(), connection); sendQuestInfoToClient(character.getQuests(), connection); sendAvailableSpellsToClient(character.getSpells(), connection); }
@Override public void handle(Connection connection, BuyFromShopPacket packet) { ShopNpc shopNpc = (ShopNpc) playState.getObject(packet.getShopId()); ShopItemWrapper itemWrapper = shopNpc.getItemWrapper(packet.getItemId()); Character userCharacter = gameData.getUserCharacterByConnectionId(connection.getID()); PlayerCharacter character = (PlayerCharacter) playState.getObject(userCharacter.getId()); int itemCount = packet.getAmount(); int singleItemPrice = itemWrapper.getPrice(); int totalPrice = singleItemPrice * itemCount; int characterGold = character.getProperties().gold; if (totalPrice > characterGold) connection.sendTCP(PacketsMaker.makeUnacceptableOperationPacket("You don't have enough gold!")); else { handleGoldPart(connection, totalPrice, character); InventoryPosition position = new InventoryPosition(packet.getDesiredInventoryPage(), packet.getDesiredInventoryX(), packet.getDesiredInventoryY()); handleItemPart(connection, itemWrapper, character, itemCount, position); } }
private void userLoggedOut(Connection connection) { User user = authenticatedClientsKeyClientId.remove(connection.getID()); Character userCharacter = loggedUsersKeyUserId.remove(user.getId()).userCharacter; if (userCharacter != null) { int characterId = userCharacter.getId(); if (playState.has(characterId)) { GameObject removedCharacter = playState.remove(characterId); new CharacterDatabaseSaver().save((PlayerCharacter)removedCharacter); server.sendToAllExceptTCP(connection.getID(), PacketsMaker.makeRemovalPacket(characterId)); } playState.removeGameCommandsHandler(user.getId()); } }
public ClientController(AbstractDiagramController pDiagramController, String pServerIp, int pPort) { diagramController = pDiagramController; serverIp = pServerIp; port = pPort; client = new Client(); initKryo(client.getKryo()); client.addListener(new Listener() { public void received (Connection connection, Object object) { if (object instanceof AbstractNode) { Platform.runLater(() -> diagramController.createNodeView((AbstractNode)object, true)); } else if (object instanceof AbstractEdge) { Platform.runLater(() -> diagramController.addEdgeView((AbstractEdge)object, true)); } else if (object instanceof Graph){ Graph graph = (Graph) object; graph.addRemotePropertyChangeListener(ClientController.this); Platform.runLater(() -> diagramController.load(graph, true)); } else if (object instanceof String[]){ Platform.runLater(() -> diagramController.remoteCommand((String[])object)); } } }); }
@Override public void handle(final Client client, Connection connection, Command command) { model.getClient().ifPresent(c -> { if (c == client) { model.getMessages().add("Server " + model.getServer() + ":" + model.getPort() + " is no longer available."); client.stop(); try { client.dispose(); } catch (IOException ignored) { // OK } model.setClient(null); model.setConnected(false); model.getMessages().clear(); } }); }
@Override public void received(Connection connection, Object o) { if(!(o instanceof Message)){ return; } Message msg = (Message) o; switch (msg.getMessageCode()){ case MessageCodes.CLIENT_NAME: Client client = players.get(players.indexOf(new Client(connection.getID()))); client.setName(((GeneralMessage)msg).getMessage()); ++namesSet; if (serverIsFull && namesSet == MAX_CLIENTS){ GameData.setPlayersReady(true); } break; } }
@Override public void handle(Connection connection, Object object) { if(!(object instanceof Message)){ return; } Message message = (Message) object; switch (message.getMessageCode()){ case MessageCodes.CLIENT_NAME: GeneralMessage msg = (GeneralMessage) message; connection.setName(msg.getMessage()); break; } }
@Override public void handle(Connection connection, Object object) { if(!(object instanceof Message)){ return; } Message message = (Message) object; switch (message.getMessageCode()){ case MessageCodes.SERVER_FULL: //////////////////////////// break; } }
@Override public void connected(Connection connection) { if (getWorld().isGameOver() || (getWorld().getPlayers().size() >= 2 && Parameters.restrictJoin)) { sendEventToPlayer(Event.ON_CONNECTION_REFUSED, -1, connection. getID()); return; } final int playerID = connection.getID(); ((ServerWorld) world).addPlayer(playerID); sendStateToPlayer(playerID); sendTileUpdateToPlayer(playerID); System.out.println("Client connected! ID# " + playerID); }
@Override public void disconnected(Connection connection) { System.out.println("disconnected from server!"); if (error == ErrorCode.NOREASON) { error = ErrorCode.SERVER_DISCONNECTED; Gdx.app.postRunnable(new Runnable() { @Override public void run() { GameScreen screen = new ScreenMainMenu(); CoreBC.changeScreen(screen); } }); } }
@Override public void received(final Connection connection, final Object object) { if (object instanceof Size) { final Size size = (Size) object; final long tod = size.tod; final int msgs = size.messages; final Price price = new Price(); for (int i = 0; i < msgs; i++) { price.tod = tod; price.iid = i; price.bid = 2; price.ask = 3; price.trd = 4; price.vol = 5; while (!connection.isIdle()) { // busy spin waiting for space in buffer } connection.sendTCP(price); } } }
@Override public void sendStreamTo (Object connectionInformation, InputStream stream, int size, String type, Object additionalInformation) { final int streamId = (int)(Math.random() * Integer.MAX_VALUE); Packet.StreamHeader streamHeader = new Packet.StreamHeader(); streamHeader.additionalInfo = additionalInformation; streamHeader.streamId = streamId; streamHeader.type = type; streamHeader.streamLength = size; sendTo(connectionInformation, streamHeader, true); // Send data in 512 byte chunks. ((Connection)connectionInformation).addListener(new InputStreamSender(stream, 1024) { @Override protected Object next (byte[] bytes) { Packet.StreamChunk chunkPacket = new Packet.StreamChunk(); chunkPacket.streamId = streamId; chunkPacket.chunkBytes = bytes; return chunkPacket; } }); }
@Override public void received (Connection connection, final Object object) { if(!(object instanceof Packet)) return; Packet packet = ((Packet)object); if (packet instanceof Packet.LobbyPacket) { if (packet instanceof Packet.SetLobbyData) layer.net.lobby.values.put(((Packet.SetLobbyData)packet).key, ((Packet.SetLobbyData)packet).value); if (packet instanceof Packet.DeleteLobbyData) layer.net.lobby.values.remove(((Packet.DeleteLobbyData)packet).key); return; } if (packet instanceof Packet.LoginAnswer) { layer.net.lobby.playerJoined(connection, "quexten"); layer.net.lobby.ownId = ((Packet.LoginAnswer)packet).id; HookApi.postHooks(layer.net.lobby.onJoinedHooks, layer.net.lobby.getPlayerForConnection(connection)); } if (layer.net.lobby != null) layer.recieve(packet); }
@Override public void received (final Connection connection, Object object) { if(!(object instanceof Packet)) return; Packet packet = ((Packet)object); if (packet instanceof Packet.LoginRequest) if (layer.net.lobby.checkPassword(((Packet.LoginRequest)packet).password)) { Debug.logDebug(LOG_TAG, "Authentification of " + connection.getRemoteAddressTCP() + " successful as: " + ((Packet.LoginRequest)packet).username); trustedConnections.add(connection.getID()); Packet.LoginAnswer answer = new Packet.LoginAnswer(); answer.id = layer.net.lobby.players.size; layer.net.lobby.playerJoined(connection, ((Packet.LoginRequest)packet).username).send(answer, true); HookApi.postHooks(layer.net.lobby.onJoinedHooks, layer.net.lobby.getPlayerForConnection(connection)); } else { Debug.log(LOG_TAG, "Authentification failed for " + connection.getRemoteAddressTCP()); connection.close(); } if (trustedConnections.contains(connection.getID())) layer.recieve(packet); }
private void updateClientDetails(Connection connection, Object object) { int version = ((ClientDetailsMessage)object).protocolVersion; if (version != Constants.PROTOCOL_VERSION) { ServerStatusMessage message = new ServerStatusMessage(); message.status = Status.DISCONNECT; if (version > Constants.PROTOCOL_VERSION) { message.toastText = "Please update server"; } else if (version < Constants.PROTOCOL_VERSION) { message.toastText = "Please update client"; } server.sendToTCP(connection.getID(), message); return; } playerList.get(connection.getID()). setName(((ClientDetailsMessage) object).name); PlayerNamesMessage players = new PlayerNamesMessage(); for (ServerPlayer tempPlayer: playerList.values()) { players.players.put(tempPlayer.id, tempPlayer.getName()); } if (server != null) server.sendToAllTCP(players); addOutgoingEvent(MessageObjectPool.instance.eventPool.obtain(). set(State.RECEIVED, players)); }
private void getInvited(int id) { RequestMessage message = new RequestMessage(RequestMessage.Command.INVITED_USERS_REQUEST, id); CalendarClient client = CalendarClient.getInstance(); Listener getInvitedListener = new Listener() { public void received(Connection connection, Object object) { if (object instanceof ParticipantUserMessage) { ParticipantUserMessage complete = (ParticipantUserMessage) object; switch (complete.getCommand()) { case RECEIVE_ALL: setInvited(complete.getParticipantUsers()); break; case SEND_ALL: break; } client.removeListener(this); } } }; client.addListener(getInvitedListener); client.sendMessage(message); }
/** * forwards a message to apropriate handle method for that message * @param conn a connected client * @param m the Message with an attached object */ private void handleMessageWithObject(Connection conn, MessageWithObject m) { switch (m.message) { case NEW_TEAMNAME: handleNewTeamName(conn, (String) m.object); break; case TRANSFER_SOURCES: receiveSourceFromTeam(conn, m); break; case CHUNKED_TRANSFER: handleNewChunkedTransfer(conn, m); break; case CHUNK: handleChunk(conn, m); break; case TRANSFER_ERROR: handleTransferError(conn, m); break; default: log.info("Received unknown message from" + connectedTeams.get(conn)); } }
@Override public void received(Connection connection, Object object) { if (object instanceof GameStateMessage) { addNewState((GameStateMessage) object); } else if (object instanceof Short) { if(world.get(object) != null ) { world.get(object).destroy = true; //FIXME Set remove in the client entity if (!(world.get(object) instanceof ClientBomb)) world.get(object).remove = true; } } else if (object instanceof AudioMessage) { audioPlayer.playAudioMessage((AudioMessage) object); } else if (object instanceof PlayerNamesMessage) { this.playerNames = (PlayerNamesMessage) object; } else if (object instanceof ServerStatusMessage) { ServerStatusMessage message = (ServerStatusMessage) object; toaster.toast(message.toastText); disconnected = true; } else if (object instanceof String) { toaster.toast((String) object); } super.received(connection, object); }
public boolean connect(NetworkServerConfig config) { try { this.client.connect(5000, config.getAddress(), config.getTcpPort(), config.getUdpPort()); this.client.addListener(new Listener() { public void received(Connection connection, Object object) { if (object instanceof MessageModel) { MessageModel response = (MessageModel) object; masterTask.sendTask(TaskFactory.createTask(EnumTargetTask.MESSAGE_SERVER, EnumTargetTask.GAME, response)); } } }); this.masterTask.sendTask(TaskFactory.createTask(EnumTargetTask.MESSAGE_SERVER, EnumTargetTask.ACCOUNT, EnumWindow.INTERFACE)); return true; } catch (IOException e) { System.err.println("ERROR: " + e.getMessage()); e.printStackTrace(); return false; } }
/** Returns the first object registered with the specified ID in any of the ObjectSpaces the specified connection belongs to. */ static Object getRegisteredObject (Connection connection, int objectID) { ObjectSpace[] instances = ObjectSpace.instances; for (int i = 0, n = instances.length; i < n; i++) { ObjectSpace objectSpace = instances[i]; // Check if the connection is in this ObjectSpace. Connection[] connections = objectSpace.connections; for (int j = 0; j < connections.length; j++) { if (connections[j] != connection) continue; // Find an object with the objectID. Object object = objectSpace.idToObject.get(objectID); if (object != null) return object; } } return null; }
public void received (final Connection connection, Object object) { if (!(object instanceof InvokeMethod)) return; if (connections != null) { int i = 0, n = connections.length; for (; i < n; i++) if (connection == connections[i]) break; if (i == n) return; // The InvokeMethod message is not for a connection in this ObjectSpace. } final InvokeMethod invokeMethod = (InvokeMethod)object; final Object target = idToObject.get(invokeMethod.objectID); if (target == null) { if (WARN) warn("kryonet", "Ignoring remote invocation request for unknown object ID: " + invokeMethod.objectID); return; } if (executor == null) invoke(connection, target, invokeMethod); else { executor.execute(new Runnable() { public void run () { invoke(connection, target, invokeMethod); } }); } }
public void getEventsForPeriod(LocalDate from, LocalDate to, ObservableList<Event> observableEvents) { EventMessage eventMessage = new EventMessage(currentUser.getValue(), EventMessage.Command.SEND_EVENTS, from, to); CalendarClient client = CalendarClient.getInstance(); Listener listener = new Listener() { public void received(Connection connection, Object object) { if (object instanceof EventMessage) { EventMessage message = (EventMessage) object; if (message.getCommand() == EventMessage.Command.RECEIVE_EVENTS) { observableEvents.addAll(message.getEvents()); client.removeListener(this); } } } }; client.addListener(listener); client.sendMessage(eventMessage); }
public boolean onPacketReceived(Connection connection, Object packet) { Iterator<Class> it = mPackets.keySet().iterator(); while (it.hasNext()) { Class item = it.next(); try { if (packet.getClass().isAssignableFrom(item)) { PacketAction a = mPackets.get(item); AccountConnection c = (AccountConnection)connection; if (!a.needLoggedIn() || (c.getToken() != null && c.getToken().length() > 0)) { a.run(c, packet); } else { ErrorPacket p = new ErrorPacket(); p.message = "You are not authenticated."; p.status = ErrorType.NOT_AUTHENTICATED; c.sendTCP(p); c.close(); } return true; } } catch (Exception e) { Log.error("PacketInterpretator", e); } } return false; }