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

@Override
public void write(ByteBuffer byteBuffer, Object o) {
    if(o instanceof FrameworkMessage){
        byteBuffer.put((byte)-2); //code for framework message
        FrameworkSerializer.write(byteBuffer, (FrameworkMessage)o);
    }else {
        if (!(o instanceof Packet))
            throw new RuntimeException("All sent objects must implement be Packets! Class: " + o.getClass());
        byte id = Registrator.getID(o.getClass());
        if (id == -1)
            throw new RuntimeException("Unregistered class: " + ClassReflection.getSimpleName(o.getClass()));
        byteBuffer.put(id);
        ((Packet) o).write(byteBuffer);
    }
}

@Override
public void received(Connection conn, Object inPacket)
{
    if (inPacket instanceof FrameworkMessage)
        return;

    if (inPacket instanceof P1_KeyVerifier)
    {
        P1_KeyVerifier packet = (P1_KeyVerifier) inPacket;

        connectionData.setPublicKey(packet.getPublicKey());

        if (!packet.checkEncryption(connectionData))
        {
            conn.close();
            return;
        }

        connectionData.handshakeCompleted();

        Log.trace("Handshake completo, id: " + conn.getID(), LogTraceType.HANDSHAKE_COMPLETED);

        P2_KeyVerifier outPacket = new P2_KeyVerifier();
        outPacket.writePacket(connectionData, packet, null);
        conn.sendTCP(outPacket);
    }
    else if (inPacket instanceof IPacket)
        connectionData.elaboratePacket((IPacket) inPacket);
    else
        Log.localizedWarn("[UNKNOW_PACKET]", inPacket.getClass().getName());
}

