imports/architectury-api
1
0
Fork 0
mirror of https://github.com/architectury/architectury-api.git synced 2026-04-02 05:27:42 -05:00
Code Issues Packages Projects Releases Wiki Activity

[ci skip] Port to NeoForge 24w14a

Browse Source 
Signed-off-by: shedaniel <daniel@shedaniel.me>
This commit is contained in:
shedaniel
2024-04-09 18:16:18 +09:00
parent d19cb9a8f1
commit 4e15fa3bbb
88 changed files with 5191 additions and 569 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
fabric/src/main/java/dev/architectury/event/fabric/EventHandlerImpl.java
View File

@@ -38,7 +38,7 @@ import net.fabricmc.fabric.api.event.player.AttackBlockCallback;
import net.fabricmc.fabric.api.event.player.AttackEntityCallback;
import net.fabricmc.fabric.api.event.player.UseBlockCallback;
import net.fabricmc.fabric.api.event.player.UseItemCallback;
// import net.fabricmc.fabric.api.loot.v2.LootTableEvents;
import net.fabricmc.fabric.api.loot.v2.LootTableEvents;
import net.fabricmc.fabric.api.message.v1.ServerMessageDecoratorEvent;
import net.fabricmc.fabric.api.message.v1.ServerMessageEvents;
@@ -83,7 +83,7 @@ public class EventHandlerImpl {
AttackBlockCallback.EVENT.register((player, world, hand, pos, face) -> InteractionEvent.LEFT_CLICK_BLOCK.invoker().click(player, hand, pos, face).asMinecraft());
AttackEntityCallback.EVENT.register((player, world, hand, entity, hitResult) -> PlayerEvent.ATTACK_ENTITY.invoker().attack(player, world, entity, hand, hitResult).asMinecraft());
// LootTableEvents.MODIFY.register((key, tableBuilder, source) -> LootEvent.MODIFY_LOOT_TABLE.invoker().modifyLootTable(lootManager, id, new LootTableModificationContextImpl(tableBuilder), source.isBuiltin()));
LootTableEvents.MODIFY.register((key, tableBuilder, source) -> LootEvent.MODIFY_LOOT_TABLE.invoker().modifyLootTable(key, new LootTableModificationContextImpl(tableBuilder), source.isBuiltin()));
ServerMessageDecoratorEvent.EVENT.register(ServerMessageDecoratorEvent.CONTENT_PHASE, (player, component) -> {
ChatEvent.ChatComponent chatComponent = new ChatComponentImpl(component);

87
fabric/src/main/java/dev/architectury/fluid/fabric/FluidStackImpl.java
View File

@@ -25,24 +25,28 @@ import com.mojang.serialization.codecs.RecordCodecBuilder;
import dev.architectury.fluid.FluidStack;
import io.netty.buffer.ByteBuf;
import net.fabricmc.fabric.api.transfer.v1.fluid.FluidVariant;
import net.minecraft.core.component.DataComponentMap;
import net.minecraft.core.component.DataComponentPatch;
import net.minecraft.core.component.DataComponentType;
import net.minecraft.core.component.PatchedDataComponentMap;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.core.registries.Registries;
import net.minecraft.network.RegistryFriendlyByteBuf;
import net.minecraft.network.codec.ByteBufCodecs;
import net.minecraft.network.codec.StreamCodec;
import net.minecraft.util.ExtraCodecs;
import net.minecraft.world.level.material.FlowingFluid;
import net.minecraft.world.level.material.Fluid;
import net.minecraft.world.level.material.Fluids;
import org.jetbrains.annotations.ApiStatus;
import org.jetbrains.annotations.Nullable;
import java.util.Objects;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.function.UnaryOperator;
@ApiStatus.Internal
@SuppressWarnings("UnstableApiUsage")
public enum FluidStackImpl implements FluidStack.FluidStackAdapter<FluidStackImpl.Pair> {
INSTANCE;
@@ -60,13 +64,30 @@ public enum FluidStackImpl implements FluidStack.FluidStackAdapter<FluidStackImp
}
public static class Pair {
public FluidVariant variant;
public Fluid fluid;
public PatchedDataComponentMap components;
public long amount;
public Pair(FluidVariant variant, long amount) {
this.variant = variant;
public Pair(Fluid fluid, @Nullable DataComponentPatch patch, long amount) {
this(fluid,
patch == null ? new PatchedDataComponentMap(DataComponentMap.EMPTY)
: PatchedDataComponentMap.fromPatch(DataComponentMap.EMPTY, patch),
amount);
}
public Pair(Fluid fluid, PatchedDataComponentMap components, long amount) {
this.fluid = fluid;
this.components = components;
this.amount = amount;
}
public FluidVariant toVariant() {
return FluidVariant.of(fluid, getPatch());
}
public DataComponentPatch getPatch() {
return amount <= 0L || this.fluid == Fluids.EMPTY ? components.asPatch() : DataComponentPatch.EMPTY;
}
}
@Override
@@ -75,17 +96,17 @@ public enum FluidStackImpl implements FluidStack.FluidStackAdapter<FluidStackImp
if (fluidType instanceof FlowingFluid flowingFluid) {
fluidType = flowingFluid.getSource();
}
return new Pair(FluidVariant.of(fluidType, patch == null ? DataComponentPatch.EMPTY : patch), amount);
return new Pair(fluidType, patch, amount);
}
@Override
public Supplier<Fluid> getRawFluidSupplier(FluidStackImpl.Pair object) {
return () -> object.variant.getFluid();
return () -> object.fluid;
}
@Override
public Fluid getFluid(FluidStackImpl.Pair object) {
return object.variant.getFluid();
return object.fluid;
}
@Override
@@ -99,28 +120,60 @@ public enum FluidStackImpl implements FluidStack.FluidStackAdapter<FluidStackImp
}
public DataComponentPatch getPatch(FluidStackImpl.Pair value) {
return value.variant.getComponents();
return value.getPatch();
}
@Override
public void setPatch(FluidStackImpl.Pair value, DataComponentPatch patch) {
value.variant = FluidVariant.of(value.variant.getFluid(), patch);
public PatchedDataComponentMap getComponents(Pair value) {
return value.components;
}
@Override
public void applyComponents(Pair value, DataComponentPatch patch) {
value.components.applyPatch(patch);
}
@Override
public void applyComponents(Pair value, DataComponentMap patch) {
value.components.setAll(patch);
}
@Override
@Nullable
public <D> D set(Pair value, DataComponentType<? super D> type, @Nullable D component) {
return value.components.set(type, component);
}
@Override
@Nullable
public <D> D remove(Pair value, DataComponentType<? extends D> type) {
return value.components.remove(type);
}
@Override
@Nullable
public <D> D update(Pair value, DataComponentType<D> type, D component, UnaryOperator<D> updater) {
return value.components.set(type, updater.apply(getComponents(value).getOrDefault(type, component)));
}
@Override
@Nullable
public <D, U> D update(Pair value, DataComponentType<D> type, D component, U updateContext, BiFunction<D, U, D> updater) {
return value.components.set(type, updater.apply(getComponents(value).getOrDefault(type, component), updateContext));
}
@Override
public FluidStackImpl.Pair copy(FluidStackImpl.Pair value) {
return new Pair(value.variant, value.amount);
return new Pair(value.fluid, value.components.copy(), value.amount);
}
@Override
public int hashCode(FluidStackImpl.Pair value) {
var pair = (Pair) value;
var code = 1;
code = 31 * code + pair.variant.hashCode();
code = 31 * code + pair.fluid.hashCode();
code = 31 * code + Long.hashCode(pair.amount);
var patch = pair.variant.getComponents();
if (patch != null)
code = 31 * code + patch.hashCode();
code = 31 * code + pair.components.hashCode();
return code;
}
@@ -133,7 +186,7 @@ public enum FluidStackImpl implements FluidStack.FluidStackAdapter<FluidStackImp
? DataResult.success(value)
: DataResult.error(() -> "Value must be non-negative: " + value);
}).fieldOf("amount").forGetter(FluidStack::getAmount),
DataComponentPatch.CODEC.fieldOf("components").forGetter(FluidStack::getPatch)
DataComponentPatch.CODEC.optionalFieldOf("components", DataComponentPatch.EMPTY).forGetter(FluidStack::getPatch)
).apply(instance, FluidStack::create));
}

