Example usage for org.apache.commons.lang ArrayUtils toPrimitive

List of usage examples for org.apache.commons.lang ArrayUtils toPrimitive

Introduction

In this page you can find the example usage for org.apache.commons.lang ArrayUtils toPrimitive.

Prototype

public static boolean[] toPrimitive(Boolean[] array) 

Source Link

Document

Converts an array of object Booleans to primitives.

Usage

From source file:org.dragonet.net.DragonetSession.java

/**
 * Process a NACK packet/* w w  w  . j  av a2  s  .  c  o  m*/
 *
 * @param buffer The NACK packet binary array
 */
public void processNACKPacket(byte[] buffer) {
    try {
        PEBinaryReader reader = new PEBinaryReader(new ByteArrayInputStream(buffer));
        int count = reader.readShort();
        List<Integer> packets = new ArrayList<>();
        for (int i = 0; i < count && reader.available() > 0; ++i) {
            byte[] tmp = new byte[6];
            if (reader.readByte() == (byte) 0x00) {
                int start = reader.readTriad();
                int end = reader.readTriad();
                if ((end - start) > 4096) {
                    end = start + 4096;
                }
                for (int c = start; c <= end; ++c) {
                    packets.add(c);
                }
            } else {
                packets.add(reader.readTriad());
            }
        }
        int[] seqNums = ArrayUtils.toPrimitive(packets.toArray(new Integer[0]));
        for (int seq : seqNums) {
            if (this.cachedOutgoingPacket.containsKey(seq)) {
                this.dServer.networkHandler.getUdp().send(this.cachedOutgoingPacket.get(seq).getData(),
                        this.remoteAddress);
            }
        }
    } catch (IOException e) {
    }
}

From source file:org.dragonet.net.inf.mcpe.PENetworkClient.java

private synchronized void sendAllACK() {
    if (this.queueACK.isEmpty()) {
        return;/*from  www.j  av  a2s .c om*/
    }
    int[] ackSeqs = ArrayUtils.toPrimitive(this.queueACK.toArray(new Integer[0]));
    Arrays.sort(ackSeqs);
    this.queueACK.clear();
    ByteArrayOutputStream allRecBos = new ByteArrayOutputStream();
    PEBinaryWriter allRecWriter = new PEBinaryWriter(allRecBos);
    try {
        int count = ackSeqs.length;
        int records = 0;
        if (count > 0) {
            int pointer = 1;
            int start = ackSeqs[0];
            int last = ackSeqs[0];
            ByteArrayOutputStream recBos = new ByteArrayOutputStream();
            PEBinaryWriter recWriter;
            while (pointer < count) {
                int current = ackSeqs[pointer++];
                int diff = current - last;
                if (diff == 1) {
                    last = current;
                } else if (diff > 1) { //Forget about duplicated packets (bad queues?)
                    recBos.reset();
                    recWriter = new PEBinaryWriter(recBos);
                    if (start == last) {
                        recWriter.writeByte((byte) 0x01);
                        recWriter.writeTriad(start);
                        start = last = current;
                    } else {
                        recWriter.writeByte((byte) 0x00);
                        recWriter.writeTriad(start);
                        recWriter.writeTriad(last);
                        start = last = current;
                    }
                    records++;
                }
            }
            if (start == last) {
                allRecWriter.writeByte((byte) 0x01);
                allRecWriter.writeTriad(start);
            } else {
                allRecWriter.writeByte((byte) 0x00);
                allRecWriter.writeTriad(start);
                allRecWriter.writeTriad(last);
            }
            records++;
        }
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        PEBinaryWriter writer = new PEBinaryWriter(bos);
        writer.writeByte((byte) 0xC0);
        writer.writeShort((short) (records & 0xFFFF));
        writer.write(allRecBos.toByteArray());
        handler.send(bos.toByteArray(), this.remoteAddress);
    } catch (IOException e) {
    }
}

From source file:org.dragonet.net.inf.mcpe.PENetworkClient.java