public PacketHandlerFactory(final PlayState playState, final StateManager states)
{
    packetHandlers.put(AuthenticationReplyPacket.class, new AuthenticationReplyPacketHandler(states));
    packetHandlers.put(CharacterCreationReplyPacket.class, new CharacterCreationReplyPacketHandler(states));
    packetHandlers.put(CharacterItemDataPacket.class, new CharacterItemDataPacketHandler(playState));
    packetHandlers.put(ObjectCreationPacket.class, new ObjectCreationPacketHandler(playState));
    packetHandlers.put(ObjectRemovePacket.class, new ObjectRemovePacketHandler(playState));
    packetHandlers.put(ObjectRepositionPacket.class, new ObjectRepositionPacketHandler(playState));
    packetHandlers.put(RegisterationReplyPacket.class, new RegisterationReplyPacketHandler(states));
    packetHandlers.put(UserCharacterDataPacket[].class, new UserCharacterDataArrayPacketHandler(states));
    packetHandlers.put(ChatMessageReplyPacket.class, new ChatMessageReplyPacketHandler(playState));
    packetHandlers.put(MonsterTargetingReplyPacket.class,
            new CharacterMonsterTargetingReplyPacketHandler(playState));
    packetHandlers.put(NormalDamagePacket.class, new NormalDamagePacketHandler(playState));
    packetHandlers.put(FireDamagePacket.class, new FireDamagePacketHandler(playState));
    packetHandlers.put(MonsterCreationPacket.class, new MonsterCreationPacketHandler(playState));
    packetHandlers.put(ExperienceGainPacket.class, new ExperienceGainPacketHandler(playState));
    packetHandlers.put(PlayerCreationPacket.class, new PlayerCreationPacketHandler(playState));
    packetHandlers.put(HpChangeByItemUsagePacket.class, new HpChangeByItemUsagePacketHandler(playState));
    packetHandlers.put(MpChangeByItemUsagePacket.class, new MpChangeByItemUsagePacketHandler(playState));
    packetHandlers.put(ManaDrainPacket.class, new ManaDrainPacketHandler(playState));
    packetHandlers.put(ItemUsagePacket.class, new ItemUsagePacketHandler(playState));
    packetHandlers.put(ContainerContentPacket.class, new ContainerContentPacketHandler(playState));
    packetHandlers.put(ContainerItemRemovalPacket.class, new ContainerItemRemovalPacketHandler(playState));
    packetHandlers.put(UnacceptableOperationPacket.class, new UnacceptableOperationPacketHandler(playState));
    packetHandlers.put(GoldReceivePacket.class, new GoldReceivePacketHandler(playState));
    packetHandlers.put(ContainerGoldRemovalPacket.class, new ContainerGoldRemovalPacketHandler(playState));
    packetHandlers.put(HpUpdatePacket.class, new HpUpdatePacketHandler(playState));
    packetHandlers.put(MpUpdatePacket.class, new MpUpdatePacketHandler(playState));
    packetHandlers.put(ShopItemsPacket.class, new ShopItemsPacketHandler(playState));
    packetHandlers.put(GoldAmountChangePacket.class, new GoldAmountChangePacketHandler(playState));
    packetHandlers.put(ScriptExecutionErrorPacket.class, new ScriptExecutionErrorPacketHandler(playState));
    packetHandlers.put(InventoryItemRepositionPacket.class, new InventoryItemRepositionPacketHandler(playState));
    packetHandlers.put(InventoryItemSwapPacket.class, new InventoryItemSwapPacketHandler(playState));
    packetHandlers.put(InventoryItemStackPacket.class, new InventoryItemStackPacketHandler(playState));
    packetHandlers.put(ItemPutInQuickAccessBarPacket.class, new ItemPutInQuickAccessBarPacketHandler(playState));
    packetHandlers.put(SpellPutInQuickAccessBarPacket.class, new SpellPutInQuickAccessBarPacketHandler(playState));
    packetHandlers.put(ScriptResultInfoPacket.class, new ScriptResultInfoPacketHandler(playState));
    packetHandlers.put(QuestBoardInfoPacket.class, new QuestBoardInfoPacketHandler(playState));
    packetHandlers.put(QuestFinishedRewardPacket.class, new QuestFinishedRewardPacketHandler(playState));
    packetHandlers.put(ItemRewardRemovePacket.class, new ItemRewardRemovePacketHandler(playState));
    packetHandlers.put(QuestRewardGoldRemovalPacket.class, new QuestRewardGoldRemovalPacketHandler(playState));
    packetHandlers.put(QuestStateInfoPacket[].class, new QuestStateInfoPacketArrayHandler(playState));
    packetHandlers.put(QuestAcceptedPacket.class, new QuestAcceptedPacketHandler(playState));
    packetHandlers.put(NpcStartDialogPacket.class, new NpcStartDialogPacketHandler(playState));
    packetHandlers.put(NpcContinueDialogPacket.class, new NpcContinueDialogPacketHandler(playState));
    packetHandlers.put(KnownSpellInfoPacket.class, new KnownSpellInfoPacketHandler(playState));

    // Ignore framework keepAliveMessage
    packetHandlers.put(FrameworkMessage.KeepAlive.class, new NullPacketHandler());
}