5
fabric/src/main/java/dev/architectury/hooks/fluid/fabric/FluidStackHooksFabric.java
View File

@@ -24,7 +24,6 @@ import dev.architectury.fluid.fabric.FluidStackImpl;
import net.fabricmc.fabric.api.transfer.v1.fluid.FluidVariant;
import net.fabricmc.fabric.api.transfer.v1.storage.StorageView;
@SuppressWarnings("UnstableApiUsage")
public final class FluidStackHooksFabric {
private FluidStackHooksFabric() {
}
@@ -34,10 +33,10 @@ public final class FluidStackHooksFabric {
}
public static FluidStack fromFabric(FluidVariant variant, long amount) {
return FluidStackImpl.fromValue.apply(new FluidStackImpl.Pair(variant, amount));
return FluidStackImpl.fromValue.apply(new FluidStackImpl.Pair(variant.getFluid(), variant.getComponents(), amount));
}
public static FluidVariant toFabric(FluidStack stack) {
return ((FluidStackImpl.Pair) FluidStackImpl.toValue.apply(stack)).variant;
return ((FluidStackImpl.Pair) FluidStackImpl.toValue.apply(stack)).toVariant();
}
}

154
fabric/src/main/java/dev/architectury/networking/fabric/NetworkManagerImpl.java
View File

