Examples with TargetingInfo blusunrize.immersiveengineering.api.TargetingInfo used on opensource projects

Example 1 with TargetingInfo

use of blusunrize.immersiveengineering.api.TargetingInfo in project ImmersiveEngineering by BluSunrize.

the class ItemIETool method onItemUseFirst.

//	@Override
//	public boolean doesContainerItemLeaveCraftingGrid(ItemStack stack)
//	{
//		return stack.getItemDamage()!=0;
//	}
@Override
public EnumActionResult onItemUseFirst(ItemStack stack, EntityPlayer player, World world, BlockPos pos, EnumFacing side, float hitX, float hitY, float hitZ, EnumHand hand) {
    TileEntity tileEntity = world.getTileEntity(pos);
    if (stack.getItemDamage() == 0) {
        if (FMLCommonHandler.instance().getEffectiveSide() == Side.CLIENT)
            return EnumActionResult.PASS;
        String[] permittedMultiblocks = null;
        String[] interdictedMultiblocks = null;
        if (ItemNBTHelper.hasKey(stack, "multiblockPermission")) {
            NBTTagList list = stack.getTagCompound().getTagList("multiblockPermission", 8);
            permittedMultiblocks = new String[list.tagCount()];
            for (int i = 0; i < permittedMultiblocks.length; i++) permittedMultiblocks[i] = list.getStringTagAt(i);
        }
        if (ItemNBTHelper.hasKey(stack, "multiblockInterdiction")) {
            NBTTagList list = stack.getTagCompound().getTagList("multiblockInterdiction", 8);
            interdictedMultiblocks = new String[list.tagCount()];
            for (int i = 0; i < interdictedMultiblocks.length; i++) interdictedMultiblocks[i] = list.getStringTagAt(i);
        }
        for (IMultiblock mb : MultiblockHandler.getMultiblocks()) if (mb.isBlockTrigger(world.getBlockState(pos))) {
            boolean b = permittedMultiblocks == null;
            if (permittedMultiblocks != null)
                for (String s : permittedMultiblocks) if (mb.getUniqueName().equalsIgnoreCase(s)) {
                    b = true;
                    continue;
                }
            if (!b)
                break;
            if (interdictedMultiblocks != null)
                for (String s : interdictedMultiblocks) if (mb.getUniqueName().equalsIgnoreCase(s)) {
                    b = false;
                    continue;
                }
            if (!b)
                break;
            if (MultiblockHandler.postMultiblockFormationEvent(player, mb, pos, stack).isCanceled())
                continue;
            if (mb.createStructure(world, pos, side, player))
                return EnumActionResult.SUCCESS;
        }
        TileEntity tile = world.getTileEntity(pos);
        if (!(tile instanceof IDirectionalTile) && !(tile instanceof IHammerInteraction) && !(tile instanceof IConfigurableSides))
            return RotationUtil.rotateBlock(world, pos, side) ? EnumActionResult.SUCCESS : EnumActionResult.PASS;
    } else if (stack.getItemDamage() == 1 && tileEntity instanceof IImmersiveConnectable && !world.isRemote) {
        TargetingInfo target = new TargetingInfo(side, hitX, hitY, hitZ);
        BlockPos masterPos = ((IImmersiveConnectable) tileEntity).getConnectionMaster(null, target);
        tileEntity = world.getTileEntity(masterPos);
        if (!(tileEntity instanceof IImmersiveConnectable))
            return EnumActionResult.PASS;
        IImmersiveConnectable nodeHere = (IImmersiveConnectable) tileEntity;
        boolean cut = ImmersiveNetHandler.INSTANCE.clearAllConnectionsFor(Utils.toCC(nodeHere), world, target);
        IESaveData.setDirty(world.provider.getDimension());
        if (cut) {
            int nbtDamage = ItemNBTHelper.getInt(stack, "cutterDmg") + 1;
            if (nbtDamage < cutterMaxDamage)
                ItemNBTHelper.setInt(stack, "cutterDmg", nbtDamage);
            else {
                player.renderBrokenItemStack(stack);
                player.setItemStackToSlot(EntityEquipmentSlot.MAINHAND, null);
            }
        }
        return EnumActionResult.SUCCESS;
    } else if (stack.getItemDamage() == 2 && !world.isRemote) {
        if (!player.isSneaking() && (tileEntity instanceof IFluxReceiver || tileEntity instanceof IFluxProvider)) {
            int max = 0;
            int stored = 0;
            if (tileEntity instanceof IFluxReceiver) {
                max = ((IFluxReceiver) tileEntity).getMaxEnergyStored(side);
                stored = ((IFluxReceiver) tileEntity).getEnergyStored(side);
            } else {
                max = ((IFluxProvider) tileEntity).getMaxEnergyStored(side);
                stored = ((IFluxProvider) tileEntity).getEnergyStored(side);
            }
            if (max > 0)
                ChatUtils.sendServerNoSpamMessages(player, new TextComponentTranslation(Lib.CHAT_INFO + "energyStorage", stored, max));
            return EnumActionResult.SUCCESS;
        }
        if (player.isSneaking() && tileEntity instanceof IImmersiveConnectable) {
            if (!ItemNBTHelper.hasKey(stack, "linkingPos"))
                ItemNBTHelper.setIntArray(stack, "linkingPos", new int[] { world.provider.getDimension(), pos.getX(), pos.getY(), pos.getZ() });
            else {
                int[] array = ItemNBTHelper.getIntArray(stack, "linkingPos");
                BlockPos linkPos = new BlockPos(array[1], array[2], array[3]);
                TileEntity tileEntityLinkingPos = world.getTileEntity(linkPos);
                if (array[0] == world.provider.getDimension()) {
                    IImmersiveConnectable nodeHere = (IImmersiveConnectable) tileEntity;
                    IImmersiveConnectable nodeLink = (IImmersiveConnectable) tileEntityLinkingPos;
                    if (nodeLink != null) {
                        Set<AbstractConnection> connections = ImmersiveNetHandler.INSTANCE.getIndirectEnergyConnections(Utils.toCC(nodeLink), world, true);
                        for (AbstractConnection con : connections) if (Utils.toCC(nodeHere).equals(con.end))
                            player.addChatComponentMessage(new TextComponentTranslation(Lib.CHAT_INFO + "averageLoss", Utils.formatDouble(con.getAverageLossRate() * 100, "###.000")));
                    }
                }
                ItemNBTHelper.remove(stack, "linkingPos");
            }
            return EnumActionResult.SUCCESS;
        }
    }
    return EnumActionResult.PASS;
}