public PacketHandlerFactory(Map<Integer, UserInfo> loggedUsersKeyUserId,
        Map<Integer, User> authenticatedClientsKeyClientId, Server server, PlayState playState)
{
    GameDataRetriever gameDataRetriever = new GameDataRetriever(loggedUsersKeyUserId,
            authenticatedClientsKeyClientId);

    packetHandlers.put(AuthenticationPacket.class, new AuthenticationPacketHandler(loggedUsersKeyUserId,
            authenticatedClientsKeyClientId, server, playState));
    packetHandlers.put(CharacterCreationPacket.class,
            new CharacterCreationPacketHandler(authenticatedClientsKeyClientId, server));
    packetHandlers.put(CharacterChangePacket.class, new CharacterChangePacketHandler(loggedUsersKeyUserId,
            authenticatedClientsKeyClientId, playState, server));
    packetHandlers.put(DisconnectPacket.class, new DisconnectPacketHandler());
    packetHandlers.put(GetUserCharactersPacket.class, new GetUserCharacterPacketHandler(server));
    packetHandlers.put(LogoutPacket.class,
            new LogoutPacketHandler(loggedUsersKeyUserId, authenticatedClientsKeyClientId, server, playState));
    packetHandlers.put(RegisterationPacket.class, new RegisterationPacketHandler(server));
    packetHandlers.put(UserCharacterDataPacket.class,
            new UserCharacterDataPacketHandler(loggedUsersKeyUserId, server, playState));
    packetHandlers.put(MoveLeftPacket.class, new MoveLeftPacketHandler(playState));
    packetHandlers.put(MoveRightPacket.class, new MoveRightPacketHandler(playState));
    packetHandlers.put(MoveUpPacket.class, new MoveUpPacketHandler(playState));
    packetHandlers.put(MoveDownPacket.class, new MoveDownPacketHandler(playState));
    packetHandlers.put(ChatMessagePacket.class, new ChatMessagePacketHandler(server, gameDataRetriever));
    packetHandlers.put(BoardClickPacket.class, new CharacterBoardClickPacketHandler(playState, gameDataRetriever));
    packetHandlers.put(ItemUsagePacket.class, new ItemUsagePacketHandler(gameDataRetriever, playState, server));
    packetHandlers.put(FireballSpellUsagePacket.class,
            new FireballSpellUsagePacketHandler(gameDataRetriever, playState));
    packetHandlers.put(HealSpellUsagePacket.class,
            new HealSpellUsagePacketHandler(gameDataRetriever, playState));
    packetHandlers.put(OpenContainterPacket.class, new OpenContainerPacketHandler(server, playState));
    packetHandlers.put(TakeItemFromContainerPacket.class,
            new TakeItemFromContainerPacketHandler(gameDataRetriever, server, playState));
    packetHandlers.put(TakingGoldFromContainerPacket.class,
            new TakingGoldFromContainerPacketHandler(gameDataRetriever, server, playState));
    packetHandlers.put(BuyFromShopPacket.class, new BuyFromShopPacketHandler(playState, gameDataRetriever));
    packetHandlers.put(ScriptCodePacket.class,
            new ScriptCodePacketHandler(playState, authenticatedClientsKeyClientId));
    packetHandlers.put(InventoryItemRepositionRequestPacket.class,
            new InventoryItemRepositionRequestPacketHandler(gameDataRetriever, playState));
    packetHandlers.put(ItemPutInQuickAccessBarPacket.class,
            new ItemPutInQuickAccessBarPacketHandler(playState, gameDataRetriever));
    packetHandlers.put(ItemRemovedFromQuickAccessBarPacket.class,
            new ItemRemovedFromQuickAccessBarPacketHandler(playState, gameDataRetriever));
    packetHandlers.put(SpellPutInQuickAccessBarPacket.class,
            new SpellPutInQuickAccessBarPacketHandler(playState, gameDataRetriever));
    packetHandlers.put(SpellRemovedFromQuickAccessBarPacket.class,
            new SpellRemovedFromQuickAccessBarPacketHandler(playState, gameDataRetriever));
    packetHandlers.put(RetrieveItemRewardPacket.class,
            new RetrieveItemRewardPacketHandler(gameDataRetriever, playState));
    packetHandlers.put(RetrieveGoldRewardPacket.class,
            new RetrieveGoldRewardPacketHandler(gameDataRetriever, playState));
    packetHandlers.put(AcceptQuestPacket.class, new AcceptQuestPacketHandler(gameDataRetriever));
    packetHandlers.put(NpcConversationAnwserChoosenPacket.class,
            new NpcConversationAnwserChoosenPacketHandler(playState, gameDataRetriever));
    // Ignore framework packets
    packetHandlers.put(FrameworkMessage.KeepAlive.class, new NullPacketHandler());
}

