Also add support for Crossbows in battle.
# Upcoming changes
+# Version Forge-1.24.0
+
+Update to Forge 1.20.2-48.1.0.
+
+The `master` branch of this repository will track the build for Minecraft Forge.
+
+The `neoforge` branch of this repo. will track the build for NeoForge.
+
+Allow use of Crossbows in battle (it should behave identically to Bows).
+
# Version 1.23.1
More robust handling of disallowed Damage Sources in battle (via config).
# Building
Simply invoke `./gradlew build` in the mod directory and after some time the
-finished jar will be saved at "build/libs/TurnBasedMinecraft-1.23.1.jar"
+finished jar will be saved at "build/libs/TurnBasedMinecraft-Forge-1.24.0.jar"
# Other notes
id 'eclipse'
id 'idea'
id 'maven-publish'
- id 'net.minecraftforge.gradle' version '[6.0,6.2)'
+ id 'net.minecraftforge.gradle' version '[6.0.16,6.2)'
id 'com.github.johnrengelman.shadow' version '8.1.1'
}
-version = "1.23.1"
+version = "1.24.0"
group = "com.burnedkirby.TurnBasedMinecraft"
-archivesBaseName = "TurnBasedMinecraft"
+archivesBaseName = "TurnBasedMinecraft-Forge"
java.toolchain.languageVersion = JavaLanguageVersion.of(17)
println('Java: ' + System.getProperty('java.version') + ' JVM: ' + System.getProperty('java.vm.version') + '(' + System.getProperty('java.vendor') + ') Arch: ' + System.getProperty('os.arch'))
## Environment Properties
# The Minecraft version must agree with the Forge version to get a valid artifact
-minecraft_version=1.20.1
+minecraft_version=1.20.2
# The Minecraft version range can use any release version of Minecraft as bounds.
# Snapshots, pre-releases, and release candidates are not guaranteed to sort properly
# as they do not follow standard versioning conventions.
-minecraft_version_range=[1.20.1,1.21)
+minecraft_version_range=[1.20.2,1.21)
# The Forge version must agree with the Minecraft version to get a valid artifact
-forge_version=47.1.0
+forge_version=48.1.0
# The Forge version range can use any version of Forge as bounds or match the loader version range
-forge_version_range=[47,)
+forge_version_range=[48,)
# The loader version range can only use the major version of Forge/FML as bounds
-loader_version_range=[47,)
+loader_version_range=[48,)
# The mapping channel to use for mappings.
# The default set of supported mapping channels are ["official", "snapshot", "snapshot_nodoc", "stable", "stable_nodoc"].
# Additional mapping channels can be registered through the "channelProviders" extension in a Gradle plugin.
mapping_channel=official
# The mapping version to query from the mapping channel.
# This must match the format required by the mapping channel.
-mapping_version=1.20.1
+mapping_version=1.20.2
## Mod Properties
# The license of the mod. Review your options at https://choosealicense.com/. All Rights Reserved is the default.
mod_license=MIT
# The mod version. See https://semver.org/
-mod_version=1.23.1
+mod_version=1.24.0
# The group ID for the mod. It is only important when publishing as an artifact to a Maven repository.
# This should match the base package used for the mod sources.
# See https://maven.apache.org/guides/mini/guide-naming-conventions.html
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.1.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.4-all.zip
networkTimeout=10000
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
}\r
\r
plugins {\r
- id 'org.gradle.toolchains.foojay-resolver-convention' version '0.5.0'\r
+ id 'org.gradle.toolchains.foojay-resolver-convention' version '0.7.0'\r
}\r
import com.burnedkirby.TurnBasedMinecraft.common.Config;
import com.burnedkirby.TurnBasedMinecraft.common.TurnBasedMinecraftMod;
import com.burnedkirby.TurnBasedMinecraft.common.networking.PacketBattleDecision;
-import com.mojang.blaze3d.vertex.PoseStack;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.GuiGraphics;
import net.minecraft.client.gui.components.AbstractButton;
import net.minecraft.client.gui.components.Button;
import net.minecraft.client.gui.screens.Screen;
import net.minecraft.network.chat.Component;
+import net.minecraftforge.network.PacketDistributor;
import java.util.ConcurrentModificationException;
import java.util.HashMap;
drawString(guiGraphics, info, width / 2 - stringWidth / 2, 20, 0xFFFFFFFF);
}
+ @Override
+ public void renderBackground(GuiGraphics p_283688_, int p_299421_, int p_298679_, float p_297268_) {
+ }
+
protected void buttonActionEvent(AbstractButton button, ButtonAction action) {
switch (action) {
case ATTACK:
setState(MenuState.ATTACK_TARGET);
break;
case DEFEND:
- TurnBasedMinecraftMod.getHandler().sendToServer(new PacketBattleDecision(
- TurnBasedMinecraftMod.proxy.getLocalBattle().getId(), Battle.Decision.DEFEND, 0));
+ TurnBasedMinecraftMod.getHandler().send(new PacketBattleDecision(
+ TurnBasedMinecraftMod.proxy.getLocalBattle().getId(), Battle.Decision.DEFEND, 0),
+ PacketDistributor.SERVER.noArg());
setState(MenuState.WAITING);
break;
case ITEM:
setState(MenuState.ITEM_ACTION);
break;
case FLEE:
- TurnBasedMinecraftMod.getHandler().sendToServer(new PacketBattleDecision(
- TurnBasedMinecraftMod.proxy.getLocalBattle().getId(), Battle.Decision.FLEE, 0));
+ TurnBasedMinecraftMod.getHandler().send(new PacketBattleDecision(
+ TurnBasedMinecraftMod.proxy.getLocalBattle().getId(), Battle.Decision.FLEE, 0),
+ PacketDistributor.SERVER.noArg());
setState(MenuState.WAITING);
break;
case ATTACK_TARGET:
if (button instanceof EntitySelectionButton) {
- TurnBasedMinecraftMod.getHandler()
- .sendToServer(new PacketBattleDecision(TurnBasedMinecraftMod.proxy.getLocalBattle().getId(),
- Battle.Decision.ATTACK, ((EntitySelectionButton) button).getID()));
+ TurnBasedMinecraftMod.getHandler().send(new PacketBattleDecision(
+ TurnBasedMinecraftMod.proxy.getLocalBattle().getId(), Battle.Decision.ATTACK, ((EntitySelectionButton) button).getID()),
+ PacketDistributor.SERVER.noArg());
setState(MenuState.WAITING);
} else {
setState(MenuState.MAIN_MENU);
break;
case DO_ITEM_SWITCH:
if (button instanceof ItemSelectionButton) {
- TurnBasedMinecraftMod.getHandler()
- .sendToServer(new PacketBattleDecision(TurnBasedMinecraftMod.proxy.getLocalBattle().getId(),
- Battle.Decision.SWITCH_ITEM, ((ItemSelectionButton) button).getID()));
+ TurnBasedMinecraftMod.getHandler().send(new PacketBattleDecision(
+ TurnBasedMinecraftMod.proxy.getLocalBattle().getId(), Battle.Decision.SWITCH_ITEM, ((ItemSelectionButton) button).getID()),
+ PacketDistributor.SERVER.noArg());
if (((ItemSelectionButton) button).getID() >= 0 && ((ItemSelectionButton) button).getID() < 9) {
Minecraft.getInstance().player.getInventory().selected = ((ItemSelectionButton) button).getID();
}
break;
case DO_USE_ITEM:
if (button instanceof ItemSelectionButton) {
- TurnBasedMinecraftMod.getHandler()
- .sendToServer(new PacketBattleDecision(TurnBasedMinecraftMod.proxy.getLocalBattle().getId(),
- Battle.Decision.USE_ITEM, ((ItemSelectionButton) button).getID()));
+ TurnBasedMinecraftMod.getHandler().send(new PacketBattleDecision(
+ TurnBasedMinecraftMod.proxy.getLocalBattle().getId(), Battle.Decision.USE_ITEM, ((ItemSelectionButton) button).getID()),
+ PacketDistributor.SERVER.noArg());
setState(MenuState.WAITING);
} else {
setState(MenuState.MAIN_MENU);
import net.minecraft.sounds.SoundSource;
import net.minecraft.world.entity.Entity;
import net.minecraft.world.level.Level;
-import net.minecraftforge.network.NetworkEvent;
-
-import java.util.function.Supplier;
+import net.minecraftforge.event.network.CustomPayloadEvent;
public class ClientProxy extends CommonProxy {
private BattleGui battleGui = null;
}
@Override
- public <MSG> void handlePacket(MSG msg, Supplier<NetworkEvent.Context> ctx) {
+ public <MSG> void handlePacket(MSG msg, CustomPayloadEvent.Context ctx) {
if (msg.getClass() == PacketBattleMessage.class) {
PacketBattleMessage pkt = (PacketBattleMessage) msg;
Entity fromEntity = getEntity(pkt.getEntityIDFrom(), pkt.getDimension());
TurnBasedMinecraftMod.proxy.displayComponent(parentComponent);
}
break;
+ case CROSSBOW_NO_AMMO: {
+ parentComponent.getSiblings().add(from);
+ parentComponent.getSiblings().add(Component.literal(" tried to use their crossbow but ran out of ammo!"));
+ TurnBasedMinecraftMod.proxy.displayComponent(parentComponent);
+ }
+ break;
}
} else if (msg.getClass() == PacketGeneralMessage.class) {
PacketGeneralMessage pkt = (PacketGeneralMessage) msg;
if(!event.getEntity().hasCustomName())
{
TurnBasedMinecraftMod.logger.error("Cannot edit custom name from entity without custom name");
- TurnBasedMinecraftMod.getHandler().send(PacketDistributor.PLAYER.with(() -> (ServerPlayer)editingInfo.editor), new PacketGeneralMessage("Cannot edit custom name from entity without custom name"));
+ TurnBasedMinecraftMod.getHandler().send(new PacketGeneralMessage("Cannot edit custom name from entity without custom name"), PacketDistributor.PLAYER.with((ServerPlayer)editingInfo.editor));
return;
}
editingInfo.entityInfo = config.getCustomEntityInfo(event.getEntity().getCustomName().getString());
editingInfo.entityInfo = new EntityInfo();
editingInfo.entityInfo.customName = event.getEntity().getCustomName().getString();
}
- TurnBasedMinecraftMod.getHandler().send(PacketDistributor.PLAYER.with(() -> (ServerPlayer)editingInfo.editor), new PacketGeneralMessage("Editing custom name \"" + event.getEntity().getCustomName().getString() + "\""));
+ TurnBasedMinecraftMod.getHandler().send(new PacketGeneralMessage("Editing custom name \"" + event.getEntity().getCustomName().getString() + "\""), PacketDistributor.PLAYER.with((ServerPlayer)editingInfo.editor));
TurnBasedMinecraftMod.logger.info("Begin editing custom \"" + event.getEntity().getCustomName().getString() + "\"");
- TurnBasedMinecraftMod.getHandler().send(PacketDistributor.PLAYER.with(() -> (ServerPlayer)editingInfo.editor), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+ TurnBasedMinecraftMod.getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with((ServerPlayer)editingInfo.editor));
}
else
{
{
editingInfo.entityInfo = editingInfo.entityInfo.clone();
}
- TurnBasedMinecraftMod.getHandler().send(PacketDistributor.PLAYER.with(() -> (ServerPlayer)editingInfo.editor), new PacketGeneralMessage("Editing entity \"" + editingInfo.entityInfo.classType.getName() + "\""));
+ TurnBasedMinecraftMod.getHandler().send(new PacketGeneralMessage("Editing entity \"" + editingInfo.entityInfo.classType.getName() + "\""), PacketDistributor.PLAYER.with((ServerPlayer)editingInfo.editor));
TurnBasedMinecraftMod.logger.info("Begin editing \"" + editingInfo.entityInfo.classType.getName() + "\"");
- TurnBasedMinecraftMod.getHandler().send(PacketDistributor.PLAYER.with(() -> (ServerPlayer)editingInfo.editor), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+ TurnBasedMinecraftMod.getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with((ServerPlayer)editingInfo.editor));
}
return;
}
import com.burnedkirby.TurnBasedMinecraft.common.networking.PacketBattleMessage;
import net.minecraft.resources.ResourceKey;
import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.InteractionHand;
import net.minecraft.world.damagesource.DamageSource;
import net.minecraft.world.effect.MobEffects;
import net.minecraft.world.entity.Entity;
}
PacketBattleInfo infoPacket = new PacketBattleInfo(getSideAIDs(), getSideBIDs(), timer, TurnBasedMinecraftMod.proxy.getConfig().getDecisionDurationNanos(), !TurnBasedMinecraftMod.proxy.getConfig().isBattleDecisionDurationForever());
for (Combatant p : players.values()) {
- TurnBasedMinecraftMod.getHandler().send(PacketDistributor.PLAYER.with(() -> (ServerPlayer) p.entity), infoPacket);
+ TurnBasedMinecraftMod.getHandler().send(infoPacket, PacketDistributor.PLAYER.with((ServerPlayer)p.entity));
}
}
PacketBattleMessage packet = new PacketBattleMessage(type, from, to, dimension, amount, custom);
for (Combatant p : players.values()) {
if (p.entity.isAlive()) {
- TurnBasedMinecraftMod.getHandler().send(PacketDistributor.PLAYER.with(() -> (ServerPlayer) p.entity), packet);
+ TurnBasedMinecraftMod.getHandler().send(packet, PacketDistributor.PLAYER.with((ServerPlayer)p.entity));
}
}
}
private void removeCombatantPostRemove(Combatant c) {
if (c.entity instanceof Player) {
- TurnBasedMinecraftMod.getHandler().send(PacketDistributor.PLAYER.with(() -> (ServerPlayer) c.entity), new PacketBattleMessage(PacketBattleMessage.MessageType.ENDED, 0, 0, dimension, 0));
+ TurnBasedMinecraftMod.getHandler().send(new PacketBattleMessage(PacketBattleMessage.MessageType.ENDED, 0, 0, dimension, 0), PacketDistributor.PLAYER.with((ServerPlayer)c.entity));
}
battleManager.addRecentlyLeftBattle(c);
}
sendMessageToAllPlayers(PacketBattleMessage.MessageType.BOW_NO_AMMO, next.entity.getId(), 0, 0);
}
continue;
+ } else if (heldItemStack.getItem() instanceof CrossbowItem) {
+ debugLog += " with crossbow";
+ if (Utility.doesPlayerHaveArrows((Player)next.entity)) {
+ // Similar to attack with bow.
+ final Entity nextEntity = next.entity;
+ final Entity targetEntity = target.entity;
+ final float yawDirection = Utility.yawDirection(next.entity.getX(), next.entity.getZ(), target.entity.getX(), target.entity.getZ());
+ final float pitchDirection = Utility.pitchDirection(next.entity.getX(), next.entity.getY(), next.entity.getZ(), target.entity.getX(), target.entity.getY(), target.entity.getZ());
+ if (TurnBasedMinecraftMod.proxy.getConfig().isFreezeCombatantsEnabled()) {
+ next.yaw = yawDirection;
+ next.pitch = pitchDirection;
+ }
+ // have player look at attack target
+ ((ServerPlayer) nextEntity).connection.teleport(nextEntity.getX(), nextEntity.getY(), nextEntity.getZ(), yawDirection, pitchDirection);
+ CrossbowItem itemCrossbow = (CrossbowItem) heldItemStack.getItem();
+ TurnBasedMinecraftMod.proxy.getAttackerViaBowSet().add(new AttackerViaBow(nextEntity, getId()));
+ itemCrossbow.releaseUsing(((Player) nextEntity).getMainHandItem(), nextEntity.level(), (LivingEntity) nextEntity, -100);
+ itemCrossbow.use(nextEntity.level(), (Player)nextEntity, InteractionHand.MAIN_HAND);
+ sendMessageToAllPlayers(PacketBattleMessage.MessageType.FIRED_ARROW, nextEntity.getId(), targetEntity.getId(), 0);
+ } else {
+ sendMessageToAllPlayers(PacketBattleMessage.MessageType.CROSSBOW_NO_AMMO, next.entity.getId(), 0, 0);
+ }
+ continue;
}
debugLog += " without bow";
int hitChance = TurnBasedMinecraftMod.proxy.getConfig().getPlayerAttackProbability();
c.time = System.nanoTime();
Config config = TurnBasedMinecraftMod.proxy.getConfig();
if(c.entity instanceof ServerPlayer) {
- TurnBasedMinecraftMod.getHandler().send(PacketDistributor.PLAYER.with(()->(ServerPlayer) c.entity), new PacketGeneralMessage("You just left battle! " + config.getLeaveBattleCooldownSeconds() + " seconds until you can attack/be-attacked again!"));
+ TurnBasedMinecraftMod.getHandler().send(new PacketGeneralMessage("You just left battle! " + config.getLeaveBattleCooldownSeconds() + " seconds until you can attack/be-attacked again!"), PacketDistributor.PLAYER.with((ServerPlayer)c.entity));
}
recentlyLeftBattle.put(c.entity.getId(), c);
entityToBattleMap.remove(new EntityIDDimPair(c.entity));
iter.remove();
if(entry.getValue().entity instanceof ServerPlayer)
{
- TurnBasedMinecraftMod.getHandler().send(PacketDistributor.PLAYER.with(()->(ServerPlayer)entry.getValue().entity), new PacketGeneralMessage("Timer ended, you can now attack/be-attacked again."));
+ TurnBasedMinecraftMod.getHandler().send(new PacketGeneralMessage("Timer ended, you can now attack/be-attacked again."), PacketDistributor.PLAYER.with((ServerPlayer)entry.getValue().entity));
}
}
}
import net.minecraft.world.entity.Entity;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.level.Level;
-import net.minecraftforge.network.NetworkEvent;
+import net.minecraftforge.event.network.CustomPayloadEvent;
import net.minecraftforge.server.ServerLifecycleHooks;
import org.apache.logging.log4j.Logger;
import java.util.Hashtable;
import java.util.Map;
import java.util.Set;
-import java.util.function.Supplier;
public class CommonProxy
{
return ServerLifecycleHooks.getCurrentServer().getLevel(dim).getEntity(id);
}
- public <MSG> void handlePacket(MSG msg, Supplier<NetworkEvent.Context> ctx) {}
+ public <MSG> void handlePacket(MSG msg,CustomPayloadEvent.Context ctx) {}
}
if(TurnBasedMinecraftMod.proxy.getBattleManager().forceLeaveBattle(new EntityIDDimPair(event.getEntity()))
&& event.getEntity() instanceof ServerPlayer) {
TurnBasedMinecraftMod.getHandler().send(
- PacketDistributor.PLAYER.with(() -> (ServerPlayer)event.getEntity()),
- new PacketGeneralMessage("Left battle due to moving to a different dimension"));
+ new PacketGeneralMessage("Left battle due to moving to a different dimension"),
+ PacketDistributor.PLAYER.with((ServerPlayer)event.getEntity()));
}
}
}
import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent;
import net.minecraftforge.fml.event.lifecycle.FMLDedicatedServerSetupEvent;
import net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext;
-import net.minecraftforge.network.NetworkRegistry;
-import net.minecraftforge.network.PacketDistributor;
-import net.minecraftforge.network.simple.SimpleChannel;
+import net.minecraftforge.network.*;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
public class TurnBasedMinecraftMod {
public static final String MODID = "com_burnedkirby_turnbasedminecraft";
public static final String NAME = "Turn Based Minecraft Mod";
- public static final String VERSION = "1.23.1";
+ public static final String VERSION = "1.24.0";
public static final String CONFIG_FILENAME = "TBM_Config.toml";
public static final String DEFAULT_CONFIG_FILENAME = "TBM_Config_DEFAULT.toml";
public static final String CONFIG_DIRECTORY = "config/TurnBasedMinecraft/";
public static final String MUSIC_SILLY = MUSIC_ROOT + "silly/";
public static final String MUSIC_BATTLE = MUSIC_ROOT + "battle/";
- private static final String PROTOCOL_VERSION = Integer.toString(2);
+ private static final Integer PROTOCOL_VERSION = 3;
private static final ResourceLocation HANDLER_ID = new ResourceLocation(MODID, "main_channel");
- private static final SimpleChannel HANDLER = NetworkRegistry.ChannelBuilder
+
+ private static final SimpleChannel HANDLER = ChannelBuilder
.named(HANDLER_ID)
- .clientAcceptedVersions(PROTOCOL_VERSION::equals)
- .serverAcceptedVersions(PROTOCOL_VERSION::equals)
- .networkProtocolVersion(() -> PROTOCOL_VERSION)
+ .clientAcceptedVersions(Channel.VersionTest.exact(PROTOCOL_VERSION))
+ .serverAcceptedVersions(Channel.VersionTest.exact(PROTOCOL_VERSION))
+ .networkProtocolVersion(PROTOCOL_VERSION)
.simpleChannel();
protected static Logger logger = LogManager.getLogger();
proxy.initialize();
// register packets
- int packetHandlerID = 0;
- HANDLER.registerMessage(
- packetHandlerID++,
- PacketBattleInfo.class,
- PacketBattleInfo::encode,
- PacketBattleInfo::decode,
- PacketBattleInfo::handle);
- HANDLER.registerMessage(
- packetHandlerID++,
- PacketBattleRequestInfo.class,
- PacketBattleRequestInfo::encode,
- PacketBattleRequestInfo::decode,
- PacketBattleRequestInfo::handle);
- HANDLER.registerMessage(
- packetHandlerID++,
- PacketBattleDecision.class,
- PacketBattleDecision::encode,
- PacketBattleDecision::decode,
- PacketBattleDecision::handle);
- HANDLER.registerMessage(
- packetHandlerID++,
- PacketBattleMessage.class,
- PacketBattleMessage::encode,
- PacketBattleMessage::decode,
- PacketBattleMessage::handle);
- HANDLER.registerMessage(
- packetHandlerID++,
- PacketGeneralMessage.class,
- PacketGeneralMessage::encode,
- PacketGeneralMessage::decode,
- PacketGeneralMessage::handle);
- HANDLER.registerMessage(
- packetHandlerID++,
- PacketEditingMessage.class,
- PacketEditingMessage::encode,
- PacketEditingMessage::decode,
- PacketEditingMessage::handle);
+ HANDLER.messageBuilder(PacketBattleInfo.class, NetworkDirection.PLAY_TO_CLIENT)
+ .encoder(new PacketBattleInfo.Encoder())
+ .decoder(new PacketBattleInfo.Decoder())
+ .consumerNetworkThread(new PacketBattleInfo.Consumer())
+ .add();
+ HANDLER.messageBuilder(PacketBattleRequestInfo.class, NetworkDirection.PLAY_TO_SERVER)
+ .encoder(new PacketBattleRequestInfo.Encoder())
+ .decoder(new PacketBattleRequestInfo.Decoder())
+ .consumerNetworkThread(new PacketBattleRequestInfo.Consumer())
+ .add();
+ HANDLER.messageBuilder(PacketBattleDecision.class, NetworkDirection.PLAY_TO_SERVER)
+ .encoder(new PacketBattleDecision.Encoder())
+ .decoder(new PacketBattleDecision.Decoder())
+ .consumerNetworkThread(new PacketBattleDecision.Consumer())
+ .add();
+ HANDLER.messageBuilder(PacketBattleMessage.class, NetworkDirection.PLAY_TO_CLIENT)
+ .encoder(new PacketBattleMessage.Encoder())
+ .decoder(new PacketBattleMessage.Decoder())
+ .consumerNetworkThread(new PacketBattleMessage.Consumer())
+ .add();
+ HANDLER.messageBuilder(PacketGeneralMessage.class, NetworkDirection.PLAY_TO_CLIENT)
+ .encoder(new PacketGeneralMessage.Encoder())
+ .decoder(new PacketGeneralMessage.Decoder())
+ .consumerNetworkThread(new PacketGeneralMessage.Consumer())
+ .add();
+ HANDLER.messageBuilder(PacketEditingMessage.class, NetworkDirection.PLAY_TO_CLIENT)
+ .encoder(new PacketEditingMessage.Encoder())
+ .decoder(new PacketEditingMessage.Decoder())
+ .consumerNetworkThread(new PacketEditingMessage.Consumer())
+ .add();
// register event handler(s)
MinecraftForge.EVENT_BUS.register(new AttackEventHandler());
proxy.getConfig().setBattleDisabledForAll(true);
for (ServerPlayer player : c.getSource().getServer().getPlayerList().getPlayers()) {
proxy.getConfig().addBattleIgnoringPlayer(player.getId());
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketGeneralMessage("OP disabled turn-based-combat for everyone"));
+ getHandler().send(new PacketGeneralMessage("OP disabled turn-based-combat for everyone"), PacketDistributor.PLAYER.with(player));
}
return 1;
}));
proxy.getConfig().setBattleDisabledForAll(false);
proxy.getConfig().clearBattleIgnoringPlayers();
for (ServerPlayer player : c.getSource().getServer().getPlayerList().getPlayers()) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketGeneralMessage("OP enabled turn-based-combat for everyone"));
+ getHandler().send(new PacketGeneralMessage("OP enabled turn-based-combat for everyone"), PacketDistributor.PLAYER.with(player));
}
return 1;
}));
.then(Commands.argument("targets", EntityArgument.players()).executes(c -> {
for (ServerPlayer player : EntityArgument.getPlayers(c, "targets")) {
proxy.getConfig().addBattleIgnoringPlayer(player.getId());
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketGeneralMessage("OP enabled turn-based-combat for you"));
+ getHandler().send(new PacketGeneralMessage("OP enabled turn-based-combat for you"), PacketDistributor.PLAYER.with(player));
c.getSource().sendSuccess(() -> Component.literal("Enabled turn-based-combat for " + player.getDisplayName().getString()), true);
}
return 1;
.then(Commands.argument("targets", EntityArgument.players()).executes(c -> {
for (ServerPlayer player : EntityArgument.getPlayers(c, "targets")) {
proxy.getConfig().removeBattleIgnoringPlayer(player.getId());
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketGeneralMessage("OP disabled turn-based-combat for you"));
+ getHandler().send(new PacketGeneralMessage("OP disabled turn-based-combat for you"), PacketDistributor.PLAYER.with(player));
c.getSource().sendSuccess(() -> Component.literal("Disabled turn-based-combat for " + player.getDisplayName().getString()), true);
}
return 1;
ServerPlayer player = c.getSource().getPlayerOrException();
EditingInfo editingInfo = proxy.getEditingInfo(player.getId());
if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
proxy.setEditingPlayer(player);
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
logger.info("Begin editing TBM Entity for player \"" + player.getDisplayName().getString() + "\" (\"" + c.getSource().getDisplayName() + "\")");
}
return 1;
EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
if (!proxy.getConfig().editEntityEntry(editingInfo.entityInfo)) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketGeneralMessage("An error occurred while attempting to save an entry to the config"));
+ getHandler().send(new PacketGeneralMessage("An error occurred while attempting to save an entry to the config"), PacketDistributor.PLAYER.with(player));
proxy.removeEditingInfo(player.getId());
} else {
proxy.removeEditingInfo(player.getId());
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketGeneralMessage("Entity info saved in config and loaded."));
+ getHandler().send(new PacketGeneralMessage("Entity info saved in config and loaded."), PacketDistributor.PLAYER.with(player));
}
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
if (editingInfo != null) {
proxy.removeEditingInfo(player.getId());
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketGeneralMessage("Cancelled editing entry."));
+ getHandler().send(new PacketGeneralMessage("Cancelled editing entry."), PacketDistributor.PLAYER.with(player));
}
return 1;
}))
Message exceptionMessage = new LiteralMessage("Invalid action for tbm-edit");
throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
proxy.setEditingPlayer(player);
proxy.getEditingInfo(player.getId()).isEditingCustomName = true;
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
logger.info("Begin editing custom TBM Entity for player \"" + player.getDisplayName().getString() + "\" (\"" + c.getSource().getDisplayName() + "\")");
}
return 1;
ServerPlayer player = c.getSource().getPlayerOrException();
EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
ServerPlayer player = c.getSource().getPlayerOrException();
EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.EDIT_IGNORE_BATTLE));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_IGNORE_BATTLE), PacketDistributor.PLAYER.with(player));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
boolean ignoreBattle = BoolArgumentType.getBool(c, "ignoreBattle");
if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
editingInfo.entityInfo.ignoreBattle = ignoreBattle;
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
ServerPlayer player = c.getSource().getPlayerOrException();
EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.EDIT_ATTACK_POWER));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_ATTACK_POWER), PacketDistributor.PLAYER.with(player));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
}
if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
editingInfo.entityInfo.attackPower = attackPower;
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
ServerPlayer player = c.getSource().getPlayerOrException();
EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.EDIT_ATTACK_PROBABILITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_ATTACK_PROBABILITY), PacketDistributor.PLAYER.with(player));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
}
if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
editingInfo.entityInfo.attackProbability = attackProbability;
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
ServerPlayer player = c.getSource().getPlayerOrException();
EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.EDIT_ATTACK_VARIANCE));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_ATTACK_VARIANCE), PacketDistributor.PLAYER.with(player));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
}
if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
editingInfo.entityInfo.attackVariance = attackVariance;
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
ServerPlayer player = c.getSource().getPlayerOrException();
EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.EDIT_ATTACK_EFFECT));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_ATTACK_EFFECT), PacketDistributor.PLAYER.with(player));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
EntityInfo.Effect effect = EntityInfo.Effect.fromString(StringArgumentType.getString(c, "attackEffect"));
if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
editingInfo.entityInfo.attackEffect = effect;
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
ServerPlayer player = c.getSource().getPlayerOrException();
EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.EDIT_ATTACK_EFFECT_PROBABILITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_ATTACK_EFFECT_PROBABILITY), PacketDistributor.PLAYER.with(player));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
}
if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
editingInfo.entityInfo.attackEffectProbability = attackEffectProbability;
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
ServerPlayer player = c.getSource().getPlayerOrException();
EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.EDIT_DEFENSE_DAMAGE));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_DEFENSE_DAMAGE), PacketDistributor.PLAYER.with(player));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
}
if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
editingInfo.entityInfo.defenseDamage = defenseDamage;
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
ServerPlayer player = c.getSource().getPlayerOrException();
EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.EDIT_DEFENSE_DAMAGE_PROBABILITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_DEFENSE_DAMAGE_PROBABILITY), PacketDistributor.PLAYER.with(player));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
}
if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
editingInfo.entityInfo.defenseDamageProbability = defenseDamageProbability;
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
ServerPlayer player = c.getSource().getPlayerOrException();
EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.EDIT_EVASION));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_EVASION), PacketDistributor.PLAYER.with(player));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
}
if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
editingInfo.entityInfo.evasion = evasion;
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
ServerPlayer player = c.getSource().getPlayerOrException();
EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.EDIT_SPEED));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_SPEED), PacketDistributor.PLAYER.with(player));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
}
if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
editingInfo.entityInfo.speed = speed;
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
ServerPlayer player = c.getSource().getPlayerOrException();
EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.EDIT_CATEGORY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_CATEGORY), PacketDistributor.PLAYER.with(player));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
String category = StringArgumentType.getString(c, "category");
if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
editingInfo.entityInfo.category = category;
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
ServerPlayer player = c.getSource().getPlayerOrException();
EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.EDIT_DECISION_ATTACK));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_DECISION_ATTACK), PacketDistributor.PLAYER.with(player));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
}
if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
editingInfo.entityInfo.decisionAttack = decisionAttack;
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
ServerPlayer player = c.getSource().getPlayerOrException();
EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.EDIT_DECISION_DEFEND));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_DECISION_DEFEND), PacketDistributor.PLAYER.with(player));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
}
if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
editingInfo.entityInfo.decisionDefend = decisionDefend;
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
ServerPlayer player = c.getSource().getPlayerOrException();
EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.EDIT_DECISION_FLEE));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_DECISION_FLEE), PacketDistributor.PLAYER.with(player));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
int decisionFlee = IntegerArgumentType.getInteger(c, "decisionFlee");
if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
editingInfo.entityInfo.decisionFlee = decisionFlee;
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
} else {
Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
.requires(c -> c.hasPermission(2))
.executes(c -> {
ServerPlayer player = c.getSource().getPlayerOrException();
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.SERVER_EDIT));
+ getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.SERVER_EDIT), PacketDistributor.PLAYER.with(player));
return 1;
})
.then(Commands.literal("leave_battle_cooldown").executes(c -> {
package com.burnedkirby.TurnBasedMinecraft.common.networking;
-import java.util.function.Supplier;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
import com.burnedkirby.TurnBasedMinecraft.common.Battle;
import com.burnedkirby.TurnBasedMinecraft.common.TurnBasedMinecraftMod;
import net.minecraft.server.level.ServerPlayer;
import net.minecraft.network.FriendlyByteBuf;
-import net.minecraftforge.network.NetworkEvent;
+import net.minecraftforge.event.network.CustomPayloadEvent;
public class PacketBattleDecision
{
this.decision = decision;
this.targetIDOrItemID = targetIDOrItemID;
}
-
- public static void encode(PacketBattleDecision pkt, FriendlyByteBuf buf) {
- buf.writeInt(pkt.battleID);
- buf.writeInt(pkt.decision.getValue());
- buf.writeInt(pkt.targetIDOrItemID);
+
+ public static class Encoder implements BiConsumer<PacketBattleDecision, FriendlyByteBuf> {
+ public Encoder() {}
+
+ @Override
+ public void accept(PacketBattleDecision pkt, FriendlyByteBuf buf) {
+ buf.writeInt(pkt.battleID);
+ buf.writeInt(pkt.decision.getValue());
+ buf.writeInt(pkt.targetIDOrItemID);
+ }
}
-
- public static PacketBattleDecision decode(FriendlyByteBuf buf) {
- return new PacketBattleDecision(buf.readInt(), Decision.valueOf(buf.readInt()), buf.readInt());
+
+ public static class Decoder implements Function<FriendlyByteBuf, PacketBattleDecision> {
+ public Decoder() {}
+
+ @Override
+ public PacketBattleDecision apply(FriendlyByteBuf buf) {
+ return new PacketBattleDecision(buf.readInt(), Decision.valueOf(buf.readInt()), buf.readInt());
+ }
}
-
- public static void handle(final PacketBattleDecision pkt, Supplier<NetworkEvent.Context> ctx) {
- ctx.get().enqueueWork(() -> {
- Battle b = TurnBasedMinecraftMod.proxy.getBattleManager().getBattleByID(pkt.battleID);
- if(b != null)
- {
- ServerPlayer player = ctx.get().getSender();
- b.setDecision(player.getId(), pkt.decision, pkt.targetIDOrItemID);
- }
- });
- ctx.get().setPacketHandled(true);
+
+ public static class Consumer implements BiConsumer<PacketBattleDecision, CustomPayloadEvent.Context> {
+ public Consumer() {}
+
+ @Override
+ public void accept(PacketBattleDecision pkt, CustomPayloadEvent.Context ctx) {
+ ctx.enqueueWork(() -> {
+ Battle b = TurnBasedMinecraftMod.proxy.getBattleManager().getBattleByID(pkt.battleID);
+ if(b != null)
+ {
+ ServerPlayer player = ctx.getSender();
+ b.setDecision(player.getId(), pkt.decision, pkt.targetIDOrItemID);
+ }
+ });
+ ctx.setPacketHandled(true);
+ }
}
}
import java.util.ArrayList;
import java.util.Collection;
-import java.util.function.Supplier;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
import com.burnedkirby.TurnBasedMinecraft.common.TurnBasedMinecraftMod;
import net.minecraft.client.Minecraft;
import net.minecraft.world.entity.Entity;
import net.minecraft.network.FriendlyByteBuf;
-import net.minecraftforge.network.NetworkEvent;
+import net.minecraftforge.event.network.CustomPayloadEvent;
public class PacketBattleInfo
{
this.turnTimerEnabled = turnTimerEnabled;
}
- public static void encode(PacketBattleInfo msg, FriendlyByteBuf buf) {
- buf.writeInt(msg.sideA.size());
- buf.writeInt(msg.sideB.size());
- for(Integer id : msg.sideA) {
- buf.writeInt(id);
- }
- for(Integer id : msg.sideB) {
- buf.writeInt(id);
- }
- buf.writeLong(msg.decisionNanos);
- buf.writeLong(msg.maxDecisionNanos);
- buf.writeBoolean(msg.turnTimerEnabled);
- }
+ public static class Encoder implements BiConsumer<PacketBattleInfo, FriendlyByteBuf> {
+ public Encoder() {}
- public static PacketBattleInfo decode(FriendlyByteBuf buf) {
- int sideACount = buf.readInt();
- int sideBCount = buf.readInt();
- Collection<Integer> sideA = new ArrayList<Integer>(sideACount);
- Collection<Integer> sideB = new ArrayList<Integer>(sideBCount);
- for(int i = 0; i < sideACount; ++i) {
- sideA.add(buf.readInt());
- }
- for(int i = 0; i < sideBCount; ++i) {
- sideB.add(buf.readInt());
- }
- long decisionNanos = buf.readLong();
- long maxDecisionNanos = buf.readLong();
- boolean turnTimerEnabled = buf.readBoolean();
- return new PacketBattleInfo(sideA, sideB, decisionNanos, maxDecisionNanos, turnTimerEnabled);
+ @Override
+ public void accept(PacketBattleInfo msg, FriendlyByteBuf buf) {
+ buf.writeInt(msg.sideA.size());
+ buf.writeInt(msg.sideB.size());
+ for(Integer id : msg.sideA) {
+ buf.writeInt(id);
+ }
+ for(Integer id : msg.sideB) {
+ buf.writeInt(id);
+ }
+ buf.writeLong(msg.decisionNanos);
+ buf.writeLong(msg.maxDecisionNanos);
+ buf.writeBoolean(msg.turnTimerEnabled);
+ }
}
-
- public static void handle(final PacketBattleInfo pkt, Supplier<NetworkEvent.Context> ctx) {
- ctx.get().enqueueWork(() -> {
- if(TurnBasedMinecraftMod.proxy.getLocalBattle() == null)
- {
- return;
+
+ public static class Decoder implements Function<FriendlyByteBuf, PacketBattleInfo> {
+ public Decoder() {}
+
+ @Override
+ public PacketBattleInfo apply(FriendlyByteBuf buf) {
+ int sideACount = buf.readInt();
+ int sideBCount = buf.readInt();
+ Collection<Integer> sideA = new ArrayList<Integer>(sideACount);
+ Collection<Integer> sideB = new ArrayList<Integer>(sideBCount);
+ for(int i = 0; i < sideACount; ++i) {
+ sideA.add(buf.readInt());
+ }
+ for(int i = 0; i < sideBCount; ++i) {
+ sideB.add(buf.readInt());
}
- TurnBasedMinecraftMod.proxy.getLocalBattle().clearCombatants();
- for(Integer id : pkt.sideA)
- {
- Entity e = Minecraft.getInstance().level.getEntity(id);
- if(e != null)
+ long decisionNanos = buf.readLong();
+ long maxDecisionNanos = buf.readLong();
+ boolean turnTimerEnabled = buf.readBoolean();
+ return new PacketBattleInfo(sideA, sideB, decisionNanos, maxDecisionNanos, turnTimerEnabled);
+ }
+ }
+
+ public static class Consumer implements BiConsumer<PacketBattleInfo, CustomPayloadEvent.Context> {
+ public Consumer() {}
+
+ @Override
+ public void accept(PacketBattleInfo pkt, CustomPayloadEvent.Context ctx) {
+ ctx.enqueueWork(() -> {
+ if(TurnBasedMinecraftMod.proxy.getLocalBattle() == null)
{
- TurnBasedMinecraftMod.proxy.getLocalBattle().addCombatantToSideA(e);
+ return;
}
- }
- for(Integer id : pkt.sideB)
- {
- Entity e = Minecraft.getInstance().level.getEntity(id);
- if(e != null)
+ TurnBasedMinecraftMod.proxy.getLocalBattle().clearCombatants();
+ for(Integer id : pkt.sideA)
{
- TurnBasedMinecraftMod.proxy.getLocalBattle().addCombatantToSideB(e);
+ Entity e = Minecraft.getInstance().level.getEntity(id);
+ if(e != null)
+ {
+ TurnBasedMinecraftMod.proxy.getLocalBattle().addCombatantToSideA(e);
+ }
}
- }
- TurnBasedMinecraftMod.proxy.setBattleGuiTime((int)(pkt.decisionNanos / 1000000000L));
- TurnBasedMinecraftMod.proxy.setBattleGuiBattleChanged();
- TurnBasedMinecraftMod.proxy.setBattleGuiTurnTimerEnabled(pkt.turnTimerEnabled);
- TurnBasedMinecraftMod.proxy.setBattleGuiTurnTimerMax((int)(pkt.maxDecisionNanos / 1000000000L));
- });
- ctx.get().setPacketHandled(true);
+ for(Integer id : pkt.sideB)
+ {
+ Entity e = Minecraft.getInstance().level.getEntity(id);
+ if(e != null)
+ {
+ TurnBasedMinecraftMod.proxy.getLocalBattle().addCombatantToSideB(e);
+ }
+ }
+ TurnBasedMinecraftMod.proxy.setBattleGuiTime((int)(pkt.decisionNanos / 1000000000L));
+ TurnBasedMinecraftMod.proxy.setBattleGuiBattleChanged();
+ TurnBasedMinecraftMod.proxy.setBattleGuiTurnTimerEnabled(pkt.turnTimerEnabled);
+ TurnBasedMinecraftMod.proxy.setBattleGuiTurnTimerMax((int)(pkt.maxDecisionNanos / 1000000000L));
+ });
+ ctx.setPacketHandled(true);
+ }
}
}
import java.util.HashMap;
import java.util.Map;
-import java.util.function.Supplier;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
import com.burnedkirby.TurnBasedMinecraft.common.TurnBasedMinecraftMod;
import net.minecraft.resources.ResourceKey;
import net.minecraft.world.level.Level;
import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.event.network.CustomPayloadEvent;
import net.minecraftforge.fml.DistExecutor;
-import net.minecraftforge.network.NetworkEvent;
public class PacketBattleMessage
{
BOW_NO_AMMO(18),
CREEPER_WAIT(19),
CREEPER_WAIT_FINAL(20),
- CREEPER_EXPLODE(21);
+ CREEPER_EXPLODE(21),
+ CROSSBOW_NO_AMMO(22);
private int value;
private static Map<Integer, MessageType> map = new HashMap<Integer, MessageType>();
this.amount = amount;
this.custom = custom;
}
-
- public static void encode(PacketBattleMessage pkt, FriendlyByteBuf buf) {
- buf.writeInt(pkt.messageType.getValue());
- buf.writeInt(pkt.entityIDFrom);
- buf.writeInt(pkt.entityIDTo);
- buf.writeUtf(Utility.serializeDimension(pkt.dimension));
- buf.writeInt(pkt.amount);
- buf.writeUtf(pkt.custom);
+
+ public static class Encoder implements BiConsumer<PacketBattleMessage, FriendlyByteBuf> {
+ public Encoder() {}
+
+ @Override
+ public void accept(PacketBattleMessage pkt, FriendlyByteBuf buf) {
+ buf.writeInt(pkt.messageType.getValue());
+ buf.writeInt(pkt.entityIDFrom);
+ buf.writeInt(pkt.entityIDTo);
+ buf.writeUtf(Utility.serializeDimension(pkt.dimension));
+ buf.writeInt(pkt.amount);
+ buf.writeUtf(pkt.custom);
+ }
}
-
- public static PacketBattleMessage decode(FriendlyByteBuf buf) {
- return new PacketBattleMessage(
- MessageType.valueOf(
- buf.readInt()),
- buf.readInt(),
- buf.readInt(),
- Utility.deserializeDimension(buf.readUtf()),
- buf.readInt(),
- buf.readUtf());
+
+ public static class Decoder implements Function<FriendlyByteBuf, PacketBattleMessage> {
+ public Decoder() {}
+
+ @Override
+ public PacketBattleMessage apply(FriendlyByteBuf buf) {
+ return new PacketBattleMessage(
+ MessageType.valueOf(
+ buf.readInt()),
+ buf.readInt(),
+ buf.readInt(),
+ Utility.deserializeDimension(buf.readUtf()),
+ buf.readInt(),
+ buf.readUtf());
+ }
}
-
- public static void handle(final PacketBattleMessage pkt, Supplier<NetworkEvent.Context> ctx) {
- ctx.get().enqueueWork(() -> {
- DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> () -> TurnBasedMinecraftMod.proxy.handlePacket(pkt, ctx));
- });
- ctx.get().setPacketHandled(true);
+
+ public static class Consumer implements BiConsumer<PacketBattleMessage, CustomPayloadEvent.Context> {
+ public Consumer() {}
+
+ @Override
+ public void accept(PacketBattleMessage pkt, CustomPayloadEvent.Context ctx) {
+ ctx.enqueueWork(() -> {
+ DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> () -> TurnBasedMinecraftMod.proxy.handlePacket(pkt, ctx));
+ });
+ ctx.setPacketHandled(true);
+ }
}
}
package com.burnedkirby.TurnBasedMinecraft.common.networking;
-import java.util.function.Supplier;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
import com.burnedkirby.TurnBasedMinecraft.common.Battle;
import com.burnedkirby.TurnBasedMinecraft.common.TurnBasedMinecraftMod;
import net.minecraft.network.FriendlyByteBuf;
-import net.minecraftforge.network.NetworkEvent;
+import net.minecraftforge.event.network.CustomPayloadEvent;
public class PacketBattleRequestInfo
{
{
this.battleID = battleID;
}
-
- public static void encode(PacketBattleRequestInfo pkt, FriendlyByteBuf buf) {
- buf.writeInt(pkt.battleID);
+
+ public static class Encoder implements BiConsumer<PacketBattleRequestInfo, FriendlyByteBuf> {
+ public Encoder() {}
+
+ @Override
+ public void accept(PacketBattleRequestInfo pkt, FriendlyByteBuf buf) {
+ buf.writeInt(pkt.battleID);
+ }
}
-
- public static PacketBattleRequestInfo decode(FriendlyByteBuf buf) {
- return new PacketBattleRequestInfo(buf.readInt());
+
+ public static class Decoder implements Function<FriendlyByteBuf, PacketBattleRequestInfo> {
+ public Decoder() {}
+
+ @Override
+ public PacketBattleRequestInfo apply(FriendlyByteBuf buf) {
+ return new PacketBattleRequestInfo(buf.readInt());
+ }
}
-
- public static void handle(final PacketBattleRequestInfo pkt, Supplier<NetworkEvent.Context> ctx) {
- ctx.get().enqueueWork(() -> {
- Battle b = TurnBasedMinecraftMod.proxy.getBattleManager().getBattleByID(pkt.battleID);
- if(b == null) {
- return;
- }
- TurnBasedMinecraftMod.getHandler().reply(new PacketBattleInfo(b.getSideAIDs(), b.getSideBIDs(), b.getTimerNanos(), TurnBasedMinecraftMod.proxy.getConfig().getDecisionDurationNanos(), !TurnBasedMinecraftMod.proxy.getConfig().isBattleDecisionDurationForever()), ctx.get());
- });
- ctx.get().setPacketHandled(true);
+
+ public static class Consumer implements BiConsumer<PacketBattleRequestInfo, CustomPayloadEvent.Context> {
+ public Consumer() {}
+
+ @Override
+ public void accept(PacketBattleRequestInfo pkt, CustomPayloadEvent.Context ctx) {
+ ctx.enqueueWork(() -> {
+ Battle b = TurnBasedMinecraftMod.proxy.getBattleManager().getBattleByID(pkt.battleID);
+ if(b == null) {
+ return;
+ }
+ TurnBasedMinecraftMod.getHandler().reply(new PacketBattleInfo(b.getSideAIDs(), b.getSideBIDs(), b.getTimerNanos(), TurnBasedMinecraftMod.proxy.getConfig().getDecisionDurationNanos(), !TurnBasedMinecraftMod.proxy.getConfig().isBattleDecisionDurationForever()), ctx);
+ });
+ ctx.setPacketHandled(true);
+ }
}
}
import com.burnedkirby.TurnBasedMinecraft.common.TurnBasedMinecraftMod;
import net.minecraft.network.FriendlyByteBuf;
import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.event.network.CustomPayloadEvent;
import net.minecraftforge.fml.DistExecutor;
-import net.minecraftforge.network.NetworkEvent;
import java.util.HashMap;
import java.util.Map;
-import java.util.function.Supplier;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
public class PacketEditingMessage
{
this.entityInfo = entityInfo;
}
}
-
- public static void encode(PacketEditingMessage pkt, FriendlyByteBuf buf) {
- buf.writeInt(pkt.type.getValue());
- if(pkt.entityInfo.classType != null) {
- buf.writeUtf(pkt.entityInfo.classType.getName());
- } else {
- buf.writeUtf("unknown");
- }
- buf.writeBoolean(pkt.entityInfo.ignoreBattle);
- buf.writeInt(pkt.entityInfo.attackPower);
- buf.writeInt(pkt.entityInfo.attackProbability);
- buf.writeInt(pkt.entityInfo.attackVariance);
- buf.writeUtf(pkt.entityInfo.attackEffect.toString());
- buf.writeInt(pkt.entityInfo.attackEffectProbability);
- buf.writeInt(pkt.entityInfo.defenseDamage);
- buf.writeInt(pkt.entityInfo.defenseDamageProbability);
- buf.writeInt(pkt.entityInfo.evasion);
- buf.writeInt(pkt.entityInfo.speed);
- buf.writeUtf(pkt.entityInfo.category);
- buf.writeInt(pkt.entityInfo.decisionAttack);
- buf.writeInt(pkt.entityInfo.decisionDefend);
- buf.writeInt(pkt.entityInfo.decisionFlee);
- buf.writeUtf(pkt.entityInfo.customName);
+
+ public static class Encoder implements BiConsumer<PacketEditingMessage, FriendlyByteBuf> {
+ public Encoder() {}
+
+ @Override
+ public void accept(PacketEditingMessage pkt, FriendlyByteBuf buf) {
+ buf.writeInt(pkt.type.getValue());
+ if(pkt.entityInfo.classType != null) {
+ buf.writeUtf(pkt.entityInfo.classType.getName());
+ } else {
+ buf.writeUtf("unknown");
+ }
+ buf.writeBoolean(pkt.entityInfo.ignoreBattle);
+ buf.writeInt(pkt.entityInfo.attackPower);
+ buf.writeInt(pkt.entityInfo.attackProbability);
+ buf.writeInt(pkt.entityInfo.attackVariance);
+ buf.writeUtf(pkt.entityInfo.attackEffect.toString());
+ buf.writeInt(pkt.entityInfo.attackEffectProbability);
+ buf.writeInt(pkt.entityInfo.defenseDamage);
+ buf.writeInt(pkt.entityInfo.defenseDamageProbability);
+ buf.writeInt(pkt.entityInfo.evasion);
+ buf.writeInt(pkt.entityInfo.speed);
+ buf.writeUtf(pkt.entityInfo.category);
+ buf.writeInt(pkt.entityInfo.decisionAttack);
+ buf.writeInt(pkt.entityInfo.decisionDefend);
+ buf.writeInt(pkt.entityInfo.decisionFlee);
+ buf.writeUtf(pkt.entityInfo.customName);
+ }
}
-
- public static PacketEditingMessage decode(FriendlyByteBuf buf) {
- Type type = Type.valueOf(buf.readInt());
- EntityInfo einfo = new EntityInfo();
- try {
- einfo.classType = einfo.getClass().getClassLoader().loadClass(buf.readUtf());
- } catch (ClassNotFoundException e) { /* ignored */ }
- einfo.ignoreBattle = buf.readBoolean();
- einfo.attackPower = buf.readInt();
- einfo.attackProbability = buf.readInt();
- einfo.attackVariance = buf.readInt();
- einfo.attackEffect = EntityInfo.Effect.fromString(buf.readUtf());
- einfo.attackEffectProbability = buf.readInt();
- einfo.defenseDamage = buf.readInt();
- einfo.defenseDamageProbability = buf.readInt();
- einfo.evasion = buf.readInt();
- einfo.speed = buf.readInt();
- einfo.category = buf.readUtf();
- einfo.decisionAttack = buf.readInt();
- einfo.decisionDefend = buf.readInt();
- einfo.decisionFlee = buf.readInt();
- einfo.customName = buf.readUtf();
- return new PacketEditingMessage(type, einfo);
+
+ public static class Decoder implements Function<FriendlyByteBuf, PacketEditingMessage> {
+ public Decoder() {}
+
+ @Override
+ public PacketEditingMessage apply(FriendlyByteBuf buf) {
+ Type type = Type.valueOf(buf.readInt());
+ EntityInfo einfo = new EntityInfo();
+ try {
+ einfo.classType = einfo.getClass().getClassLoader().loadClass(buf.readUtf());
+ } catch (ClassNotFoundException e) { /* ignored */ }
+ einfo.ignoreBattle = buf.readBoolean();
+ einfo.attackPower = buf.readInt();
+ einfo.attackProbability = buf.readInt();
+ einfo.attackVariance = buf.readInt();
+ einfo.attackEffect = EntityInfo.Effect.fromString(buf.readUtf());
+ einfo.attackEffectProbability = buf.readInt();
+ einfo.defenseDamage = buf.readInt();
+ einfo.defenseDamageProbability = buf.readInt();
+ einfo.evasion = buf.readInt();
+ einfo.speed = buf.readInt();
+ einfo.category = buf.readUtf();
+ einfo.decisionAttack = buf.readInt();
+ einfo.decisionDefend = buf.readInt();
+ einfo.decisionFlee = buf.readInt();
+ einfo.customName = buf.readUtf();
+ return new PacketEditingMessage(type, einfo);
+ }
}
- public static void handle(final PacketEditingMessage pkt, Supplier<NetworkEvent.Context> ctx) {
- ctx.get().enqueueWork(() -> {
- DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> () -> TurnBasedMinecraftMod.proxy.handlePacket(pkt, ctx));
- });
- ctx.get().setPacketHandled(true);
+ public static class Consumer implements BiConsumer<PacketEditingMessage, CustomPayloadEvent.Context> {
+ public Consumer() {}
+
+ @Override
+ public void accept(PacketEditingMessage pkt, CustomPayloadEvent.Context ctx) {
+ ctx.enqueueWork(() -> {
+ DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> () -> TurnBasedMinecraftMod.proxy.handlePacket(pkt, ctx));
+ });
+ ctx.setPacketHandled(true);
+ }
}
}
package com.burnedkirby.TurnBasedMinecraft.common.networking;
-import java.util.function.Supplier;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
import com.burnedkirby.TurnBasedMinecraft.common.TurnBasedMinecraftMod;
import net.minecraft.network.FriendlyByteBuf;
import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.event.network.CustomPayloadEvent;
import net.minecraftforge.fml.DistExecutor;
-import net.minecraftforge.network.NetworkEvent;
public class PacketGeneralMessage
{
{
this.message = message;
}
-
- public static void encode(PacketGeneralMessage pkt, FriendlyByteBuf buf) {
- buf.writeUtf(pkt.message);
+
+ public static class Encoder implements BiConsumer<PacketGeneralMessage, FriendlyByteBuf> {
+ public Encoder() {}
+
+ @Override
+ public void accept(PacketGeneralMessage pkt, FriendlyByteBuf buf) {
+ buf.writeUtf(pkt.message);
+ }
}
-
- public static PacketGeneralMessage decode(FriendlyByteBuf buf) {
- return new PacketGeneralMessage(buf.readUtf());
+
+ public static class Decoder implements Function<FriendlyByteBuf, PacketGeneralMessage> {
+ public Decoder() {}
+
+ @Override
+ public PacketGeneralMessage apply(FriendlyByteBuf buf) {
+ return new PacketGeneralMessage(buf.readUtf());
+ }
}
-
- public static void handle(final PacketGeneralMessage pkt, Supplier<NetworkEvent.Context> ctx) {
- ctx.get().enqueueWork(() -> {
- DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> () -> TurnBasedMinecraftMod.proxy.handlePacket(pkt, ctx));
- });
- ctx.get().setPacketHandled(true);
+
+ public static class Consumer implements BiConsumer<PacketGeneralMessage, CustomPayloadEvent.Context> {
+ public Consumer() {}
+
+ @Override
+ public void accept(PacketGeneralMessage pkt, CustomPayloadEvent.Context ctx) {
+ ctx.enqueueWork(() -> {
+ DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> () -> TurnBasedMinecraftMod.proxy.handlePacket(pkt, ctx));
+ });
+ ctx.setPacketHandled(true);
+ }
}
}
"modid": "com_burnedkirby_turnbasedminecraft",
"name": "Turn Based Minecraft",
"description": "Changes battles to be turn-based.",
- "version": "1.23.1",
- "mcversion": "1.20.1",
+ "version": "1.24.0",
+ "mcversion": "1.20.2",
"url": "",
"updateUrl": "",
"authorList": ["Stephen Seo"],
projects / TurnBasedMinecraftMod / commitdiff
