Java Code Examples for org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable#getReturnValue()

@Inject(method = "loadChunkFromPacket", at = @At("RETURN"))
private void onLoadChunkFromPacket(int x, int z, BiomeArray biomes, PacketByteBuf buf, CompoundTag heightmaps, int verticalStripBitmask, boolean bl, CallbackInfoReturnable<WorldChunk> ci) {
    if (ConnectionInfo.protocolVersion <= Protocols.V1_12_2) {
        if (ci.getReturnValue() != null) {
            synchronized (LOCK) {
                UpgradeData upgradeData = ChunkUpgrader.fixChunk(ci.getReturnValue());
                ((IUpgradableChunk) ci.getReturnValue()).multiconnect_setClientUpgradeData(upgradeData);
                for (int dx = -1; dx <= 1; dx++) {
                    for (int dz = -1; dz <= 1; dz++) {
                        WorldChunk chunk = getChunk(x + dx, z + dz, ChunkStatus.FULL, false);
                        if (chunk != null)
                            ((IUpgradableChunk) chunk).multiconnect_onNeighborLoaded();
                    }
                }
            }
        }
    }
}
 

@Inject(method = "build", at = @At("RETURN"))
private void onBuildReturn(String id, CallbackInfoReturnable<EntityType> cir) {
	PatchworkEntityTypeExtensions type = (PatchworkEntityTypeExtensions) cir.getReturnValue();

	if (updateInterval != null) {
		type.patchwork$setUpdateInterval(updateInterval);
	}

	if (trackingRange != null) {
		type.patchwork$setTrackingRange(trackingRange);
	}

	if (shouldRecieveVelocityUpdates != null) {
		type.patchwork$setShouldReceiveVelocityUpdates(shouldRecieveVelocityUpdates);
	}
}
 

@SuppressWarnings("RedundantSuppression")
@Inject(method = "getName", at = @At("RETURN"), cancellable = true)
private void getName(CallbackInfoReturnable<Text> returnable) {
    Identifier id = Registry.ITEM.getId(getItem());
    //noinspection ConstantConditions,PointlessBooleanExpression
    if (false && id.getNamespace().equals(Constants.MOD_ID)) {
        Text returnVal = returnable.getReturnValue();
        if (returnVal.getStyle().getColor() == null) {
            returnable.setReturnValue(returnVal.shallowCopy().setStyle(returnVal.getStyle().withColor(Formatting.BLUE)));
        }
    }
}
 

@Inject(at = @At("RETURN"), method = "getViewDistance()F", cancellable = true)
private void getHallowViewDistance(final CallbackInfoReturnable<Float> info) {
	final MinecraftClient client = MinecraftClient.getInstance();
	final World world = client.world;
	
	if (world.getDimension().getType() == HallowedDimensions.THE_HALLOW) {
		final PlayerEntity player = client.player;
		float totalIntensity = 0;
		int count = 0;
		final int radius = HallowedConfig.HallowedFog.fogSmoothingRadius;
		for (int x = 0; x < radius; x++) {
			for (int z = 0; z < radius; z++) {
				final BlockPos pos = player.getBlockPos().add(x - (radius / 2), 0, z - (radius / 2));
				
				if (world.getBiomeAccess().getBiome(pos) instanceof HallowedBiomeInfo) {
					final HallowedBiomeInfo biomeInfo = (HallowedBiomeInfo) world.getBiomeAccess().getBiome(pos);
					totalIntensity += biomeInfo.getFogIntensity();
					count++;
				}
			}
		}
		
		final float distance = totalIntensity / count;
		if(distance < info.getReturnValue())
		{
			info.setReturnValue(distance);
		}
	}
}
 

@Inject(method = "loadChunkFromPacket", at = @At("RETURN"))
private void onLoadChunkFromPacket(int x, int z, BiomeArray biomeArray, PacketByteBuf buf, CompoundTag heightmaps, int verticalStripMask, boolean bl, CallbackInfoReturnable<WorldChunk> ci) {
    if (ConnectionInfo.protocolVersion <= Protocols.V1_14_4) {
        if (ci.getReturnValue() != null) {
            Biome[] biomeData = PendingBiomeData.getPendingBiomeData(x, z);
            if (biomeData != null) {
                ((IBiomeStorage_1_14_4) ci.getReturnValue()).multiconnect_setBiomeArray_1_14_4(biomeData);
                PendingBiomeData.setPendingBiomeData(x, z, null);
            }
        }
    }
}
 

@SuppressWarnings("unchecked")
@Inject(method = "build", at = @At("RETURN"))
private void onBuildReturn(String id, CallbackInfoReturnable<EntityType<T>> callback) {
	ClientEntitySpawner<T> spawner = (ClientEntitySpawner<T>) callback.getReturnValue();

	spawner.patchwork$setCustomClientFactory(this.customClientFactory);
}
 

@Inject(method = "getPlayerRelativeBlockHardness", at = @At("RETURN"), cancellable = true)
public void modifyBreakSpeed(EntityPlayer playerIn, World worldIn, BlockPos pos, final CallbackInfoReturnable<Float> callbackInfo) {
    float f = callbackInfo.getReturnValue();

    // NoSlowBreak
    final NoSlowBreak noSlowBreak = (NoSlowBreak) LiquidBounce.moduleManager.getModule(NoSlowBreak.class);
    if (noSlowBreak.getState()) {
        if (noSlowBreak.getWaterValue().get() && playerIn.isInsideOfMaterial(Material.water) &&
                !EnchantmentHelper.getAquaAffinityModifier(playerIn)) {
            f *= 5.0F;
        }

        if (noSlowBreak.getAirValue().get() && !playerIn.onGround) {
            f *= 5.0F;
        }
    } else if (playerIn.onGround) { // NoGround
        final NoFall noFall = (NoFall) LiquidBounce.moduleManager.getModule(NoFall.class);
        final Criticals criticals = (Criticals) LiquidBounce.moduleManager.getModule(Criticals.class);

        if (noFall.getState() && noFall.modeValue.get().equalsIgnoreCase("NoGround") ||
                criticals.getState() && criticals.getModeValue().get().equalsIgnoreCase("NoGround")) {
            f /= 5F;
        }
    }

    callbackInfo.setReturnValue(f);
}
 