private synchronized void sendAllNACK() {
    if (this.queueNACK.isEmpty()) {
        return;/*  ww w .  java  2 s.  c  o m*/
    }
    int[] ackSeqs = ArrayUtils.toPrimitive(this.queueNACK.toArray(new Integer[0]));
    Arrays.sort(ackSeqs);
    this.queueNACK.clear();
    ByteArrayOutputStream allRecBos = new ByteArrayOutputStream();
    PEBinaryWriter allRecWriter = new PEBinaryWriter(allRecBos);
    try {
        int count = ackSeqs.length;
        int records = 0;
        if (count > 0) {
            int pointer = 1;
            int start = ackSeqs[0];
            int last = ackSeqs[0];
            ByteArrayOutputStream recBos = new ByteArrayOutputStream();
            PEBinaryWriter recWriter;
            while (pointer < count) {
                int current = ackSeqs[pointer++];
                int diff = current - last;
                if (diff == 1) {
                    last = current;
                } else if (diff > 1) { //Forget about duplicated packets (bad queues?)
                    recBos.reset();
                    recWriter = new PEBinaryWriter(recBos);
                    if (start == last) {
                        recWriter.writeByte((byte) 0x01);
                        recWriter.writeTriad(start);
                        start = last = current;
                    } else {
                        recWriter.writeByte((byte) 0x00);
                        recWriter.writeTriad(start);
                        recWriter.writeTriad(last);
                        start = last = current;
                    }
                    records++;
                }
            }
            if (start == last) {
                allRecWriter.writeByte((byte) 0x01);
                allRecWriter.writeTriad(start);
            } else {
                allRecWriter.writeByte((byte) 0x00);
                allRecWriter.writeTriad(start);
                allRecWriter.writeTriad(last);
            }
            records++;
        }
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        PEBinaryWriter writer = new PEBinaryWriter(bos);
        writer.writeByte((byte) 0xA0);
        writer.writeShort((short) (records & 0xFFFF));
        writer.write(allRecBos.toByteArray());
        handler.send(bos.toByteArray(), this.remoteAddress);
    } catch (IOException e) {
    }
}

From source file:org.dragonet.net.inf.mcpe.PENetworkClient.java

/**
 * Process a ACK packet/*w  w  w . j a v  a  2  s  .  c  om*/
 *
 * @param buffer The ACK packet binary array
 */
public void processACKPacket(byte[] buffer) {
    try {
        PEBinaryReader reader = new PEBinaryReader(new ByteArrayInputStream(buffer));
        int count = reader.readShort();
        List<Integer> packets = new ArrayList<>();
        for (int i = 0; i < count && reader.available() > 0; ++i) {
            if (reader.readByte() == (byte) 0x00) {
                int start = reader.readTriad();
                int end = reader.readTriad();
                if ((end - start) > 4096) {
                    end = start + 4096;
                }
                for (int c = start; c <= end; ++c) {
                    packets.add(c);
                }
            } else {
                packets.add(reader.readTriad());
            }
        }
        int[] seqNums = ArrayUtils.toPrimitive(packets.toArray(new Integer[0]));
        for (int seq : seqNums) {
            if (this.cachedOutgoingPacket.containsKey(seq)) {
                this.cachedOutgoingPacket.remove(seq);
            }
            if (this.chunkPacketIDS.contains(seq)) {
                this.sentAndReceivedChunks++;
                this.chunkPacketIDS.remove(new Integer(seq));
            }
        }
    } catch (IOException e) {
    }
}

From source file:org.dragonet.net.inf.mcpe.PENetworkClient.java

/**
 * Process a NACK packet// w  ww.j a v a 2s  . co m
 *
 * @param buffer The NACK packet binary array
 */
public void processNACKPacket(byte[] buffer) {
    try {
        PEBinaryReader reader = new PEBinaryReader(new ByteArrayInputStream(buffer));
        int count = reader.readShort();
        List<Integer> packets = new ArrayList<>();
        for (int i = 0; i < count && reader.available() > 0; ++i) {
            if (reader.readByte() == (byte) 0x00) {
                int start = reader.readTriad();
                int end = reader.readTriad();
                if ((end - start) > 4096) {
                    end = start + 4096;
                }
                for (int c = start; c <= end; ++c) {
                    packets.add(c);
                }
            } else {
                packets.add(reader.readTriad());
            }
        }
        int[] seqNums = ArrayUtils.toPrimitive(packets.toArray(new Integer[0]));
        for (int seq : seqNums) {
            if (this.cachedOutgoingPacket.containsKey(seq)) {
                handler.getUdp().send(this.cachedOutgoingPacket.get(seq).getData(), this.remoteAddress);
            }
        }
    } catch (IOException e) {
    }
}

From source file:org.dragonet.net.translator.protocols.v0_10_0.Translator_v0_10_0.java

