@Override
public ActionResult useOnBlock(ItemUsageContext context) {
	PlayerEntity player = context.getPlayer();
	if (context.getWorld().isClient) return ActionResult.PASS;
	BlockState state = context.getWorld().getBlockState(context.getBlockPos());
	if(state.getBlock() == HallowedBlocks.HALLOWED_GATE) {
		if (context.getWorld().getDimension().getType() == DimensionType.OVERWORLD) {
			if (HallowedGateBlock.isValid(context.getWorld(), context.getBlockPos(), state)) {
				BlockPos pos = player.getBlockPos();
				CompoundTag tag = new CompoundTag();
				tag.putInt("x", pos.getX());
				tag.putInt("y", pos.getY());
				tag.putInt("z", pos.getZ());
				context.getStack().putSubTag("PortalLoc", tag);
				FabricDimensions.teleport(player, HallowedDimensions.THE_HALLOW);
				return ActionResult.SUCCESS;
			} else {
				player.addChatMessage(new TranslatableText("text.thehallow.gate_incomplete"), true);
			}
		} else {
			player.addChatMessage(new TranslatableText("text.thehallow.gate_in_wrong_dimension"), true);
		}
	}
	return ActionResult.PASS;
}
 

@Override
public void onDimensionChange(ServerPlayerEntity player, Vec3d from, Vec3d to, DimensionType fromDim, DimensionType dimTo)
{
    // eligibility already checked in mixin
    Value fromValue = ListValue.fromTriple(from.x, from.y, from.z);
    Value toValue = (to == null)?Value.NULL:ListValue.fromTriple(to.x, to.y, to.z);
    Value fromDimStr = new StringValue(NBTSerializableValue.nameFromRegistryId(Registry.DIMENSION_TYPE.getId(fromDim)));
    Value toDimStr = new StringValue(NBTSerializableValue.nameFromRegistryId(Registry.DIMENSION_TYPE.getId(dimTo)));

    handler.call( () -> Arrays.asList(
            ((c, t) -> new EntityValue(player)),
            ((c, t) -> fromValue),
            ((c, t) -> fromDimStr),
            ((c, t) -> toValue),
            ((c, t) -> toDimStr)
    ), player::getCommandSource);
}
 

@Override public Integer validate(ServerCommandSource source, ParsedRule<Integer> currentRule, Integer newValue, String string) {
    if (source == null) return newValue;
    if (newValue < 0 || newValue > 32)
    {
        Messenger.m(source, "r spawn chunk size has to be between 0 and 32");
        return null;
    }
    if (currentRule.get().intValue() == newValue.intValue())
    {
        //must been some startup thing
        return newValue;
    }
    if (CarpetServer.minecraft_server == null) return newValue;
    ServerWorld currentOverworld = CarpetServer.minecraft_server.getWorld(DimensionType.OVERWORLD);
    if (currentOverworld != null)
    {
        changeSpawnSize(newValue);
    }
    return newValue;
}
 

public static void registerSpawn(DimensionType dim, MobEntity mob, EntityCategory cat, BlockPos pos)
{
    if (lower_spawning_limit != null)
    {
        if (!( (lower_spawning_limit.getX() <= pos.getX() && pos.getX() <= upper_spawning_limit.getX()) &&
             (lower_spawning_limit.getY() <= pos.getY() && pos.getY() <= upper_spawning_limit.getY()) && 
             (lower_spawning_limit.getZ() <= pos.getZ() && pos.getZ() <= upper_spawning_limit.getZ())
           ))
        {
            return;
        }
    }
    Pair<DimensionType, EntityCategory> key = Pair.of(mob.dimension, cat);
    long count = spawn_stats.get(key).getOrDefault(mob.getType(), 0L);
    spawn_stats.get(key).put(mob.getType(), count + 1);
    spawned_mobs.get(key).put(Pair.of(mob.getType(), pos));
    local_spawns.put(cat, local_spawns.get(cat)+1);
}
 