@Inject(method = "getPlayerRelativeBlockHardness", at = @At("RETURN"), cancellable = true)
public void modifyBreakSpeed(EntityPlayer playerIn, World worldIn, BlockPos pos, final CallbackInfoReturnable<Float> callbackInfo) {
    float f = callbackInfo.getReturnValue();

    // NoSlowBreak
    final NoSlowBreak noSlowBreak = (NoSlowBreak) LiquidBounce.moduleManager.getModule(NoSlowBreak.class);
    if (noSlowBreak.getState()) {
        if (noSlowBreak.getWaterValue().get() && playerIn.isInsideOfMaterial(Material.water) &&
                !EnchantmentHelper.getAquaAffinityModifier(playerIn)) {
            f *= 5.0F;
        }

        if (noSlowBreak.getAirValue().get() && !playerIn.onGround) {
            f *= 5.0F;
        }
    } else if (playerIn.onGround) { // NoGround
        final NoFall noFall = (NoFall) LiquidBounce.moduleManager.getModule(NoFall.class);
        final Criticals criticals = (Criticals) LiquidBounce.moduleManager.getModule(Criticals.class);

        if (noFall.getState() && noFall.modeValue.get().equalsIgnoreCase("NoGround") ||
                criticals.getState() && criticals.getModeValue().get().equalsIgnoreCase("NoGround")) {
            f /= 5F;
        }
    }

    callbackInfo.setReturnValue(f);
}
 

@Inject(method = "getLocationCape", at = @At("HEAD"), cancellable = true)
private void getLocationCape(CallbackInfoReturnable<ResourceLocation> locationCallbackInfoReturnable) {
    NickHider instance = NickHider.instance;
    if (locationCallbackInfoReturnable.getReturnValue() != null) return;

    if (instance != null && instance.getNickHiderConfig().isHideSkins() && instance.getNickHiderConfig().isMasterEnabled()) {
        NickHiderConfig config = instance.getNickHiderConfig();

        if (getUniqueID().equals(Minecraft.getMinecraft().thePlayer.getUniqueID()) && config.isUseRealSkinForSelf()) {
            locationCallbackInfoReturnable.setReturnValue(instance.getPlayerCape());
        }
    }
}
 

@Inject(method = "getLocationCape", at = @At("RETURN"), cancellable = true)
private void getLocationCape(CallbackInfoReturnable<ResourceLocation> cir) {
    NickHider instance = NickHider.instance;

    if (cir.getReturnValue() != null) return;

    if (instance != null && instance.getNickHiderConfig().isHideSkins() && instance.getNickHiderConfig().isMasterEnabled()) {
        NickHiderConfig config = instance.getNickHiderConfig();

        if (gameProfile.getId().equals(Minecraft.getMinecraft().thePlayer.getUniqueID()) && config.isUseRealSkinForSelf()) {
            cir.setReturnValue(instance.getPlayerCape());
        }
    }
}
 

/**
 * Fix mods using duplicate property names.
 */
@Inject(method = "equals", at = @At("RETURN"), cancellable = true)
public void overrideEquals(Object obj, CallbackInfoReturnable<Boolean> cir) {
    if (cir.getReturnValue() && obj instanceof PropertyHelper) {
        if (!getClass().getName().startsWith("net.minecraft") && !getAllowedValues().equals(((PropertyHelper<?>) obj).getAllowedValues())) {
            cir.setReturnValue(false);
        }
    }
}
 

@Inject(method = "get", at = @At("RETURN"), cancellable = true)
private void onGet(int id, CallbackInfoReturnable<T> ci) {
    if (ci.getReturnValue() == null) {
        ci.setReturnValue(highIdsMap.get(id));
    }
}
 

@Inject(method = "getReadBuffer", at = @At("RETURN"), cancellable = true)
private void onGetReadBuffer(CallbackInfoReturnable<PacketByteBuf> ci) {
    TransformerByteBuf transformerByteBuf = new TransformerByteBuf(ci.getReturnValue(), null);
    transformerByteBuf.readTopLevelType(ChunkData.class);
    ci.setReturnValue(transformerByteBuf);
}
 

public void getFormattedTextReturn(CallbackInfoReturnable<String> string) {
    cache = string.getReturnValue();
}
 

@Inject(method = "dropItem", at = @At("RETURN"))
private void itemDrop(ItemStack droppedItem, boolean dropAround, boolean traceItem, CallbackInfoReturnable<EntityItem> cir) {
    if (cir.getReturnValue() == null) return;

    new ItemTossEvent((EntityPlayer) (Object) this, cir.getReturnValue()).post();
}
 

@Inject(method = "getTooltip", at = @At("RETURN"))
private void injectTooltip(EntityPlayer playerIn, boolean advanced, CallbackInfoReturnable<List<String>> cir) {
    if (cir.getReturnValue() == null) return;

    new ItemTooltipEvent((ItemStack) (Object) this, cir.getReturnValue());
}