@Override
public PEPacket[] translateToPE(Message message) {
    /*//from  w w w . j  a va  2s.  c  o  m
     if (!message.getClass().getSimpleName().contains("Time") && !message.getClass().getSimpleName().contains("Chunk")
     && !message.getClass().getSimpleName().contains("Move")) {
     System.out.print("Trnaslating to PE: " + message.getClass().getSimpleName() + "\nDetail: " + message.toString());
     }
     /*
            
     /* ==================================================================================== */
    /**
     * Kick Message
     */
    if (message instanceof KickMessage) {
        return new PEPacket[] { new DisconnectPacket() };
    }

    /**
     * Chat Message
     */
    if (message instanceof ChatMessage) {
        String msg = "";
        try {
            //String msg = ((ChatMessage) message).text.asPlaintext();
            Object json = new JSONParser().parse(((ChatMessage) message).text.encode());
            if (json instanceof JSONObject) {
                msg = this.translateChatMessage((JSONObject) json);
            } else {
                msg = ((ChatMessage) message).text.asPlaintext();
            }
        } catch (ParseException ex) {
            return null;
        }
        //if(json)
        MessagePacket pkMessage = new MessagePacket();
        pkMessage.sender = "";
        pkMessage.message = msg;
        return new PEPacket[] { pkMessage };
    }

    /**
     * Position Update
     */
    if (message instanceof RelativeEntityPositionMessage) {
        RelativeEntityPositionMessage msgRelativeEntityPosition = ((RelativeEntityPositionMessage) message);
        Entity entity = this.getSession().getPlayer().getWorld().getEntityManager()
                .getEntity(msgRelativeEntityPosition.id);
        if (entity == null) {
            return null;
        }
        if (entity instanceof GlowPlayer) {
            boolean isTeleport = Math.sqrt(msgRelativeEntityPosition.deltaX
                    ^ 2 + msgRelativeEntityPosition.deltaY ^ 2 + msgRelativeEntityPosition.deltaZ ^ 2) > 2;
            MovePlayerPacket pkMovePlayer = new MovePlayerPacket(msgRelativeEntityPosition.id,
                    (float) entity.getLocation().getX(), (float) entity.getLocation().getY(),
                    (float) entity.getLocation().getZ(), entity.getLocation().getYaw(),
                    entity.getLocation().getPitch(), entity.getLocation().getYaw(), isTeleport);
            return new PEPacket[] { pkMovePlayer };
        } else {
            //TODO: Handle other entities
            return null;
        }
    }

    /**
     * Force Update Client Position & Rotation TODO: WHY THE FUCK DOESN'T IT
     * WORK!
     */
    if (message instanceof PositionRotationMessage) {
        if (this.getSession().getPlayer() == null) {
            return null;
        }
        PositionRotationMessage msgPosRot = (PositionRotationMessage) message;
        //Hack: Yaw and pitch set to 0.0f
        //MovePlayerPacket pkMovePlayer = new MovePlayerPacket(this.getSession().getPlayer().getEntityId(), (float) msgPosRot.x, (float) msgPosRot.y, (float) msgPosRot.z, 0.0f, 0.0f, 0.0f, true);
        MoveEntitiesPacket.MoveEntityData d = new MoveEntitiesPacket.MoveEntityData();
        d.x = (float) msgPosRot.x;
        d.y = (float) msgPosRot.y;
        d.z = (float) msgPosRot.z;
        d.yaw = 0.0f;
        d.pitch = 0.0f;
        MoveEntitiesPacket pkMoveEntity = new MoveEntitiesPacket(new MoveEntitiesPacket.MoveEntityData[] { d });
        return new PEPacket[] { pkMoveEntity };
    }

    /**
     * Repositioning Player
     */
    if (message instanceof PlayerPositionMessage) {
        PlayerPositionMessage msgPlayerPos = (PlayerPositionMessage) message;
        MovePlayerPacket pkMovePlayer = new MovePlayerPacket();
        pkMovePlayer.eid = this.getSession().getPlayer().getEntityId();
        pkMovePlayer.x = (float) msgPlayerPos.x;
        pkMovePlayer.y = (float) msgPlayerPos.y;
        pkMovePlayer.z = (float) msgPlayerPos.z;
        pkMovePlayer.yaw = this.getSession().getPlayer().getLocation().getYaw();
        pkMovePlayer.pitch = this.getSession().getPlayer().getLocation().getPitch();
        pkMovePlayer.teleport = true;
        return new PEPacket[] { pkMovePlayer };
    }
    if (message instanceof PlayerPositionLookMessage) {
        PlayerPositionLookMessage msgPlayerLookPos = (PlayerPositionLookMessage) message;
        MovePlayerPacket pkMovePlayer = new MovePlayerPacket();
        pkMovePlayer.eid = this.getSession().getPlayer().getEntityId();
        pkMovePlayer.x = (float) msgPlayerLookPos.x;
        pkMovePlayer.y = (float) msgPlayerLookPos.y;
        pkMovePlayer.z = (float) msgPlayerLookPos.z;
        pkMovePlayer.yaw = msgPlayerLookPos.yaw;
        pkMovePlayer.pitch = msgPlayerLookPos.pitch;
        pkMovePlayer.teleport = true;
        return new PEPacket[] { pkMovePlayer };
    }

    /**
     * Spawn Player
     */
    if (message instanceof SpawnPlayerMessage) {
        SpawnPlayerMessage msgSpawnPlayer = (SpawnPlayerMessage) message;
        if (!this.cachedEntityIDs.contains(msgSpawnPlayer.id)) {
            this.cachedEntityIDs.add(msgSpawnPlayer.id); //Add to the spawned entity list
        }
        this.cachedPlayerEntities.add(msgSpawnPlayer.id); //Register this id as a player
        AddPlayerPacket pkAddPlayer = new AddPlayerPacket();
        pkAddPlayer.clientID = 0;
        pkAddPlayer.eid = msgSpawnPlayer.getId();
        pkAddPlayer.username = this.getSession().getServer().getPlayer(msgSpawnPlayer.getUuid())
                .getDisplayName();
        pkAddPlayer.x = (float) msgSpawnPlayer.getX();
        pkAddPlayer.y = (float) msgSpawnPlayer.getY();
        pkAddPlayer.z = (float) msgSpawnPlayer.getZ();
        pkAddPlayer.yaw = (msgSpawnPlayer.getRotation() % 360 + 360) % 360;
        pkAddPlayer.pitch = msgSpawnPlayer.getPitch();
        pkAddPlayer.unknown1 = 0;
        pkAddPlayer.unknown2 = 0;
        pkAddPlayer.metadata = EntityMetaData.getMetaDataFromPlayer((GlowPlayer) this.getSession().getPlayer()
                .getWorld().getEntityManager().getEntity(msgSpawnPlayer.getId()));
        return new PEPacket[] { pkAddPlayer };
    }

    /**
     * Motion Change
     */
    if (message instanceof EntityVelocityMessage) {
        EntityVelocityMessage msgVelocity = (EntityVelocityMessage) message;
        SetEntityMotionPacket pkMotion = new SetEntityMotionPacket();
        SetEntityMotionPacket.EntityMotionData data = new SetEntityMotionPacket.EntityMotionData();
        data.eid = msgVelocity.id;
        data.motionX = msgVelocity.velocityX;
        data.motionY = msgVelocity.velocityY;
        data.motionZ = msgVelocity.velocityZ;
        pkMotion.motions = new SetEntityMotionPacket.EntityMotionData[] { data };
        return new PEPacket[] { pkMotion };
    }

    /**
     * Gamemode Change
     */
    if (message instanceof StateChangeMessage) {
        if (((StateChangeMessage) message).reason == StateChangeMessage.Reason.GAMEMODE.ordinal()) {
            if (this.getSession().getPlayer() == null) {
                return null;
            }
            StartGamePacket pkStartGame = new StartGamePacket();
            pkStartGame.eid = this.getSession().getPlayer().getEntityId();
            pkStartGame.gamemode = ((int) ((StateChangeMessage) message).value) & 0x1;
            pkStartGame.seed = 0;
            pkStartGame.generator = 1;
            pkStartGame.spawnX = this.getSession().getPlayer().getWorld().getSpawnLocation().getBlockX();
            pkStartGame.spawnY = this.getSession().getPlayer().getWorld().getSpawnLocation().getBlockY();
            pkStartGame.spawnZ = this.getSession().getPlayer().getWorld().getSpawnLocation().getBlockZ();
            pkStartGame.x = (float) this.getSession().getPlayer().getLocation().getX();
            pkStartGame.y = (float) this.getSession().getPlayer().getLocation().getY();
            pkStartGame.z = (float) this.getSession().getPlayer().getLocation().getZ();
            return new PEPacket[] { pkStartGame };
        }
    }

    /**
     * Open Window
     */
    if (message instanceof OpenWindowMessage) {
        OpenWindowMessage msgOpenWindow = (OpenWindowMessage) message;
        byte typePE = InventoryType.PEInventory
                .toPEInventory(InventoryType.PCInventory.fromString(msgOpenWindow.type), msgOpenWindow.slots);
        if (typePE == (byte) 0xFF) {
            //Not supported, close it
            CloseWindowMessage msgCloseWindow = new CloseWindowMessage(msgOpenWindow.id);
            this.getSession().messageReceived(msgCloseWindow);
            return null;
        }
        WindowOpenPacket pkOpenWindow = new WindowOpenPacket();
        pkOpenWindow.windowID = (byte) (msgOpenWindow.id & 0xFF);
        pkOpenWindow.type = typePE;
        pkOpenWindow.slots = (byte) (msgOpenWindow.slots & 0xFFFF);
        pkOpenWindow.x = this.getSession().getPlayer().getLocation().getBlockX();
        pkOpenWindow.y = this.getSession().getPlayer().getLocation().getBlockY();
        pkOpenWindow.z = this.getSession().getPlayer().getLocation().getBlockZ();
        this.cachedWindowType[msgOpenWindow.id & 0xFF] = typePE;
        return new PEPacket[] { pkOpenWindow };
    }

    /**
     * Set Window Items
     */
    if (message instanceof SetWindowContentsMessage) {
        SetWindowContentsMessage msgWindowContents = (SetWindowContentsMessage) message;
        if (msgWindowContents.id == 0) {
            //Inventory Items(Included hotbar)
            WindowItemsPacket pkInventory = new WindowItemsPacket();
            pkInventory.windowID = PEWindowConstantID.PLAYER_INVENTORY;
            pkInventory.slots = new PEInventorySlot[InventoryType.SlotSize.PLAYER];
            for (int i = 9; i <= 44; i++) {
                if (msgWindowContents.items[i] != null) {
                    pkInventory.slots[i - 9] = new PEInventorySlot(
                            (short) (msgWindowContents.items[i].getTypeId() & 0xFFFF),
                            (byte) (msgWindowContents.items[i].getAmount() & 0xFF),
                            msgWindowContents.items[i].getDurability());
                } else {
                    pkInventory.slots[i - 9] = new PEInventorySlot();
                }
            }
            pkInventory.hotbar = new int[9];
            for (int i = 36; i <= 44; i++) {
                pkInventory.hotbar[i - 36] = i - 9;
            }
            //Armor
            WindowItemsPacket pkArmorInv = new WindowItemsPacket();
            pkArmorInv.windowID = PEWindowConstantID.PLAYER_ARMOR;
            pkArmorInv.slots = new PEInventorySlot[4];
            for (int i = 5; i <= 8; i++) {
                if (msgWindowContents.items[i] != null) {
                    pkArmorInv.slots[i - 5] = new PEInventorySlot(
                            (short) (msgWindowContents.items[i].getTypeId() & 0xFFFF),
                            (byte) (msgWindowContents.items[i].getAmount() & 0xFF),
                            msgWindowContents.items[i].getDurability());
                } else {
                    pkArmorInv.slots[i - 5] = new PEInventorySlot();
                }
            }
            if (this.getSession().getSentAndReceivedChunks() != -1) {
                //Not fully loaded
                this.getSession().getQueueAfterChunkSent().add(pkInventory);
                this.getSession().getQueueAfterChunkSent().add(pkArmorInv);
            } else {
                return new PEPacket[] { pkInventory, pkArmorInv };
            }
            return null;
        }
        //TODO: Implement other types of inventory
        //switch(this.getSession().getPlayer().)
        System.out.println("Updating window content for " + msgWindowContents.id + ", which has "
                + msgWindowContents.items.length + " slots. ");
    }

    /**
     * Set Window Slot
     */
    if (message instanceof SetWindowSlotMessage) {
        SetWindowSlotMessage msgSetSlot = (SetWindowSlotMessage) message;
        if (this.cachedWindowType[msgSetSlot.id & 0xFF] == -1) {
            return null;
        }
        //NOT WORKING YET
        /*
         //System.out.println("Updating slot: WID=" + msgSetSlot.id + ", ITEM=" + msgSetSlot.item + ", SLOTID=" + msgSetSlot.slot);
         //byte typePE = (byte) (this.cachedWindowType[msgSetSlot.id & 0xFF] & 0xFF);
         int targetSlot = 0;
         if (msgSetSlot.id == 0) {
         if (msgSetSlot.slot >= 9 && msgSetSlot.slot <= 35) {
         targetSlot = (short) (msgSetSlot.slot - 9);
         } else if (msgSetSlot.slot >= 36 && msgSetSlot.slot <= 44) {
         targetSlot = (short) (msgSetSlot.slot - 36);
         } else {
         targetSlot = (short) (msgSetSlot.slot & 0xFFFF);
         }
         } else {
         targetSlot = (short) (msgSetSlot.slot & 0xFFFF);
         }
         WindowSetSlotPacket pkSetSlot = new WindowSetSlotPacket();
         pkSetSlot.windowID = (byte) (msgSetSlot.id & 0xFF);
         pkSetSlot.slot = (short) (targetSlot & 0xFFFF);
         pkSetSlot.item = new PEInventorySlot((short) (msgSetSlot.item.getTypeId() & 0xFFFF), (byte) (msgSetSlot.item.getAmount() & 0xFF), msgSetSlot.item.getDurability());
         return new PEPacket[]{pkSetSlot};
         */
        if (msgSetSlot.id == 0) {
            //Player Inventory
            this.getSession().sendInventory();
            return null;
        } else {
            //TODO
            //this.getSession().getPlayer().getOpenInventory().getTopInventory()
        }
    }

    /**
     * Close Window Slot
     */
    if (message instanceof CloseWindowMessage) {
        CloseWindowMessage msgCloseWindow = (CloseWindowMessage) message;
        if (msgCloseWindow.id != 0) {
            this.cachedWindowType[msgCloseWindow.id & 0xFF] = -1;
        }
        WindowClosePacket pkCloseWindow = new WindowClosePacket();
        pkCloseWindow.windowID = (byte) (msgCloseWindow.id & 0xFF);
        return new PEPacket[] { pkCloseWindow };
    }

    /**
     * Set time
     */
    if (message instanceof TimeMessage) {
        SetTimePacket pkTime = new SetTimePacket(0, (this.getSession().getSentAndReceivedChunks() == -1)); //Because of the hack, we use 0 here. 
        return new PEPacket[] { pkTime };
    }

    /**
     * Block Change
     */
    if (message instanceof BlockChangeMessage) {
        BlockChangeMessage msgBC = (BlockChangeMessage) message;
        UpdateBlockPacket pkBC = new UpdateBlockPacket();
        pkBC.x = msgBC.x;
        pkBC.z = msgBC.z;
        pkBC.y = (byte) (msgBC.y & 0xFF);
        pkBC.block = (byte) (this.itemTranslator.translateToPE(msgBC.type >> 4) & 0xFF);
        pkBC.meta = (byte) (msgBC.type & 0xFF);
        return new PEPacket[] { pkBC };
    }

    /**
     * Multi Block Change
     */
    if (message instanceof MultiBlockChangeMessage) {
        MultiBlockChangeMessage msgMBC = (MultiBlockChangeMessage) message;
        PEPacket[] packets = new PEPacket[msgMBC.records.size()];
        int i = 0;
        for (BlockChangeMessage msgBC : msgMBC.records) {
            packets[i] = this.translateToPE(msgBC)[0];
            i++;
        }
        return packets;
    }

    /**
     * Spawn Object
     */
    if (message instanceof SpawnObjectMessage) {
        SpawnObjectMessage msgObj = (SpawnObjectMessage) message;
        this.cachedSpawnObjects.put(msgObj.id, msgObj); //Cache it first :P 
    }

    /**
     * Entity Metadata
     */
    if (message instanceof EntityMetadataMessage) {
        EntityMetadataMessage msgEntityMeta = (EntityMetadataMessage) message;
        if (!this.cachedEntityIDs.contains(msgEntityMeta.id)) { //Not spawned yet, let's create them
            if (this.cachedSpawnObjects.containsKey(msgEntityMeta.id)) {
                //Spawn it :) 
                SpawnObjectMessage msgObj = this.cachedSpawnObjects.get(msgEntityMeta.id);
                this.cachedSpawnObjects.remove(msgEntityMeta.id); //Remove it
                switch (msgObj.type) {
                case 2: //Dropped Item
                    AddItemEntityPacket pkAddItemEntity = new AddItemEntityPacket();
                    pkAddItemEntity.eid = msgObj.id;
                    pkAddItemEntity.item = new PEInventorySlot(
                            (short) (((ItemStack) msgEntityMeta.entries.get(0).value).getTypeId() & 0xFFFF),
                            (byte) (((ItemStack) msgEntityMeta.entries.get(0).value).getAmount() & 0xFF),
                            (short) (((ItemStack) msgEntityMeta.entries.get(0).value).getDurability()
                                    & 0xFFFF));
                    pkAddItemEntity.pitch = 0;
                    pkAddItemEntity.yaw = 0;
                    pkAddItemEntity.x = (float) (msgObj.x / 32);
                    pkAddItemEntity.y = (float) (msgObj.y / 32);
                    pkAddItemEntity.z = (float) (msgObj.z / 32);
                    pkAddItemEntity.roll = (byte) 0x00;
                    return new PEPacket[] { pkAddItemEntity };
                }
            } else {
                return null;
            }
        }
    }

    /**
     * Remove Entities
     */
    if (message instanceof DestroyEntitiesMessage) {
        DestroyEntitiesMessage pkDestroy = (DestroyEntitiesMessage) message;
        this.cachedEntityIDs.removeAll(pkDestroy.ids); //Remove from the list
        int[] ids = ArrayUtils.toPrimitive(pkDestroy.ids.toArray(new Integer[0]));
        PEPacket[] pkRemoveEntity = new PEPacket[ids.length];
        for (int i = 0; i < ids.length; i++) {
            if (!this.cachedPlayerEntities.contains(ids[i])) {
                pkRemoveEntity[i] = new RemoveEntityPacket();
                ((RemoveEntityPacket) pkRemoveEntity[i]).eid = ids[i];
            } else {
                pkRemoveEntity[i] = new RemovePlayerPacket();
                ((RemovePlayerPacket) pkRemoveEntity[i]).clientID = 0;
                ((RemovePlayerPacket) pkRemoveEntity[i]).eid = ids[i];
                this.cachedPlayerEntities.remove(new Integer(ids[i]));
            }
        }
        return pkRemoveEntity;
    }

    /**
     * Collect Item
     */
    if (message instanceof CollectItemMessage) {
        CollectItemMessage msgCollectItem = (CollectItemMessage) message;
        PickUpItemPacket pkPickUp = new PickUpItemPacket();
        pkPickUp.target = msgCollectItem.collector;
        pkPickUp.eid = msgCollectItem.id;
        return new PEPacket[] { pkPickUp };
    }

    /**
     * Animate Packet
     */
    if (message instanceof AnimateEntityMessage) {
        AnimateEntityMessage msgAnimate = (AnimateEntityMessage) message;
        AnimatePacket pkAnimate = new AnimatePacket();
        pkAnimate.eid = msgAnimate.id;
        pkAnimate.action = (byte) 0x01; //(msgAnimate.animation & 0xFF);
        return new PEPacket[] { pkAnimate };
    }

    /**
     * Entity Equipment
     */
    if (message instanceof EntityEquipmentMessage) {
        EntityEquipmentMessage msgEquipment = (EntityEquipmentMessage) message;
        if (!(this.getSession().getPlayer().getWorld().getEntityManager()
                .getEntity(msgEquipment.id) instanceof Player)) {
            return null;
        }
        switch (msgEquipment.slot) {
        case 0: //Held Item
            PlayerEquipmentPacket pkEquipment = new PlayerEquipmentPacket();
            pkEquipment.eid = msgEquipment.id;
            if (msgEquipment.stack != null) {
                pkEquipment.item = (short) (msgEquipment.stack.getTypeId() & 0xFFFF);
                pkEquipment.meta = (short) (msgEquipment.stack.getDurability() & 0xFFFF);
            } else {
                pkEquipment.item = 0;
                pkEquipment.meta = 0;
            }
            pkEquipment.slot = (byte) 0;
            return new PEPacket[] { pkEquipment };
        }
    }

    /* ==================================================================================== */
    return null;
}