private static Identifier dimensionIdToName(int dimensionId) {
    switch (dimensionId) {
        case -1:
            return DimensionType.THE_NETHER_REGISTRY_KEY.getValue();
        case 1:
            return DimensionType.THE_END_REGISTRY_KEY.getValue();
        case 0:
        default:
            return DimensionType.OVERWORLD_REGISTRY_KEY.getValue();
    }
}
 

/**
 * A target point that excludes the provided player entity.
 */
public TargetPoint(final ServerPlayerEntity excluded, final double x, final double y, final double z, final double radius, final DimensionType dim) {
	this.excluded = excluded;
	this.x = x;
	this.y = y;
	this.z = z;
	this.radius = radius;
	this.dim = dim;
}
 

/**
 * A target point that does not exclude any entities.
 */
public TargetPoint(final double x, final double y, final double z, final double radius, final DimensionType dim) {
	this.excluded = null;
	this.x = x;
	this.y = y;
	this.z = z;
	this.radius = radius;
	this.dim = dim;
}
 

@Redirect(method = "createWorlds", at = @At(value = "INVOKE", target = "java/util/Iterator.next ()Ljava/lang/Object;"))
private Object proxyNextWorldToSpecialCaseOverworld(Iterator<DimensionType> iterator) {
	DimensionType type = iterator.next();

	if (type == DimensionType.OVERWORLD) {
		WorldEvents.onWorldLoad(this.worlds.get(type));
	}

	return type;
}
 

public void add(MinecraftServer server, ItemStack stack)
{
    if (startTick == 0)
    {
        startTick = server.getWorld(DimensionType.OVERWORLD).getTime();
        startMillis = System.currentTimeMillis();
    }
    Item item = stack.getItem();
    counter.put(item, counter.getLong(item) + stack.getCount());
    // pubSubProvider.publish();
}
 

public void reset(MinecraftServer server)
{
    counter.clear();
    startTick = server.getWorld(DimensionType.OVERWORLD).getTime();
    startMillis = System.currentTimeMillis();
    // pubSubProvider.publish();
}
 

@Override
public void onTick()
{
    handler.call(Collections::emptyList, () ->
            CarpetServer.minecraft_server.getCommandSource().
                    withWorld(CarpetServer.minecraft_server.getWorld(DimensionType.OVERWORLD))
    );
}
 

@Override
public void onTick()
{
    handler.call(Collections::emptyList, () ->
            CarpetServer.minecraft_server.getCommandSource().
                    withWorld(CarpetServer.minecraft_server.getWorld(DimensionType.THE_NETHER))
    );
}
 

@Override
public void onTick()
{
    handler.call(Collections::emptyList, () ->
            CarpetServer.minecraft_server.getCommandSource().
                    withWorld(CarpetServer.minecraft_server.getWorld(DimensionType.THE_END))
    );
}
 

@Override
public Value validate(Map<String, Value> options, CarpetContext cc, Value value)
{
    String dimStr = value.getString();
    Optional<DimensionType> dimOp = Registry.DIMENSION_TYPE.getOrEmpty(new Identifier(dimStr));
    if (!dimOp.isPresent()) throw new InternalExpressionException("Unknown dimension "+dimStr);
    return value;
}
 

public void addShape(CompoundTag tag)
{
    ShapeDispatcher.ExpiringShape shape = ShapeDispatcher.fromTag(tag);
    if (shape == null) return;
    BiFunction<MinecraftClient, ShapeDispatcher.ExpiringShape, RenderedShape<? extends ShapeDispatcher.ExpiringShape >> shapeFactory;
    shapeFactory = renderedShapes.get(tag.getString("shape"));
    if (shapeFactory == null)
    {
        CarpetSettings.LOG.info("Unrecognized shape: "+tag.getString("shape"));
    }
    else
    {
        RenderedShape<?> rshape = shapeFactory.apply(client, shape);
        DimensionType dim = shape.shapeDimension;
        long key = rshape.key();
        synchronized (shapes)
        {
            RenderedShape<?> existing = shapes.computeIfAbsent(dim, d -> new Long2ObjectOpenHashMap<>()).get(key);
            if (existing != null)
            {   // promoting previous shape
                existing.expiryTick = rshape.expiryTick;
            }
            else
            {
                shapes.get(dim).put(key, rshape);
            }
        }
    }
}
 

