Examples with ConfigInfo mekanism.common.tile.component.config.ConfigInfo used on opensource projects

Example 26 with ConfigInfo

use of mekanism.common.tile.component.config.ConfigInfo in project Mekanism by mekanism.

the class PacketConfigurationUpdate method handle.

@Override
public void handle(NetworkEvent.Context context) {
    PlayerEntity player = context.getSender();
    if (player == null) {
        return;
    }
    TileEntity tile = WorldUtils.getTileEntity(player.level, pos);
    if (tile instanceof ISideConfiguration) {
        ISideConfiguration config = (ISideConfiguration) tile;
        if (packetType == ConfigurationPacket.EJECT) {
            ConfigInfo info = config.getConfig().getConfig(transmission);
            if (info != null) {
                info.setEjecting(!info.isEjecting());
                WorldUtils.saveChunk(tile);
            }
        } else if (packetType == ConfigurationPacket.CLEAR_ALL) {
            TileComponentConfig configComponent = config.getConfig();
            ConfigInfo info = configComponent.getConfig(transmission);
            if (info != null) {
                for (RelativeSide side : EnumUtils.SIDES) {
                    if (info.isSideEnabled(side) && info.getDataType(side) != DataType.NONE) {
                        info.setDataType(DataType.NONE, side);
                        configComponent.sideChanged(transmission, side);
                    }
                }
            }
        } else if (packetType == ConfigurationPacket.SIDE_DATA) {
            TileComponentConfig configComponent = config.getConfig();
            ConfigInfo info = configComponent.getConfig(transmission);
            if (info != null) {
                DataType type = info.getDataType(inputSide);
                boolean changed = false;
                if (clickType == 0) {
                    changed = type != info.incrementDataType(inputSide);
                } else if (clickType == 1) {
                    changed = type != info.decrementDataType(inputSide);
                } else if (clickType == 2 && type != DataType.NONE) {
                    // We only need to update it if we are changing it to none
                    changed = true;
                    info.setDataType(DataType.NONE, inputSide);
                }
                if (changed) {
                    configComponent.sideChanged(transmission, inputSide);
                }
            }
        } else if (packetType == ConfigurationPacket.EJECT_COLOR) {
            TileComponentEjector ejector = config.getEjector();
            if (clickType == 0) {
                ejector.setOutputColor(TransporterUtils.increment(ejector.getOutputColor()));
            } else if (clickType == 1) {
                ejector.setOutputColor(TransporterUtils.decrement(ejector.getOutputColor()));
            } else if (clickType == 2) {
                ejector.setOutputColor(null);
            }
        } else if (packetType == ConfigurationPacket.INPUT_COLOR) {
            TileComponentEjector ejector = config.getEjector();
            if (clickType == 0) {
                ejector.setInputColor(inputSide, TransporterUtils.increment(ejector.getInputColor(inputSide)));
            } else if (clickType == 1) {
                ejector.setInputColor(inputSide, TransporterUtils.decrement(ejector.getInputColor(inputSide)));
            } else if (clickType == 2) {
                ejector.setInputColor(inputSide, null);
            }
        } else if (packetType == ConfigurationPacket.STRICT_INPUT) {
            TileComponentEjector ejector = config.getEjector();
            ejector.setStrictInput(!ejector.hasStrictInput());
        }
    }
}

Example 27 with ConfigInfo

use of mekanism.common.tile.component.config.ConfigInfo in project Mekanism by mekanism.

the class ItemConfigurator method useOn.