From source file:org.dragonet.net.translator.tope.DestroyEntitiesMessageTranslator.java

@Override
public PEPacket[] handleSpecific(DestroyEntitiesMessage packet) {
    this.getTranslator().cachedEntityIDs.removeAll(packet.ids); //Remove from the list
    int[] ids = ArrayUtils.toPrimitive(packet.ids.toArray(new Integer[0]));
    ArrayList<PEPacket> pkRemoveEntity = new ArrayList<>();
    for (int i = 0; i < ids.length; i++) {
        if (!this.getTranslator().cachedPlayerEntities.contains(ids[i])) {
            PEPacket tmp = new RemoveEntityPacket();
            ((RemoveEntityPacket) tmp).eid = ids[i];
            pkRemoveEntity.add(tmp);//w w w  .  ja  va  2  s . c  o m
        } else {
            GlowPlayer glow = ((GlowPlayer) this.getSession().getPlayer().getWorld().getEntityManager()
                    .getEntity(ids[i]));
            PEPacket tmp = new RemovePlayerPacket();
            ((RemovePlayerPacket) tmp).uuid = glow.getUniqueId();
            ((RemovePlayerPacket) tmp).eid = ids[i];
            this.getTranslator().cachedPlayerEntities.remove(new Integer(ids[i]));
            PlayerListPacket pl = new PlayerListPacket(
                    new PlayerListPacket.PlayerInfo(glow.getUniqueId(), -1, null, true, true, null));
            pl.isAdding = false;
            pkRemoveEntity.add(tmp);
            pkRemoveEntity.add(pl);
        }
    }
    return pkRemoveEntity.toArray(new PEPacket[0]);
}