public boolean shouldRender(DimensionType dim)
{
    if (shape.followEntity <=0 ) return true;
    if (client.world == null) return false;
    if (client.world.getEntityById(shape.followEntity) == null) return false;
    return true;
}
 

public static void changeSpawnSize(int size)
{
    ServerWorld overworld = CarpetServer.minecraft_server.getWorld(DimensionType.OVERWORLD);
    if (overworld != null) {
        ChunkPos centerChunk = new ChunkPos(new BlockPos(
                overworld.getLevelProperties().getSpawnX(),
                overworld.getLevelProperties().getSpawnY(),
                overworld.getLevelProperties().getSpawnZ()
        ));
        SpawnChunks.changeSpawnChunks(overworld.getChunkManager(), centerChunk, size);
    }
}
 

public static void reset_spawn_stats(boolean full)
{

    spawn_stats.clear();
    spawned_mobs.clear();
    for (EntityCategory enumcreaturetype : EntityCategory.values())
    {
        if (full)
        {
            spawn_tries.put(enumcreaturetype, 1);
        }
        for (DimensionType dim : DimensionType.getAll())
        {
            Pair<DimensionType, EntityCategory> key = Pair.of(dim, enumcreaturetype);
            overall_spawn_ticks.put(key, 0L);
            spawn_attempts.put(key, 0L);
            spawn_ticks_full.put(key, 0L);
            spawn_ticks_fail.put(key, 0L);
            spawn_ticks_succ.put(key, 0L);
            spawn_ticks_spawns.put(key, 0L);
            spawn_cap_count.put(key, 0L);
            spawn_stats.put(key, new Object2LongOpenHashMap<>());
            spawned_mobs.put(key, new EvictingQueue<>());
        }
    }
    track_spawns = 0L;
}
 

@Inject(method = "changeDimension", at = @At(
        value = "INVOKE",
        target = "Lnet/minecraft/entity/Entity;getLastNetherPortalDirection()Lnet/minecraft/util/math/Direction;"
))
private void registerEntityDimensionChange(DimensionType newDimension, CallbackInfoReturnable<Entity> cir)
{
    if (CarpetSettings.portalSuffocationFix)
    {
        CarpetSettings.currentTelepotingEntityBox = getBoundingBox();
        CarpetSettings.fixedPosition = null;
    }
}
 

@Inject(method = "changeDimension", at = @At("RETURN"))
private void atChangeDimension(DimensionType newDimension, CallbackInfoReturnable<Entity> cir)
{
    if (PLAYER_CHANGES_DIMENSION.isNeeded())
    {
        ServerPlayerEntity player = (ServerPlayerEntity) (Object)this;
        Vec3d to = null;
        if (!notInAnyWorld || previousDimension != DimensionType.THE_END || newDimension != DimensionType.OVERWORLD)
        {
            to = getPos();
        }
        PLAYER_CHANGES_DIMENSION.onDimensionChange(player, previousLocation, to, previousDimension, newDimension);
    }
}
 

private LegacyStructureDataUtil getLegacyStructureDataUtil() {
    if (this.legacyStructureDataUtil == null) {
        File dataFolder = new File(DimensionType.OVERWORLD.getDirectory(this.saveHandler.getWorldDirectory()), "data");
        this.legacyStructureDataUtil = LegacyStructureDataUtil.func_215130_a(dimensionId.getDimensionType(),
                new DimensionSavedDataManager(dataFolder, this.saveHandler.getFixer()));
    }
    return this.legacyStructureDataUtil;
}
 

private static DimensionId getDimensionId(PayloadReader reader, String name) {
    if (name.equals(NAME)) return reader.readDimensionId();

    int dimensionRawId = reader.readVarInt();
    DimensionType dimensionType = DimensionType.getById(dimensionRawId);
    return DimensionId.from(dimensionType);
}
 