private void handleReceived(Connection conn, Object obj) {
    //Log.debug("received from server: " + obj);
    if (obj == null) {
        Log.error("received null object from kryonet");
    }
    if (obj instanceof ServerMessage.AssignPlayerEntityId) {
        handleAssignPlayerEntityId((ServerMessage.AssignPlayerEntityId) obj);
    }
    else if (obj instanceof ServerMessage.DestroyEntity) {
        ServerMessage.DestroyEntity destroy = (ServerMessage.DestroyEntity) obj;
        Main.inst.clientEventManager.addEventToQueue(new ClientEvent.DestroyEntity(destroy.id));
    }
    else if (obj instanceof ServerMessage.ServerInfo) {
        handleServerInfo((ServerMessage.ServerInfo) obj);
    }
    else if (obj instanceof ServerMessage.LevelGeometry) {
        handleLevelGeometry((ServerMessage.LevelGeometry) obj);
    }
    else if (obj instanceof ChatMessage) {
        ChatMessage chat = (ChatMessage) obj;
        // creation time based on when client receives it, override the value
        chat.createTime = TimeUtils.millis();
        Main.inst.clientEventManager.addEventToQueue(new ClientEvent.ReceivedChatMessage(chat));
    }
    else if (obj instanceof ServerUpdate) {
        ServerUpdate serverUpdate = (ServerUpdate) obj;
        if (serverUpdate.tickNum <= highestTickNumUpdateReceived) {
            Log.debug("discarding outdated serverupdate, ticknum: " + serverUpdate.tickNum + ", current tick: " + highestTickNumUpdateReceived);
            return;
        }
        /*long now = TimeUtils.millis();
        long elapsed = now - lastServerUpdateTime;
        lastServerUpdateTime = now;
        Log.debug("server update elapsed time (tick: " + serverUpdate.tickNum + "): " + elapsed);*/
        handleUpdateFromServer(serverUpdate);
    }
    else if (obj instanceof EntityInfoRequest.Response) {
        handleEntityInfoRequestResponse((EntityInfoRequest.Response) obj);
    }
    else if (obj instanceof FrameworkMessage.Ping) {
        if (((FrameworkMessage.Ping) obj).isReply) {
            ping = client.getReturnTripTime();
            //System.out.println("new ping: " + ping);
        }
    }
    else if (obj instanceof BulletPackage) {
        handleBulletPackage((BulletPackage) obj);
    } else {
        //Log.debug("unhandled object from server: " + obj);
        if (!obj.getClass().getName().contains("com.esotericsoftware.kryonet")) {
            throw new GdxRuntimeException("unhandled object from server: " + obj);
        }
    }
}

public void received(Connection connection, Object object) {
    if (object instanceof CameraMessage) {
        CameraMessage message = (CameraMessage) object;
        CameraConnection cameraConnection = (CameraConnection) connection;
        switch (message.messageId) {
            case UPDATE_CAR:
                UpdateCarMessage updateCarMsg = (UpdateCarMessage) message;

                if (!cameraConnection.isValidUpdateCarMessage(updateCarMsg.seqNr))
                    break;

                _moderator.updateCar(updateCarMsg.carId, updateCarMsg.posX, updateCarMsg.posY,
                        updateCarMsg.direction);
                break;
            case CAR_DETECTED:
                CarDetectedMessage carDetectedMsg = (CarDetectedMessage) message;

                // get the car image
                BufferedImage carImage = null;
                if (carDetectedMsg.image != null && carDetectedMsg.image.length > 0) {
                    try {
                        InputStream in = new ByteInputStream(carDetectedMsg.image,
                                carDetectedMsg.image.length);
                        carImage = ImageIO.read(in);
                        in.close();
                    } catch (IOException e) {
                        _logger.error("Exception caught while reading car image!", e);
                    }

                } else {
                    _logger.error("No image received for car with id: {}", carDetectedMsg.carId);
                }

                if (carImage != null) {

                    Car<Player> car = new Car<Player>(carDetectedMsg.carId, new Position(
                            carDetectedMsg.posX, carDetectedMsg.posY), new Direction(
                            carDetectedMsg.direction), carImage);
                    _moderator.carDetected(car);
                }

                break;
            case CONFIGURE_MAP:
                ConfigureMapMessage configureMapMsg = (ConfigureMapMessage) message;
                _moderator.configureMap(configureMapMsg.sizeX, configureMapMsg.sizeY);
                break;
            case DETECTION_FINISHED:
                _moderator.detectionFinished();
                break;
            default:
                _logger.warn("Camera message with id: {} not known!", message.messageId);
                break;
        }
    } else if (object instanceof FrameworkMessage.KeepAlive) {
        // _logger.debug("Received Camera keepAlive ...");
    }
}