From source file:org.drugis.addis.presentation.wizard.NetworkMetaAnalysisWizardPM.java

protected Set<TreatmentDefinition> permuteTreatmentDefinitions() {
    Set<TreatmentDefinition> set = new HashSet<TreatmentDefinition>();
    for (TreatmentDefinition trivial : getRawAlternativesGraph().getSelectedDefinitions()) {
        // Find the categorizations relevant to the current combination of drugs
        List<TreatmentCategorization> catzs = new ArrayList<TreatmentCategorization>();
        List<Integer> nCat = new ArrayList<Integer>();
        for (Category category : trivial.getContents()) {
            TreatmentCategorization catz = (TreatmentCategorization) getCategorizationModel(category.getDrug())
                    .getValue();//from  w ww . j  a va  2s.  c  om
            catzs.add(catz);
            nCat.add(catz.getCategories().size());
        }

        // Generate all permutations of the categories in the relevant categorizations
        int[] c = ArrayUtils.toPrimitive(nCat.toArray(new Integer[] {}));
        int[] x = new int[c.length]; // initialized to { 0, ... }
        do {
            Set<Category> categories = new HashSet<Category>();
            for (int i = 0; i < x.length; ++i) {
                categories.add(catzs.get(i).getCategories().get(x[i]));
            }
            set.add(new TreatmentDefinition(categories));
        } while (CollectionUtil.nextLexicographicElement(x, c));
    }
    return set;
}