private Consumer<Packet<?>> playerListDimConsumer(final Supplier<DimensionType> dimensionType) {
	return packet -> getServer().getPlayerManager().sendToDimension(packet, dimensionType.get());
}
 

/**
 * Helper to build a target point that does not exclude any entities.
 */
public static Supplier<TargetPoint> p(double x, double y, double z, double radius, DimensionType dim) {
	TargetPoint point = new TargetPoint(x, y, z, radius, dim);
	return () -> point;
}
 

protected MixinServerWorld(LevelProperties levelProperties, DimensionType dimensionType, BiFunction<World, Dimension, ChunkManager> chunkManagerProvider, Profiler profiler, boolean isClient) {
	super(levelProperties, dimensionType, chunkManagerProvider, profiler, isClient);
}
 

protected MixinClientWorld(LevelProperties levelProperties, DimensionType dimensionType, BiFunction<World, Dimension, ChunkManager> chunkManagerProvider, Profiler profiler, boolean isClient) {
	super(levelProperties, dimensionType, chunkManagerProvider, profiler, isClient);
}
 

@Shadow
public abstract ServerWorld getWorld(DimensionType dimensionType_1);
 

public World sbx$getWorld(Identity identity) {
    return (World) getWorld(DimensionType.byId(WrappingUtil.convert(identity)));
}
 

public void addCoords() {
	boolean nether = Minecraft.getInstance().player.dimension == DimensionType.THE_NETHER;
	BlockPos pos = Minecraft.getInstance().player.getPosition();
			
	bottomLeftList.add("XYZ: " + (nether ? "�4" : "�b") + pos.getX() + " " + pos.getY() + " " + pos.getZ());
}
 

public List<BaseText> format(MinecraftServer server, boolean realTime, boolean brief)
{
    if (counter.isEmpty())
    {
        if (brief)
        {
            return Collections.singletonList(Messenger.c("g "+color+": -, -/h, - min "));
        }
        return Collections.singletonList(Messenger.s(String.format("No items for %s yet", color.getName())));
    }
    long total = getTotalItems();
    long ticks = Math.max(realTime ? (System.currentTimeMillis() - startMillis) / 50 : server.getWorld(DimensionType.OVERWORLD).getTime() - startTick, 1);
    if (total == 0)
    {
        if (brief)
        {
            return Collections.singletonList(Messenger.c(String.format("c %s: 0, 0/h, %.1f min ", color, ticks / (20.0 * 60.0))));
        }
        return Collections.singletonList(Messenger.c(String.format("w No items for %s yet (%.2f min.%s)",
                color.getName(), ticks / (20.0 * 60.0), (realTime ? " - real time" : "")),
                "nb  [X]", "^g reset", "!/counter " + color.getName() +" reset"));
    }
    if (brief)
    {
        return Collections.singletonList(Messenger.c(String.format("c %s: %d, %d/h, %.1f min ",
                color.getName(), total, total * (20 * 60 * 60) / ticks, ticks / (20.0 * 60.0))));
    }
    List<BaseText> items = new ArrayList<>();
    items.add(Messenger.c(String.format("w Items for %s (%.2f min.%s), total: %d, (%.1f/h):",
            color, ticks*1.0/(20*60), (realTime?" - real time":""), total, total*1.0*(20*60*60)/ticks),
            "nb [X]", "^g reset", "!/counter "+color+" reset"
    ));
    items.addAll(counter.object2LongEntrySet().stream().sorted((e, f) -> Long.compare(f.getLongValue(), e.getLongValue())).map(e ->
    {
        BaseText itemName = new TranslatableText(e.getKey().getTranslationKey());
        long count = e.getLongValue();
        return Messenger.c("w - ", itemName, String.format("w : %d, %.1f/h",
                count,
                count * (20.0 * 60.0 * 60.0) / ticks));
    }).collect(Collectors.toList()));
    return items;
}