Example 2 with TargetingInfo

use of blusunrize.immersiveengineering.api.TargetingInfo in project ImmersiveEngineering by BluSunrize.

the class ItemWireCoil method onItemUseFirst.

@Override
public EnumActionResult onItemUseFirst(ItemStack stack, EntityPlayer player, World world, BlockPos pos, EnumFacing side, float hitX, float hitY, float hitZ, EnumHand hand) {
    if (!world.isRemote) {
        TileEntity tileEntity = world.getTileEntity(pos);
        if (tileEntity instanceof IImmersiveConnectable && ((IImmersiveConnectable) tileEntity).canConnect()) {
            TargetingInfo target = new TargetingInfo(side, hitX, hitY, hitZ);
            WireType wire = getWireType(stack);
            BlockPos masterPos = ((IImmersiveConnectable) tileEntity).getConnectionMaster(wire, target);
            tileEntity = world.getTileEntity(masterPos);
            if (!(tileEntity instanceof IImmersiveConnectable) || !((IImmersiveConnectable) tileEntity).canConnect())
                return EnumActionResult.PASS;
            if (!((IImmersiveConnectable) tileEntity).canConnectCable(wire, target)) {
                player.addChatMessage(new TextComponentTranslation(Lib.CHAT_WARN + "wrongCable"));
                return EnumActionResult.FAIL;
            }
            if (!ItemNBTHelper.hasKey(stack, "linkingPos")) {
                ItemNBTHelper.setIntArray(stack, "linkingPos", new int[] { world.provider.getDimension(), masterPos.getX(), masterPos.getY(), masterPos.getZ() });
                NBTTagCompound targetNbt = new NBTTagCompound();
                target.writeToNBT(targetNbt);
                ItemNBTHelper.setTagCompound(stack, "targettingInfo", targetNbt);
            } else {
                WireType type = getWireType(stack);
                int[] array = ItemNBTHelper.getIntArray(stack, "linkingPos");
                BlockPos linkPos = new BlockPos(array[1], array[2], array[3]);
                TileEntity tileEntityLinkingPos = world.getTileEntity(linkPos);
                int distanceSq = (int) Math.ceil(linkPos.distanceSq(masterPos));
                if (array[0] != world.provider.getDimension())
                    player.addChatMessage(new TextComponentTranslation(Lib.CHAT_WARN + "wrongDimension"));
                else if (linkPos.equals(masterPos))
                    player.addChatMessage(new TextComponentTranslation(Lib.CHAT_WARN + "sameConnection"));
                else if (distanceSq > (type.getMaxLength() * type.getMaxLength()))
                    player.addChatMessage(new TextComponentTranslation(Lib.CHAT_WARN + "tooFar"));
                else {
                    TargetingInfo targetLink = TargetingInfo.readFromNBT(ItemNBTHelper.getTagCompound(stack, "targettingInfo"));
                    if (!(tileEntityLinkingPos instanceof IImmersiveConnectable) || !((IImmersiveConnectable) tileEntityLinkingPos).canConnectCable(wire, targetLink))
                        player.addChatMessage(new TextComponentTranslation(Lib.CHAT_WARN + "invalidPoint"));
                    else {
                        IImmersiveConnectable nodeHere = (IImmersiveConnectable) tileEntity;
                        IImmersiveConnectable nodeLink = (IImmersiveConnectable) tileEntityLinkingPos;
                        boolean connectionExists = false;
                        Set<Connection> outputs = ImmersiveNetHandler.INSTANCE.getConnections(world, Utils.toCC(nodeHere));
                        if (outputs != null)
                            for (Connection con : outputs) {
                                if (con.end.equals(Utils.toCC(nodeLink)))
                                    connectionExists = true;
                            }
                        if (connectionExists)
                            player.addChatMessage(new TextComponentTranslation(Lib.CHAT_WARN + "connectionExists"));
                        else {
                            Vec3d rtOff0 = nodeHere.getRaytraceOffset(nodeLink).addVector(masterPos.getX(), masterPos.getY(), masterPos.getZ());
                            Vec3d rtOff1 = nodeLink.getRaytraceOffset(nodeHere).addVector(linkPos.getX(), linkPos.getY(), linkPos.getZ());
                            Set<BlockPos> ignore = new HashSet<>();
                            ignore.addAll(nodeHere.getIgnored(nodeLink));
                            ignore.addAll(nodeLink.getIgnored(nodeHere));
                            boolean canSee = Utils.rayTraceForFirst(rtOff0, rtOff1, world, ignore) == null;
                            if (canSee) {
                                ImmersiveNetHandler.INSTANCE.addConnection(world, Utils.toCC(nodeHere), Utils.toCC(nodeLink), (int) Math.sqrt(distanceSq), type);
                                nodeHere.connectCable(type, target, nodeLink);
                                nodeLink.connectCable(type, targetLink, nodeHere);
                                IESaveData.setDirty(world.provider.getDimension());
                                player.addStat(IEAchievements.connectWire);
                                if (!player.capabilities.isCreativeMode)
                                    stack.stackSize--;
                                ((TileEntity) nodeHere).markDirty();
                                world.addBlockEvent(masterPos, ((TileEntity) nodeHere).getBlockType(), -1, 0);
                                IBlockState state = world.getBlockState(masterPos);
                                world.notifyBlockUpdate(masterPos, state, state, 3);
                                ((TileEntity) nodeLink).markDirty();
                                world.addBlockEvent(linkPos, ((TileEntity) nodeLink).getBlockType(), -1, 0);
                                state = world.getBlockState(linkPos);
                                world.notifyBlockUpdate(linkPos, state, state, 3);
                            } else
                                player.addChatMessage(new TextComponentTranslation(Lib.CHAT_WARN + "cantSee"));
                        }
                    }
                }
                ItemNBTHelper.remove(stack, "linkingPos");
                ItemNBTHelper.remove(stack, "targettingInfo");
            }
            return EnumActionResult.SUCCESS;
        }
    }
    return EnumActionResult.PASS;
}