From source file:org.drugis.addis.util.convertors.NetworkMetaAnalysisConverter.java

private static void loadConsistencyModel(org.drugis.addis.entities.data.NetworkMetaAnalysis nma,
        NetworkMetaAnalysis networkMetaAnalysis, Domain domain) {
    final ConsistencyResults results = nma.getConsistencyResults();
    final HashMap<Parameter, QuantileSummary> quantileSummaries = new HashMap<Parameter, QuantileSummary>();
    final HashMap<Parameter, ConvergenceSummary> convergenceSummaries = new HashMap<Parameter, ConvergenceSummary>();

    addRelativeEffectQuantileSummaries(networkMetaAnalysis, quantileSummaries,
            results.getRelativeEffectsQuantileSummary().getRelativeEffectQuantileSummary(), domain);
    addParameterSummaries(networkMetaAnalysis, quantileSummaries, convergenceSummaries, results.getSummary(),
            domain);//from  w ww  . j a v a  2  s . c  o  m

    RelativeEffectsSummary relativeEffects = results.getRelativeEffectsSummary();
    double[] mean = ArrayUtils.toPrimitive(relativeEffects.getMeans()
            .toArray(new Double[results.getRelativeEffectsSummary().getMeans().size()]));
    int covarianceSize = calcCovMatrixDim(relativeEffects.getCovariance().size());

    double[][] covarianceMatrix = new double[covarianceSize][covarianceSize];
    int covIdx = 0;
    for (int row = 0; row < covarianceSize; row++) {
        for (int col = row; col < covarianceSize; col++) {
            double x = relativeEffects.getCovariance().get(covIdx);
            covarianceMatrix[row][col] = x;
            covarianceMatrix[col][row] = x;
            covIdx++;
        }
    }
    MultivariateNormalSummary relativeEffectsSummary = new SimpleMultivariateNormalSummary(mean,
            covarianceMatrix);

    // DrugSets are always sorted in their natural order
    List<Treatment> treatments = new ArrayList<Treatment>();
    for (DrugSet d : networkMetaAnalysis.getIncludedDrugs()) {
        treatments.add(networkMetaAnalysis.getTreatment(d));
    }
    double[][] rankProbabilityMatrix = new double[treatments.size()][treatments.size()];
    int rankIdx = 0;
    for (int row = treatments.size() - 1; row >= 0; row--) {
        for (int col = 0; col < treatments.size(); ++col) {
            rankProbabilityMatrix[col][row] = results.getRankProbabilitySummary().get(rankIdx);
            rankIdx++;
        }
    }
    RankProbabilitySummary rankProbabilitySummary = new RankProbabilitySummary(rankProbabilityMatrix,
            treatments);
    networkMetaAnalysis.loadConsistencyModel(buildMCMCSettingsCache(results.getMcmcSettings()),
            quantileSummaries, convergenceSummaries, relativeEffectsSummary, rankProbabilitySummary);
}