@Nonnull
@Override
public ActionResultType useOn(ItemUseContext context) {
    PlayerEntity player = context.getPlayer();
    World world = context.getLevel();
    if (!world.isClientSide && player != null) {
        BlockPos pos = context.getClickedPos();
        Direction side = context.getClickedFace();
        ItemStack stack = context.getItemInHand();
        TileEntity tile = WorldUtils.getTileEntity(world, pos);
        ConfiguratorMode mode = getMode(stack);
        if (mode.isConfigurating()) {
            // Configurate
            TransmissionType transmissionType = Objects.requireNonNull(mode.getTransmission(), "Configurating state requires transmission type");
            if (tile instanceof ISideConfiguration && ((ISideConfiguration) tile).getConfig().supports(transmissionType)) {
                ISideConfiguration config = (ISideConfiguration) tile;
                ConfigInfo info = config.getConfig().getConfig(transmissionType);
                if (info != null) {
                    RelativeSide relativeSide = RelativeSide.fromDirections(config.getDirection(), side);
                    DataType dataType = info.getDataType(relativeSide);
                    if (!player.isShiftKeyDown()) {
                        player.sendMessage(MekanismUtils.logFormat(MekanismLang.CONFIGURATOR_VIEW_MODE.translate(transmissionType, dataType.getColor(), dataType, dataType.getColor().getColoredName())), Util.NIL_UUID);
                    } else if (SecurityUtils.canAccess(player, tile)) {
                        if (!player.isCreative()) {
                            IEnergyContainer energyContainer = StorageUtils.getEnergyContainer(stack, 0);
                            FloatingLong energyPerConfigure = MekanismConfig.gear.configuratorEnergyPerConfigure.get();
                            if (energyContainer == null || energyContainer.extract(energyPerConfigure, Action.SIMULATE, AutomationType.MANUAL).smallerThan(energyPerConfigure)) {
                                return ActionResultType.FAIL;
                            }
                            energyContainer.extract(energyPerConfigure, Action.EXECUTE, AutomationType.MANUAL);
                        }
                        DataType old = dataType;
                        dataType = info.incrementDataType(relativeSide);
                        if (dataType != old) {
                            player.sendMessage(MekanismUtils.logFormat(MekanismLang.CONFIGURATOR_TOGGLE_MODE.translate(transmissionType, dataType.getColor(), dataType, dataType.getColor().getColoredName())), Util.NIL_UUID);
                            config.getConfig().sideChanged(transmissionType, relativeSide);
                        }
                    } else {
                        SecurityUtils.displayNoAccess(player);
                    }
                }
                return ActionResultType.SUCCESS;
            }
            if (SecurityUtils.canAccess(player, tile)) {
                Optional<IConfigurable> capability = CapabilityUtils.getCapability(tile, Capabilities.CONFIGURABLE_CAPABILITY, side).resolve();
                if (capability.isPresent()) {
                    IConfigurable config = capability.get();
                    if (player.isShiftKeyDown()) {
                        return config.onSneakRightClick(player, side);
                    }
                    return config.onRightClick(player, side);
                }
            } else {
                SecurityUtils.displayNoAccess(player);
                return ActionResultType.SUCCESS;
            }
        } else if (mode == ConfiguratorMode.EMPTY) {
            // Empty
            if (tile instanceof IMekanismInventory) {
                IMekanismInventory inv = (IMekanismInventory) tile;
                if (inv.hasInventory()) {
                    if (SecurityUtils.canAccess(player, tile)) {
                        boolean creative = player.isCreative();
                        IEnergyContainer energyContainer = creative ? null : StorageUtils.getEnergyContainer(stack, 0);
                        if (!creative && energyContainer == null) {
                            return ActionResultType.FAIL;
                        }
                        // TODO: Switch this to items being handled by TileEntityMekanism, energy handled here (via lambdas?)
                        FloatingLong energyPerItemDump = MekanismConfig.gear.configuratorEnergyPerItem.get();
                        for (IInventorySlot inventorySlot : inv.getInventorySlots(null)) {
                            if (!inventorySlot.isEmpty()) {
                                if (!creative) {
                                    if (energyContainer.extract(energyPerItemDump, Action.SIMULATE, AutomationType.MANUAL).smallerThan(energyPerItemDump)) {
                                        break;
                                    }
                                    energyContainer.extract(energyPerItemDump, Action.EXECUTE, AutomationType.MANUAL);
                                }
                                Block.popResource(world, pos, inventorySlot.getStack().copy());
                                inventorySlot.setEmpty();
                            }
                        }
                        return ActionResultType.SUCCESS;
                    } else {
                        SecurityUtils.displayNoAccess(player);
                        return ActionResultType.FAIL;
                    }
                }
            }
        } else if (mode == ConfiguratorMode.ROTATE) {
            // Rotate
            if (tile instanceof TileEntityMekanism) {
                if (SecurityUtils.canAccess(player, tile)) {
                    TileEntityMekanism tileMekanism = (TileEntityMekanism) tile;
                    if (Attribute.get(tileMekanism.getBlockType(), AttributeStateFacing.class).canRotate()) {
                        if (!player.isShiftKeyDown()) {
                            tileMekanism.setFacing(side);
                        } else if (player.isShiftKeyDown()) {
                            tileMekanism.setFacing(side.getOpposite());
                        }
                    }
                } else {
                    SecurityUtils.displayNoAccess(player);
                }
            }
            return ActionResultType.SUCCESS;
        } else if (mode == ConfiguratorMode.WRENCH) {
            // Wrench
            return ActionResultType.PASS;
        }
    }
    return ActionResultType.PASS;
}