Example 3 with TargetingInfo

use of blusunrize.immersiveengineering.api.TargetingInfo in project ImmersiveEngineering by BluSunrize.

the class BlockConnector method getPickBlock.

@Override
public ItemStack getPickBlock(IBlockState state, RayTraceResult target, World world, BlockPos pos, EntityPlayer player) {
    // Select the wire if the player is sneaking
    if (player != null && player.isSneaking()) {
        TileEntity te = world.getTileEntity(pos);
        if (te instanceof IImmersiveConnectable) {
            TargetingInfo subTarget = null;
            if (target.hitVec != null)
                subTarget = new TargetingInfo(target.sideHit, (float) target.hitVec.x - pos.getX(), (float) target.hitVec.y - pos.getY(), (float) target.hitVec.z - pos.getZ());
            else
                subTarget = new TargetingInfo(target.sideHit, 0, 0, 0);
            BlockPos masterPos = ((IImmersiveConnectable) te).getConnectionMaster(null, subTarget);
            if (masterPos != pos)
                te = world.getTileEntity(masterPos);
            if (te instanceof IImmersiveConnectable) {
                IImmersiveConnectable connectable = (IImmersiveConnectable) te;
                WireType wire = connectable.getCableLimiter(subTarget);
                if (wire != null)
                    return wire.getWireCoil();
                ArrayList<ItemStack> applicableWires = new ArrayList<ItemStack>();
                NonNullList<ItemStack> pInventory = player.inventory.mainInventory;
                for (int i = 0; i < pInventory.size(); i++) {
                    ItemStack s = pInventory.get(i);
                    if (s.getItem() instanceof IWireCoil) {
                        IWireCoil coilItem = (IWireCoil) s.getItem();
                        wire = coilItem.getWireType(s);
                        if (connectable.canConnectCable(wire, subTarget, pos.subtract(masterPos)) && coilItem.canConnectCable(s, te)) {
                            ItemStack coil = wire.getWireCoil();
                            boolean unique = true;
                            int insertIndex = applicableWires.size();
                            for (int j = 0; j < applicableWires.size(); j++) {
                                ItemStack priorWire = applicableWires.get(j);
                                if (// sort same item by metadata
                                coil.getItem() == priorWire.getItem()) {
                                    if (coil.getMetadata() == priorWire.getMetadata()) {
                                        unique = false;
                                        break;
                                    }
                                    if (coil.getMetadata() < priorWire.getMetadata()) {
                                        insertIndex = j;
                                        break;
                                    }
                                } else /*sort different item by itemID (can't guarantee a static list otherwise. switching items by pickBlock changes the order in which things are looked at,
									making for scenarios in which applicable wires are possibly skipped when 3 or more wire Items are present)*/
                                {
                                    int coilID = Item.REGISTRY.getIDForObject(coil.getItem());
                                    int priorID = Item.REGISTRY.getIDForObject(priorWire.getItem());
                                    if (coilID < priorID) {
                                        insertIndex = j;
                                        break;
                                    }
                                }
                            }
                            if (unique)
                                applicableWires.add(insertIndex, coil);
                        }
                    }
                }
                if (applicableWires.size() > 0) {
                    ItemStack heldItem = pInventory.get(player.inventory.currentItem);
                    if (heldItem.getItem() instanceof IWireCoil)
                        // cycle through to the next applicable wire, if currently held wire is already applicable
                        for (int i = 0; i < applicableWires.size(); i++) if (heldItem.isItemEqual(applicableWires.get(i)))
                            // wrap around on i+1 >= applicableWires.size()
                            return applicableWires.get((i + 1) % applicableWires.size());
                    return applicableWires.get(0);
                }
            }
        }
    }
    return super.getPickBlock(state, target, world, pos, player);
}