@@ -20,20 +20,19 @@
package dev.architectury.networking.fabric;
import com.mojang.logging.LogUtils;
import dev.architectury.impl.NetworkAggregator;
import dev.architectury.networking.NetworkManager;
import dev.architectury.networking.NetworkManager.NetworkReceiver;
import dev.architectury.networking.SpawnEntityPacket;
import dev.architectury.networking.transformers.PacketSink;
import dev.architectury.networking.transformers.PacketTransformer;
import dev.architectury.utils.Env;
import io.netty.buffer.ByteBufUtil;
import io.netty.buffer.Unpooled;
import net.fabricmc.api.EnvType;
import net.fabricmc.api.Environment;
import net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking;
import net.fabricmc.fabric.api.networking.v1.PayloadTypeRegistry;
import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking;
import net.minecraft.network.FriendlyByteBuf;
import net.minecraft.core.RegistryAccess;
import net.minecraft.network.RegistryFriendlyByteBuf;
import net.minecraft.network.codec.StreamCodec;
import net.minecraft.network.protocol.Packet;
import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
import net.minecraft.network.protocol.game.ClientGamePacketListener;
@@ -44,79 +43,47 @@ import net.minecraft.world.entity.Entity;
import net.minecraft.world.entity.player.Player;
import org.slf4j.Logger;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
public class NetworkManagerImpl {
private static final Map<ResourceLocation, CustomPacketPayload.Type<BufCustomPacketPayload>> C2S_TYPE = new HashMap<>();
private static final Map<ResourceLocation, CustomPacketPayload.Type<BufCustomPacketPayload>> S2C_TYPE = new HashMap<>();
private static final Map<ResourceLocation, NetworkReceiver> C2S_RECEIVER = new HashMap<>();
private static final Map<ResourceLocation, NetworkReceiver> S2C_RECEIVER = new HashMap<>();
private static final Map<ResourceLocation, PacketTransformer> C2S_TRANSFORMERS = new HashMap<>();
private static final Map<ResourceLocation, PacketTransformer> S2C_TRANSFORMERS = new HashMap<>();
private static final Logger LOGGER = LogUtils.getLogger();
public static void registerReceiver(NetworkManager.Side side, ResourceLocation id, List<PacketTransformer> packetTransformers, NetworkReceiver receiver) {
Objects.requireNonNull(id, "Cannot register receiver with a null ID!");
packetTransformers = Objects.requireNonNullElse(packetTransformers, List.of());
Objects.requireNonNull(receiver, "Cannot register a null receiver!");
if (side == NetworkManager.Side.C2S) {
registerC2SReceiver(id, packetTransformers, receiver);
} else if (side == NetworkManager.Side.S2C) {
registerS2CReceiver(id, packetTransformers, receiver);
}
}
private static void registerC2SReceiver(ResourceLocation id, List<PacketTransformer> packetTransformers, NetworkReceiver receiver) {
LOGGER.info("Registering C2S receiver with id {}", id);
C2S_RECEIVER.put(id, receiver);
CustomPacketPayload.Type<BufCustomPacketPayload> type = new CustomPacketPayload.Type<>(id);
C2S_TYPE.put(id, type);
PayloadTypeRegistry.playC2S().register(type, BufCustomPacketPayload.streamCodec(type));
PacketTransformer transformer = PacketTransformer.concat(packetTransformers);
ServerPlayNetworking.registerGlobalReceiver(type, (payload, fabricContext) -> {
var context = context(fabricContext.player(), fabricContext.player().server, false);
FriendlyByteBuf buf = new FriendlyByteBuf(Unpooled.wrappedBuffer(payload.payload()));
transformer.inbound(NetworkManager.Side.C2S, id, buf, context, (side, id1, buf1) -> {
NetworkReceiver networkReceiver = side == NetworkManager.Side.C2S ? C2S_RECEIVER.get(id1) : S2C_RECEIVER.get(id1);
if (networkReceiver == null) {
throw new IllegalArgumentException("Network Receiver not found! " + id1);
}
networkReceiver.receive(buf1, context);
});
buf.release();
});
C2S_TRANSFORMERS.put(id, transformer);
}
@SuppressWarnings("Convert2Lambda")
@Environment(EnvType.CLIENT)
private static void registerS2CReceiver(ResourceLocation id, List<PacketTransformer> packetTransformers, NetworkReceiver receiver) {
LOGGER.info("Registering S2C receiver with id {}", id);
S2C_RECEIVER.put(id, receiver);
CustomPacketPayload.Type<BufCustomPacketPayload> type = new CustomPacketPayload.Type<>(id);
S2C_TYPE.put(id, type);
PayloadTypeRegistry.playS2C().register(type, BufCustomPacketPayload.streamCodec(type));
PacketTransformer transformer = PacketTransformer.concat(packetTransformers);
ClientPlayNetworking.registerGlobalReceiver(type, new ClientPlayNetworking.PlayPayloadHandler<>() {
public static NetworkAggregator.Adaptor getAdaptor() {
return new NetworkAggregator.Adaptor() {
@Override
public void receive(BufCustomPacketPayload payload, ClientPlayNetworking.Context fabricContext) {
var context = context(fabricContext.player(), fabricContext.client(), true);
FriendlyByteBuf buf = new FriendlyByteBuf(Unpooled.wrappedBuffer(payload.payload()));
transformer.inbound(NetworkManager.Side.S2C, id, buf, context, (side, id1, buf1) -> {
NetworkReceiver networkReceiver = side == NetworkManager.Side.C2S ? C2S_RECEIVER.get(id1) : S2C_RECEIVER.get(id1);
if (networkReceiver == null) {
throw new IllegalArgumentException("Network Receiver not found! " + id1);
}
networkReceiver.receive(buf1, context);
public <T extends CustomPacketPayload> void registerC2S(CustomPacketPayload.Type<T> type, StreamCodec<? super RegistryFriendlyByteBuf, T> codec, NetworkReceiver<T> receiver) {
LOGGER.info("Registering C2S receiver with id {}", type.id());
PayloadTypeRegistry.playC2S().register(type, codec);
ServerPlayNetworking.registerGlobalReceiver(type, (payload, fabricContext) -> {
var context = context(fabricContext.player(), fabricContext.player().server, false);
receiver.receive(payload, context);
});
buf.release();
}
});
S2C_TRANSFORMERS.put(id, transformer);
@Override
@Environment(EnvType.CLIENT)
public <T extends CustomPacketPayload> void registerS2C(CustomPacketPayload.Type<T> type, StreamCodec<? super RegistryFriendlyByteBuf, T> codec, NetworkReceiver<T> receiver) {
LOGGER.info("Registering S2C receiver with id {}", type.id());
PayloadTypeRegistry.playS2C().register(type, codec);
ClientPlayNetworking.registerGlobalReceiver(type, (payload, fabricContext) -> {
var context = context(fabricContext.player(), fabricContext.client(), true);
receiver.receive(payload, context);
});
}
@Override
public <T extends CustomPacketPayload> Packet<?> toC2SPacket(T payload) {
return ClientPlayNetworking.createC2SPacket(payload);
}
@Override
public <T extends CustomPacketPayload> Packet<?> toS2CPacket(T payload) {
return ServerPlayNetworking.createS2CPacket(payload);
}
@Override
public <T extends CustomPacketPayload> void registerS2CType(CustomPacketPayload.Type<T> type, StreamCodec<? super RegistryFriendlyByteBuf, T> codec) {
PayloadTypeRegistry.playS2C().register(type, codec);
}
};
}
private static NetworkManager.PacketContext context(Player player, BlockableEventLoop<?> taskQueue, boolean client) {
@@ -135,30 +102,14 @@ public class NetworkManagerImpl {
public Env getEnvironment() {
return client ? Env.CLIENT : Env.SERVER;
}
@Override
public RegistryAccess registryAccess() {
return player.registryAccess();
}
};
}
public static void collectPackets(PacketSink sink, NetworkManager.Side side, ResourceLocation id, FriendlyByteBuf buf) {
PacketTransformer transformer = side == NetworkManager.Side.C2S ? C2S_TRANSFORMERS.get(id) : S2C_TRANSFORMERS.get(id);
if (transformer != null) {
transformer.outbound(side, id, buf, (side1, id1, buf1) -> {
sink.accept(toPacket(side1, id1, buf1));
});
} else {
sink.accept(toPacket(side, id, buf));
}
}
public static Packet<?> toPacket(NetworkManager.Side side, ResourceLocation id, FriendlyByteBuf buf) {
if (side == NetworkManager.Side.C2S) {
return toC2SPacket(id, buf);
} else if (side == NetworkManager.Side.S2C) {
return toS2CPacket(id, buf);
}
throw new IllegalArgumentException("Invalid side: " + side);
}
@Environment(EnvType.CLIENT)
public static boolean canServerReceive(ResourceLocation id) {
return ClientPlayNetworking.canSend(id);
@@ -171,21 +122,4 @@ public class NetworkManagerImpl {
public static Packet<ClientGamePacketListener> createAddEntityPacket(Entity entity) {
return SpawnEntityPacket.create(entity);
}
@Environment(EnvType.CLIENT)
private static Packet<?> toC2SPacket(ResourceLocation id, FriendlyByteBuf buf) {
CustomPacketPayload.Type<BufCustomPacketPayload> type = C2S_TYPE.get(id);
if (type == null) {
throw new IllegalArgumentException("Unknown packet id: " + id);
}
return ClientPlayNetworking.createC2SPacket(new BufCustomPacketPayload(type, ByteBufUtil.getBytes(buf)));
}
private static Packet<?> toS2CPacket(ResourceLocation id, FriendlyByteBuf buf) {
CustomPacketPayload.Type<BufCustomPacketPayload> type = S2C_TYPE.get(id);
if (type == null) {
throw new IllegalArgumentException("Unknown packet id: " + id);
}
return ServerPlayNetworking.createS2CPacket(new BufCustomPacketPayload(type, ByteBufUtil.getBytes(buf)));
}
}