From source file:org.drugis.addis.util.jaxb.NetworkMetaAnalysisConverter.java

private static void loadConsistencyModel(org.drugis.addis.entities.data.NetworkMetaAnalysis nma,
        NetworkMetaAnalysis networkMetaAnalysis, Domain domain) {
    final ConsistencyResults results = nma.getConsistencyResults();
    final HashMap<Parameter, QuantileSummary> quantileSummaries = new HashMap<Parameter, QuantileSummary>();
    final HashMap<Parameter, ConvergenceSummary> convergenceSummaries = new HashMap<Parameter, ConvergenceSummary>();

    addRelativeEffectQuantileSummaries(networkMetaAnalysis, quantileSummaries,
            results.getRelativeEffectsQuantileSummary().getRelativeEffectQuantileSummary(), domain);
    addParameterSummaries(networkMetaAnalysis, quantileSummaries, convergenceSummaries, results.getSummary(),
            domain);//from w  w w  .  j a  v  a 2s .  c  o m

    RelativeEffectsSummary relativeEffects = results.getRelativeEffectsSummary();
    double[] mean = ArrayUtils.toPrimitive(relativeEffects.getMeans()
            .toArray(new Double[results.getRelativeEffectsSummary().getMeans().size()]));
    int covarianceSize = calcCovMatrixDim(relativeEffects.getCovariance().size());

    double[][] covarianceMatrix = new double[covarianceSize][covarianceSize];
    int covIdx = 0;
    for (int row = 0; row < covarianceSize; row++) {
        for (int col = row; col < covarianceSize; col++) {
            double x = relativeEffects.getCovariance().get(covIdx);
            covarianceMatrix[row][col] = x;
            covarianceMatrix[col][row] = x;
            covIdx++;
        }
    }
    MultivariateNormalSummary relativeEffectsSummary = new SimpleMultivariateNormalSummary(mean,
            covarianceMatrix);

    // TreatmentCategorySets are always sorted in their natural order
    List<Treatment> treatments = new ArrayList<Treatment>();
    for (TreatmentDefinition d : networkMetaAnalysis.getAlternatives()) {
        treatments.add(networkMetaAnalysis.getTreatment(d));
    }
    double[][] rankProbabilityMatrix = new double[treatments.size()][treatments.size()];
    int rankIdx = 0;
    for (int row = treatments.size() - 1; row >= 0; row--) {
        for (int col = 0; col < treatments.size(); ++col) {
            rankProbabilityMatrix[col][row] = results.getRankProbabilitySummary().get(rankIdx);
            rankIdx++;
        }
    }
    RankProbabilitySummary rankProbabilitySummary = new RankProbabilitySummary(rankProbabilityMatrix,
            treatments);
    networkMetaAnalysis.loadConsistencyModel(buildMCMCSettingsCache(results.getMcmcSettings()),
            quantileSummaries, convergenceSummaries, relativeEffectsSummary, rankProbabilitySummary);
}