Example 4 with TargetingInfo

use of blusunrize.immersiveengineering.api.TargetingInfo in project ImmersiveEngineering by BluSunrize.

the class ItemIETool method onItemUse.

@Nonnull
@Override
public EnumActionResult onItemUse(EntityPlayer player, World world, BlockPos pos, EnumHand hand, EnumFacing side, float hitX, float hitY, float hitZ) {
    ItemStack stack = player.getHeldItem(hand);
    TileEntity tileEntity = world.getTileEntity(pos);
    if (stack.getMetadata() == HAMMER_META) {
        if (!(tileEntity instanceof IDirectionalTile) && !(tileEntity instanceof IHammerInteraction) && !(tileEntity instanceof IConfigurableSides))
            return RotationUtil.rotateBlock(world, pos, side) ? EnumActionResult.SUCCESS : EnumActionResult.PASS;
    } else if (stack.getMetadata() == CUTTER_META && tileEntity instanceof IImmersiveConnectable) {
        TargetingInfo target = new TargetingInfo(side, hitX, hitY, hitZ);
        BlockPos masterPos = ((IImmersiveConnectable) tileEntity).getConnectionMaster(null, target);
        tileEntity = world.getTileEntity(masterPos);
        if (!(tileEntity instanceof IImmersiveConnectable))
            return EnumActionResult.PASS;
        if (!world.isRemote) {
            IImmersiveConnectable nodeHere = (IImmersiveConnectable) tileEntity;
            boolean cut = ImmersiveNetHandler.INSTANCE.clearAllConnectionsFor(Utils.toCC(nodeHere), world, target);
            IESaveData.setDirty(world.provider.getDimension());
            if (cut) {
                int nbtDamage = ItemNBTHelper.getInt(stack, Lib.NBT_DAMAGE) + 1;
                if (nbtDamage < cutterDurabiliy)
                    ItemNBTHelper.setInt(stack, Lib.NBT_DAMAGE, nbtDamage);
                else {
                    player.renderBrokenItemStack(stack);
                    player.setItemStackToSlot(EntityEquipmentSlot.MAINHAND, ItemStack.EMPTY);
                }
            }
        }
        return EnumActionResult.SUCCESS;
    } else if (stack.getMetadata() == VOLTMETER_META && !world.isRemote) {
        if (!player.isSneaking() && (tileEntity instanceof IFluxReceiver || tileEntity instanceof IFluxProvider)) {
            int max = 0;
            int stored = 0;
            if (tileEntity instanceof IFluxReceiver) {
                max = ((IFluxReceiver) tileEntity).getMaxEnergyStored(side);
                stored = ((IFluxReceiver) tileEntity).getEnergyStored(side);
            } else {
                max = ((IFluxProvider) tileEntity).getMaxEnergyStored(side);
                stored = ((IFluxProvider) tileEntity).getEnergyStored(side);
            }
            if (max > 0)
                ChatUtils.sendServerNoSpamMessages(player, new TextComponentTranslation(Lib.CHAT_INFO + "energyStorage", stored, max));
            return EnumActionResult.SUCCESS;
        }
        if (player.isSneaking() && tileEntity instanceof IImmersiveConnectable) {
            if (!ItemNBTHelper.hasKey(stack, "linkingPos"))
                ItemNBTHelper.setIntArray(stack, "linkingPos", new int[] { world.provider.getDimension(), pos.getX(), pos.getY(), pos.getZ() });
            else {
                int[] array = ItemNBTHelper.getIntArray(stack, "linkingPos");
                BlockPos linkPos = new BlockPos(array[1], array[2], array[3]);
                TileEntity tileEntityLinkingPos = world.getTileEntity(linkPos);
                if (array[0] == world.provider.getDimension()) {
                    IImmersiveConnectable nodeHere = (IImmersiveConnectable) tileEntity;
                    IImmersiveConnectable nodeLink = (IImmersiveConnectable) tileEntityLinkingPos;
                    if (nodeLink != null) {
                        Set<AbstractConnection> connections = ImmersiveNetHandler.INSTANCE.getIndirectEnergyConnections(Utils.toCC(nodeLink), world, true);
                        for (AbstractConnection con : connections) if (Utils.toCC(nodeHere).equals(con.end))
                            player.sendMessage(new TextComponentTranslation(Lib.CHAT_INFO + "averageLoss", Utils.formatDouble(con.getAverageLossRate() * 100, "###.000")));
                    }
                }
                ItemNBTHelper.remove(stack, "linkingPos");
            }
            return EnumActionResult.SUCCESS;
        }
    }
    return EnumActionResult.PASS;
}