id 'eclipse'
id 'idea'
id 'maven-publish'
- id 'net.neoforged.gradle.userdev' version '7.0.57'
+ id 'net.neoforged.gradle.userdev' version '7.0.80'
}
version = "1.25.0"
## Environment Properties
# The Minecraft version must agree with the Forge version to get a valid artifact
-minecraft_version=1.20.2
+minecraft_version=1.20.4
# 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.2,1.21)
+minecraft_version_range=[1.20.4,1.21)
# The Neo version must agree with the Minecraft version to get a valid artifact
-neo_version=20.2.88
+neo_version=20.4.108-beta
# The Neo version range can use any version of Neo as bounds or match the loader version range
-neo_version_range=[20.2,)
+neo_version_range=[20.4,)
# The loader version range can only use the major version of Neo/FML as bounds
-loader_version_range=[1,)
+loader_version_range=[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.25.0
+mod_version=1.25.1
# 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
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.neoforged.neoforge.network.PacketDistributor;
import java.util.ConcurrentModificationException;
import java.util.HashMap;
.getSideAEntrySet()) {
if (e.getValue().entity != null) {
addRenderableWidget(new EntitySelectionButton(width / 4 - 60, y, 120, 20, e.getValue().entity.getDisplayName(), e.getKey(), true, (button) -> {
- buttonActionEvent(button, ButtonAction.ATTACK_TARGET);
+ entityButtonActionEvent(button, ButtonAction.ATTACK_TARGET);
}));
} else {
addRenderableWidget(new EntitySelectionButton(width / 4 - 60, y, 120, 20, "Unknown", e.getKey(), true, (button) -> {
- buttonActionEvent(button, ButtonAction.ATTACK_TARGET);
+ entityButtonActionEvent(button, ButtonAction.ATTACK_TARGET);
}));
}
y += 20;
.getSideBEntrySet()) {
if (e.getValue().entity != null) {
addRenderableWidget(new EntitySelectionButton(width * 3 / 4 - 60, y, 120, 20, e.getValue().entity.getDisplayName(), e.getKey(), false, (button) -> {
- buttonActionEvent(button, ButtonAction.ATTACK_TARGET);
+ entityButtonActionEvent(button, ButtonAction.ATTACK_TARGET);
}));
} else {
addRenderableWidget(new EntitySelectionButton(width * 3 / 4 - 60, y, 120, 20, "Unknown", e.getKey(), false, (button) -> {
- buttonActionEvent(button, ButtonAction.ATTACK_TARGET);
+ entityButtonActionEvent(button, ButtonAction.ATTACK_TARGET);
}));
}
y += 20;
case SWITCH_ITEM:
info = "To which item will you switch to?";
for (int i = 0; i < 9; ++i) {
- addRenderableWidget(new ItemSelectionButton(width / 2 - 88 + i * 20, height - 19, 16, 16, "", i, (button) -> {
- buttonActionEvent(button, ButtonAction.DO_ITEM_SWITCH);
+ addRenderableWidget(new ItemSelectionButton(width / 2 - 88 + i * 20, height - 19, 16, 16, i, (button) -> {
+ itemButtonActionEvent(button, ButtonAction.DO_ITEM_SWITCH);
}));
}
addRenderableWidget(Button.builder(Component.literal("Cancel"), (button) -> {
case USE_ITEM:
info = "Which item will you use?";
for (int i = 0; i < 9; ++i) {
- addRenderableWidget(new ItemSelectionButton(width / 2 - 88 + i * 20, height - 19, 16, 16, "", i, (button) -> {
- buttonActionEvent(button, ButtonAction.DO_USE_ITEM);
+ addRenderableWidget(new ItemSelectionButton(width / 2 - 88 + i * 20, height - 19, 16, 16, i, (button) -> {
+ itemButtonActionEvent(button, ButtonAction.DO_USE_ITEM);
}));
}
addRenderableWidget(Button.builder(Component.literal("Cancel"), (button) -> {
setState(MenuState.ATTACK_TARGET);
break;
case DEFEND:
- TurnBasedMinecraftMod.getHandler().sendToServer(new PacketBattleDecision(
- TurnBasedMinecraftMod.proxy.getLocalBattle().getId(), Battle.Decision.DEFEND, 0));
+ PacketDistributor.SERVER.noArg().send(new PacketBattleDecision(
+ TurnBasedMinecraftMod.proxy.getLocalBattle().getId(), Battle.Decision.DEFEND, 0));
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));
+ PacketDistributor.SERVER.noArg().send(new PacketBattleDecision(
+ TurnBasedMinecraftMod.proxy.getLocalBattle().getId(), Battle.Decision.FLEE, 0));
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()));
- setState(MenuState.WAITING);
- } else {
- setState(MenuState.MAIN_MENU);
- }
+ // Invalid, but set menu to main menu anyways.
+ setState(MenuState.MAIN_MENU);
break;
case SWITCH_HELD_ITEM:
setState(MenuState.SWITCH_ITEM);
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()));
- if (((ItemSelectionButton) button).getID() >= 0 && ((ItemSelectionButton) button).getID() < 9) {
- Minecraft.getInstance().player.getInventory().selected = ((ItemSelectionButton) button).getID();
- }
- setState(MenuState.WAITING);
- } else {
- setState(MenuState.MAIN_MENU);
- }
+ // Invalid, but set menu to main menu anyways.
+ setState(MenuState.MAIN_MENU);
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()));
+ // Invalid, but set menu to main menu anyways.
+ setState(MenuState.MAIN_MENU);
+ break;
+ }
+ }
+
+ protected void entityButtonActionEvent(EntitySelectionButton button, ButtonAction action) {
+ if (action.equals(ButtonAction.ATTACK_TARGET)) {
+ PacketDistributor.SERVER.noArg().send(
+ new PacketBattleDecision(TurnBasedMinecraftMod.proxy.getLocalBattle().getId(),
+ Battle.Decision.ATTACK, ((EntitySelectionButton) button).getID()));
+ setState(MenuState.WAITING);
+ } else {
+ setState(MenuState.MAIN_MENU);
+ }
+ }
+
+ protected void itemButtonActionEvent(ItemSelectionButton button, ButtonAction action) {
+ switch (action) {
+ case DO_ITEM_SWITCH:
+ PacketDistributor.SERVER.noArg().send(
+ new PacketBattleDecision(TurnBasedMinecraftMod.proxy.getLocalBattle().getId(),
+ Battle.Decision.SWITCH_ITEM, button.getID()));
+ if (button.getID() >= 0 && button.getID() < 9) {
+ Minecraft.getInstance().player.getInventory().selected = button.getID();
+ }
setState(MenuState.WAITING);
- } else {
+ break;
+ case DO_USE_ITEM:
+ PacketDistributor.SERVER.noArg().send(
+ new PacketBattleDecision(TurnBasedMinecraftMod.proxy.getLocalBattle().getId(),
+ Battle.Decision.USE_ITEM, button.getID()));
+ setState(MenuState.WAITING);
+ break;
+ default:
setState(MenuState.MAIN_MENU);
- }
- break;
+ break;
}
}
import net.minecraft.sounds.SoundSource;
import net.minecraft.world.entity.Entity;
import net.minecraft.world.level.Level;
-import net.neoforged.neoforge.network.NetworkEvent;
+import net.neoforged.neoforge.network.handling.PlayPayloadContext;
public class ClientProxy extends CommonProxy {
private BattleGui battleGui = null;
}
@Override
- public <MSG> void handlePacket(MSG msg, NetworkEvent.Context ctx) {
+ public <MSG> void handlePacket(final MSG msg, final PlayPayloadContext ctx) {
if (msg.getClass() == PacketBattleMessage.class) {
PacketBattleMessage pkt = (PacketBattleMessage) msg;
Entity fromEntity = getEntity(pkt.getEntityIDFrom(), pkt.getDimension());
package com.burnedkirby.TurnBasedMinecraft.client;
-import com.burnedkirby.TurnBasedMinecraft.common.CommonProxy;
import com.burnedkirby.TurnBasedMinecraft.common.TurnBasedMinecraftMod;
-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.components.Renderable;
+import net.minecraft.client.gui.components.events.GuiEventListener;
+import net.minecraft.client.gui.narration.NarratableEntry;
import net.minecraft.client.gui.narration.NarratedElementType;
import net.minecraft.client.gui.narration.NarrationElementOutput;
import net.minecraft.network.chat.Component;
import net.minecraft.world.entity.Entity;
import net.minecraft.world.entity.LivingEntity;
-public class EntitySelectionButton extends AbstractButton {
- TBMButtonPress onPress;
+public class EntitySelectionButton implements Renderable, GuiEventListener, NarratableEntry {
+ private int x;
+ private int y;
+ private int width;
+ private int height;
+ private boolean focused;
+ private Button nestedButton;
+ TBMEntityButtonPress onPress;
private int entityID;
private boolean isSideA;
- public EntitySelectionButton(int x, int y, int widthIn, int heightIn, String buttonText, int entityID, boolean isSideA, TBMButtonPress onPress) {
- super(x, y, widthIn, heightIn, Component.literal(buttonText));
+ public EntitySelectionButton(int x, int y, int widthIn, int heightIn, String buttonText, int entityID, boolean isSideA, TBMEntityButtonPress onPress) {
+ this.x = x;
+ this.y = y;
+ this.width = widthIn;
+ this.height = heightIn;
this.onPress = onPress;
this.entityID = entityID;
this.isSideA = isSideA;
+ this.nestedButton = Button.builder(Component.literal(buttonText), (unused) -> {}).pos(x, y).size(widthIn, heightIn).build();
}
- public EntitySelectionButton(int x, int y, int widthIn, int heightIn, Component buttonTextComponent, int entityID, boolean isSideA, TBMButtonPress onPress) {
- super(x, y, widthIn, heightIn, buttonTextComponent);
+ public EntitySelectionButton(int x, int y, int widthIn, int heightIn, Component buttonTextComponent, int entityID, boolean isSideA, TBMEntityButtonPress onPress) {
+ this.x = x;
+ this.y = y;
+ this.width = widthIn;
+ this.height = heightIn;
this.onPress = onPress;
this.entityID = entityID;
this.isSideA = isSideA;
+ this.nestedButton = Button.builder(buttonTextComponent, (unused) -> {}).pos(x, y).size(widthIn, heightIn).build();
}
public int getID() {
@Override
public void render(GuiGraphics guiGraphics, int mouseX, int mouseY, float partialTicks) {
- super.render(guiGraphics, mouseX, mouseY, partialTicks);
+ this.nestedButton.render(guiGraphics, mouseX, mouseY, partialTicks);
Entity e = Minecraft.getInstance().level.getEntity(entityID);
if (e != null && e instanceof LivingEntity && ((LivingEntity) e).isAlive()) {
int health = (int) (((LivingEntity) e).getHealth() + 0.5f);
- int xpos = getX();
+ int xpos = this.x;
int xoffset;
if (isSideA) {
- xpos += getWidth() + 4;
+ xpos += this.width + 4;
xoffset = 4;
} else {
xpos -= 6;
xoffset = -4;
}
if (health > 200) {
- guiGraphics.fill(xpos, getY() + getHeight() * 4 / 5, xpos + 2, getY() + getHeight(), 0xFFFF0000);
- guiGraphics.fill(xpos, getY() + getHeight() * 3 / 5, xpos + 2, getY() + getHeight() * 4 / 5, 0xFFFFFF00);
- guiGraphics.fill(xpos, getY() + getHeight() * 2 / 5, xpos + 2, getY() + getHeight() * 3 / 5, 0xFF00FF00);
- guiGraphics.fill(xpos, getY() + getHeight() / 5, xpos + 2, getY() + getHeight() * 2 / 5, 0xFF00FFFF);
- guiGraphics.fill(xpos, getY(), xpos + 2, getY() + getHeight() / 5, 0xFF0000FF);
- int healthHeight = ((health - 200) * getHeight() / 100);
- guiGraphics.fill(xpos + xoffset, getY() + getHeight() - healthHeight, xpos + xoffset + 2, getY() + getHeight(), 0xFFFFFFFF);
+ guiGraphics.fill(xpos, this.y + this.height * 4 / 5, xpos + 2, this.y + this.height, 0xFFFF0000);
+ guiGraphics.fill(xpos, this.y + this.height * 3 / 5, xpos + 2, this.y + this.height * 4 / 5, 0xFFFFFF00);
+ guiGraphics.fill(xpos, this.y + this.height * 2 / 5, xpos + 2, this.y + this.height * 3 / 5, 0xFF00FF00);
+ guiGraphics.fill(xpos, this.y + this.height / 5, xpos + 2, this.y + this.height * 2 / 5, 0xFF00FFFF);
+ guiGraphics.fill(xpos, this.y, xpos + 2, this.y + this.height / 5, 0xFF0000FF);
+ int healthHeight = ((health - 200) * this.height / 100);
+ guiGraphics.fill(xpos + xoffset, this.y + this.height - healthHeight, xpos + xoffset + 2, this.y + this.height, 0xFFFFFFFF);
} else if (health > 100) {
- guiGraphics.fill(xpos, getY() + getHeight() * 4 / 5, xpos + 2, getY() + getHeight(), 0xFFFF0000);
- guiGraphics.fill(xpos, getY() + getHeight() * 3 / 5, xpos + 2, getY() + getHeight() * 4 / 5, 0xFFFFFF00);
- guiGraphics.fill(xpos, getY() + getHeight() * 2 / 5, xpos + 2, getY() + getHeight() * 3 / 5, 0xFF00FF00);
- guiGraphics.fill(xpos, getY() + getHeight() / 5, xpos + 2, getY() + getHeight() * 2 / 5, 0xFF00FFFF);
- int healthHeight = ((health - 100) * getHeight() / 100);
- guiGraphics.fill(xpos + xoffset, getY() + getHeight() - healthHeight, xpos + xoffset + 2, getY() + getHeight(), 0xFF0000FF);
+ guiGraphics.fill(xpos, this.y + this.height * 4 / 5, xpos + 2, this.y + this.height, 0xFFFF0000);
+ guiGraphics.fill(xpos, this.y + this.height * 3 / 5, xpos + 2, this.y + this.height * 4 / 5, 0xFFFFFF00);
+ guiGraphics.fill(xpos, this.y + this.height * 2 / 5, xpos + 2, this.y + this.height * 3 / 5, 0xFF00FF00);
+ guiGraphics.fill(xpos, this.y + this.height / 5, xpos + 2, this.y + this.height * 2 / 5, 0xFF00FFFF);
+ int healthHeight = ((health - 100) * this.height / 100);
+ guiGraphics.fill(xpos + xoffset, this.y + this.height - healthHeight, xpos + xoffset + 2, this.y + this.height, 0xFF0000FF);
} else if (health > 50) {
- guiGraphics.fill(xpos, getY() + getHeight() * 4 / 5, xpos + 2, getY() + getHeight(), 0xFFFF0000);
- guiGraphics.fill(xpos, getY() + getHeight() * 3 / 5, xpos + 2, getY() + getHeight() * 4 / 5, 0xFFFFFF00);
- guiGraphics.fill(xpos, getY() + getHeight() * 2 / 5, xpos + 2, getY() + getHeight() * 3 / 5, 0xFF00FF00);
- int healthHeight = ((health - 50) * getHeight() / 50);
- guiGraphics.fill(xpos + xoffset, getY() + getHeight() - healthHeight, xpos + xoffset + 2, getY() + getHeight(), 0xFF00FFFF);
+ guiGraphics.fill(xpos, this.y + this.height * 4 / 5, xpos + 2, this.y + this.height, 0xFFFF0000);
+ guiGraphics.fill(xpos, this.y + this.height * 3 / 5, xpos + 2, this.y + this.height * 4 / 5, 0xFFFFFF00);
+ guiGraphics.fill(xpos, this.y + this.height * 2 / 5, xpos + 2, this.y + this.height * 3 / 5, 0xFF00FF00);
+ int healthHeight = ((health - 50) * this.height / 50);
+ guiGraphics.fill(xpos + xoffset, this.y + this.height - healthHeight, xpos + xoffset + 2, this.y + this.height, 0xFF00FFFF);
} else if (health > 20) {
- guiGraphics.fill(xpos, getY() + getHeight() * 4 / 5, xpos + 2, getY() + getHeight(), 0xFFFF0000);
- guiGraphics.fill(xpos, getY() + getHeight() * 3 / 5, xpos + 2, getY() + getHeight() * 4 / 5, 0xFFFFFF00);
- int healthHeight = ((health - 20) * getHeight() / 30);
- guiGraphics.fill(xpos + xoffset, getY() + getHeight() - healthHeight, xpos + xoffset + 2, getY() + getHeight(), 0xFF00FF00);
+ guiGraphics.fill(xpos, this.y + this.height * 4 / 5, xpos + 2, this.y + this.height, 0xFFFF0000);
+ guiGraphics.fill(xpos, this.y + this.height * 3 / 5, xpos + 2, this.y + this.height * 4 / 5, 0xFFFFFF00);
+ int healthHeight = ((health - 20) * this.height / 30);
+ guiGraphics.fill(xpos + xoffset, this.y + this.height - healthHeight, xpos + xoffset + 2, this.y + this.height, 0xFF00FF00);
} else if (health > 10) {
- guiGraphics.fill(xpos, getY() + getHeight() * 4 / 5, xpos + 2, getY() + getHeight(), 0xFFFF0000);
- int healthHeight = ((health - 10) * getHeight() / 10);
- guiGraphics.fill(xpos + xoffset, getY() + getHeight() - healthHeight, xpos + xoffset + 2, getY() + getHeight(), 0xFFFFFF00);
+ guiGraphics.fill(xpos, this.y + this.height * 4 / 5, xpos + 2, this.y + this.height, 0xFFFF0000);
+ int healthHeight = ((health - 10) * this.height / 10);
+ guiGraphics.fill(xpos + xoffset, this.y + this.height - healthHeight, xpos + xoffset + 2, this.y + this.height, 0xFFFFFF00);
} else {
- int healthHeight = (health * getHeight() / 10);
- guiGraphics.fill(xpos + xoffset, getY() + getHeight() - healthHeight, xpos + xoffset + 2, getY() + getHeight(), 0xFFFF0000);
+ int healthHeight = (health * this.height / 10);
+ guiGraphics.fill(xpos + xoffset, this.y + this.height - healthHeight, xpos + xoffset + 2, this.y + this.height, 0xFFFF0000);
}
}
}
+ public void onPress() {
+ onPress.onPress(this);
+ }
+
@Override
- protected void updateWidgetNarration(NarrationElementOutput p_259858_) {
- p_259858_.add(NarratedElementType.HINT, TurnBasedMinecraftMod.proxy.getEntity(entityID, Minecraft.getInstance().level.dimension()).getName());
+ public void setFocused(boolean b) {
+ this.focused = b;
}
@Override
- public void onPress() {
- onPress.onPress(this);
+ public boolean isFocused() {
+ return focused;
+ }
+
+ @Override
+ public NarrationPriority narrationPriority() {
+ return NarrationPriority.FOCUSED;
+ }
+
+ @Override
+ public void updateNarration(NarrationElementOutput narrationElementOutput) {
+ narrationElementOutput.add(NarratedElementType.HINT, TurnBasedMinecraftMod.proxy.getEntity(entityID, Minecraft.getInstance().level.dimension()).getName());
+ }
+
+ @Override
+ public boolean mouseClicked(double x, double y, int unknown) {
+ if (unknown == 0 && x >= this.x && y >= this.y && x <= (double)(this.x + this.width) && y <= (double)(this.y + this.height)) {
+ onPress();
+ return true;
+ }
+ return false;
}
}
package com.burnedkirby.TurnBasedMinecraft.client;
-import com.mojang.blaze3d.vertex.PoseStack;
import net.minecraft.client.gui.GuiGraphics;
-import net.minecraft.client.gui.components.AbstractButton;
+import net.minecraft.client.gui.components.Renderable;
+import net.minecraft.client.gui.components.events.GuiEventListener;
+import net.minecraft.client.gui.narration.NarratableEntry;
import net.minecraft.client.gui.narration.NarratedElementType;
import net.minecraft.client.gui.narration.NarrationElementOutput;
-import net.minecraft.network.chat.Component;
-public class ItemSelectionButton extends AbstractButton {
-
- TBMButtonPress onPress;
+public class ItemSelectionButton implements Renderable, GuiEventListener, NarratableEntry {
+ private int x;
+ private int y;
+ private int width;
+ private int height;
+ TBMItemButtonPress onPress;
private int itemStackID;
- public ItemSelectionButton(int x, int y, int widthIn, int heightIn, String buttonText, int itemStackID, TBMButtonPress onPress) {
- super(x, y, widthIn, heightIn, Component.literal(buttonText));
+ public ItemSelectionButton(int x, int y, int widthIn, int heightIn, int itemStackID, TBMItemButtonPress onPress) {
+ this.x = x;
+ this.y = y;
+ this.width = widthIn;
+ this.height = heightIn;
this.onPress = onPress;
this.itemStackID = itemStackID;
}
@Override
public void render(GuiGraphics guiGraphics, int mouseX, int mouseY, float unk) {
- if (visible) {
- boolean hovered = mouseX >= getX() && mouseY >= getY() && mouseX < getX() + getWidth() && mouseY < getY() + getHeight();
- if (hovered) {
- guiGraphics.fill(getX(), getY(), getX() + getWidth(), getY() + getHeight(), 0x80FFFFFF);
- } else {
- guiGraphics.fill(getX(), getY(), getX() + getWidth(), getY() + getHeight(), 0x20707070);
- }
+ boolean hovered = mouseX >= this.x && mouseY >= this.y && mouseX < this.x + this.width && mouseY < this.y + this.height;
+ if (hovered) {
+ guiGraphics.fill(this.x, this.y, this.x + this.width, this.y + this.height, 0x80FFFFFF);
+ } else {
+ guiGraphics.fill(this.x, this.y, this.x + this.width, this.y + this.height, 0x20707070);
}
}
+ public void onPress() {
+ onPress.onPress(this);
+ }
+
@Override
- protected void updateWidgetNarration(NarrationElementOutput p_259858_) {
- p_259858_.add(NarratedElementType.HINT, "Item " + this.itemStackID);
+ public void setFocused(boolean b) {
+
}
@Override
- public void onPress() {
- onPress.onPress(this);
+ public boolean isFocused() {
+ return false;
+ }
+
+ @Override
+ public NarrationPriority narrationPriority() {
+ return null;
+ }
+
+ @Override
+ public void updateNarration(NarrationElementOutput narrationElementOutput) {
+ narrationElementOutput.add(NarratedElementType.HINT, "Item " + this.itemStackID);
+ }
+
+ @Override
+ public boolean mouseClicked(double x, double y, int unknown) {
+ if (unknown == 0 && x >= this.x && y >= this.y && x <= (double)(this.x + this.width) && y <= (double)(this.y + this.height)) {
+ onPress();
+ return true;
+ }
+ return false;
}
}
\ No newline at end of file
--- /dev/null
+package com.burnedkirby.TurnBasedMinecraft.client;
+
+public interface TBMEntityButtonPress {
+ void onPress(EntitySelectionButton button);
+}
--- /dev/null
+package com.burnedkirby.TurnBasedMinecraft.client;
+
+public interface TBMItemButtonPress {
+ void onPress(ItemSelectionButton button);
+}
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"));
+ PacketDistributor.PLAYER.with((ServerPlayer)editingInfo.editor).send(new PacketGeneralMessage("Cannot edit custom name from entity without custom name"));
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() + "\""));
+ PacketDistributor.PLAYER.with((ServerPlayer)editingInfo.editor).send(new PacketGeneralMessage("Editing custom name \"" + event.getEntity().getCustomName().getString() + "\""));
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));
+ PacketDistributor.PLAYER.with((ServerPlayer)editingInfo.editor).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
}
else
{
{
editingInfo.entityInfo = editingInfo.entityInfo.clone();
}
- TurnBasedMinecraftMod.getHandler().send(PacketDistributor.PLAYER.with(() -> (ServerPlayer)editingInfo.editor), new PacketGeneralMessage("Editing entity \"" + editingInfo.entityInfo.classType.getName() + "\""));
+ PacketDistributor.PLAYER.with((ServerPlayer)editingInfo.editor).send(new PacketGeneralMessage("Editing entity \"" + editingInfo.entityInfo.classType.getName() + "\""));
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));
+ PacketDistributor.PLAYER.with((ServerPlayer)editingInfo.editor).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
}
return;
}
}
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);
+ PacketDistributor.PLAYER.with((ServerPlayer)p.entity).send(infoPacket);
}
}
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);
+ PacketDistributor.PLAYER.with((ServerPlayer)p.entity).send(packet);
}
}
}
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));
+ PacketDistributor.PLAYER.with((ServerPlayer)c.entity).send(new PacketBattleMessage(PacketBattleMessage.MessageType.ENDED, 0, 0, dimension, 0));
}
battleManager.addRecentlyLeftBattle(c);
}
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!"));
+ PacketDistributor.PLAYER.with((ServerPlayer)c.entity).send(new PacketGeneralMessage("You just left battle! " + config.getLeaveBattleCooldownSeconds() + " seconds until you can attack/be-attacked again!"));
}
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."));
+ PacketDistributor.PLAYER.with((ServerPlayer)entry.getValue().entity).send(new PacketGeneralMessage("Timer ended, you can now attack/be-attacked again."));
}
}
}
import net.minecraft.world.entity.Entity;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.level.Level;
-import net.neoforged.neoforge.network.NetworkEvent;
+import net.neoforged.neoforge.network.handling.PlayPayloadContext;
import net.neoforged.neoforge.server.ServerLifecycleHooks;
import org.apache.logging.log4j.Logger;
return ServerLifecycleHooks.getCurrentServer().getLevel(dim).getEntity(id);
}
- public <MSG> void handlePacket(MSG msg, NetworkEvent.Context ctx) {}
+ public <MSG> void handlePacket(final MSG msg, final PlayPayloadContext 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"));
+ PacketDistributor.PLAYER.with((ServerPlayer)event.getEntity()).send(new PacketGeneralMessage("Left battle due to moving to a different dimension"));
}
}
}
import net.minecraft.network.chat.MutableComponent;
import net.minecraft.resources.ResourceLocation;
import net.minecraft.server.level.ServerPlayer;
+import net.neoforged.bus.api.IEventBus;
import net.neoforged.bus.api.SubscribeEvent;
import net.neoforged.fml.loading.FMLEnvironment;
import net.neoforged.neoforge.common.NeoForge;
import net.neoforged.fml.event.lifecycle.FMLClientSetupEvent;
import net.neoforged.fml.event.lifecycle.FMLCommonSetupEvent;
import net.neoforged.fml.event.lifecycle.FMLDedicatedServerSetupEvent;
-import net.neoforged.fml.javafmlmod.FMLJavaModLoadingContext;
-import net.neoforged.neoforge.network.NetworkRegistry;
+import net.neoforged.neoforge.network.event.RegisterPayloadHandlerEvent;
+import net.neoforged.neoforge.network.registration.IPayloadRegistrar;
import net.neoforged.neoforge.network.PacketDistributor;
-import net.neoforged.neoforge.network.simple.SimpleChannel;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
private static final String PROTOCOL_VERSION = Integer.toString(3);
private static final ResourceLocation HANDLER_ID = new ResourceLocation(MODID, "main_channel");
- private static final SimpleChannel HANDLER = NetworkRegistry.ChannelBuilder
- .named(HANDLER_ID)
- .clientAcceptedVersions(PROTOCOL_VERSION::equals)
- .serverAcceptedVersions(PROTOCOL_VERSION::equals)
- .networkProtocolVersion(() -> PROTOCOL_VERSION)
- .simpleChannel();
protected static Logger logger = LogManager.getLogger();
public static ResourceLocation getNetResourceLocation() {
return HANDLER_ID;
}
- public static SimpleChannel getHandler() {
- return HANDLER;
+ public static CommonProxy proxy;
+
+ public TurnBasedMinecraftMod(IEventBus eventBus) {
+ eventBus.addListener(this::firstInit);
+ eventBus.addListener(this::secondInitClient);
+ eventBus.addListener(this::secondInitServer);
+ eventBus.addListener(this::registerNetwork);
+ NeoForge.EVENT_BUS.register(this);
}
- public static CommonProxy proxy;
+ private void registerNetwork(final RegisterPayloadHandlerEvent event) {
+ final IPayloadRegistrar registrar = event.registrar(MODID);
- public TurnBasedMinecraftMod() {
- FMLJavaModLoadingContext.get().getModEventBus().addListener(this::firstInit);
- FMLJavaModLoadingContext.get().getModEventBus().addListener(this::secondInitClient);
- FMLJavaModLoadingContext.get().getModEventBus().addListener(this::secondInitServer);
+ registrar.play(PacketBattleDecision.ID, PacketBattleDecision::new, handler -> handler
+ .server(PacketBattleDecision.PayloadHandler.getInstance()::handleData));
- NeoForge.EVENT_BUS.register(this);
+ registrar.play(PacketBattleInfo.ID, PacketBattleInfo::new, handler -> handler
+ .client(PacketBattleInfo.PayloadHandler.getInstance()::handleData));
+
+ registrar.play(PacketBattleMessage.ID, PacketBattleMessage::new, handler -> handler
+ .client(PacketBattleMessage.PayloadHandler.getInstance()::handleData));
+
+ registrar.play(PacketBattleRequestInfo.ID, PacketBattleRequestInfo::new, handler -> handler
+ .server(PacketBattleRequestInfo.PayloadHandler.getInstance()::handleData));
+
+ registrar.play(PacketEditingMessage.ID, PacketEditingMessage::new, handler -> handler
+ .client(PacketEditingMessage.PayloadHandler.getInstance()::handleData));
+
+ registrar.play(PacketGeneralMessage.ID, PacketGeneralMessage::new, handler -> handler
+ .client(PacketGeneralMessage.PayloadHandler.getInstance()::handleData));
+
+ logger.debug("Register packets com_burnedkirby_turnbasedminecraft");
}
private void firstInit(final FMLCommonSetupEvent event) {
proxy.setLogger(logger);
proxy.initialize();
- // register packets
- int packetHandlerID = 0;
- HANDLER.registerMessage(
- packetHandlerID++,
- PacketBattleInfo.class,
- new PacketBattleInfo.Encoder(),
- new PacketBattleInfo.Decoder(),
- new PacketBattleInfo.Consumer());
- HANDLER.registerMessage(
- packetHandlerID++,
- PacketBattleRequestInfo.class,
- new PacketBattleRequestInfo.Encoder(),
- new PacketBattleRequestInfo.Decoder(),
- new PacketBattleRequestInfo.Consumer());
- HANDLER.registerMessage(
- packetHandlerID++,
- PacketBattleDecision.class,
- new PacketBattleDecision.Encoder(),
- new PacketBattleDecision.Decoder(),
- new PacketBattleDecision.Consumer());
- HANDLER.registerMessage(
- packetHandlerID++,
- PacketBattleMessage.class,
- new PacketBattleMessage.Encoder(),
- new PacketBattleMessage.Decoder(),
- new PacketBattleMessage.Consumer());
- HANDLER.registerMessage(
- packetHandlerID++,
- PacketGeneralMessage.class,
- new PacketGeneralMessage.Encoder(),
- new PacketGeneralMessage.Decoder(),
- new PacketGeneralMessage.Consumer());
- HANDLER.registerMessage(
- packetHandlerID++,
- PacketEditingMessage.class,
- new PacketEditingMessage.Encoder(),
- new PacketEditingMessage.Decoder(),
- new PacketEditingMessage.Consumer());
-
// register event handler(s)
NeoForge.EVENT_BUS.register(new AttackEventHandler());
NeoForge.EVENT_BUS.register(new PlayerJoinEventHandler());
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"));
+ PacketDistributor.PLAYER.with(player).send(new PacketGeneralMessage("OP disabled turn-based-combat for everyone"));
}
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"));
+ PacketDistributor.PLAYER.with(player).send(new PacketGeneralMessage("OP enabled turn-based-combat for everyone"));
}
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"));
+ PacketDistributor.PLAYER.with(player).send(new PacketGeneralMessage("OP enabled turn-based-combat for you"));
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"));
+ PacketDistributor.PLAYER.with(player).send(new PacketGeneralMessage("OP disabled turn-based-combat for you"));
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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} else {
proxy.setEditingPlayer(player);
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
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"));
+ PacketDistributor.PLAYER.with(player).send(new PacketGeneralMessage("An error occurred while attempting to save an entry to the config"));
proxy.removeEditingInfo(player.getId());
} else {
proxy.removeEditingInfo(player.getId());
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketGeneralMessage("Entity info saved in config and loaded."));
+ PacketDistributor.PLAYER.with(player).send(new PacketGeneralMessage("Entity info saved in config and loaded."));
}
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} 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."));
+ PacketDistributor.PLAYER.with(player).send(new PacketGeneralMessage("Cancelled editing entry."));
}
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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} else {
proxy.setEditingPlayer(player);
proxy.getEditingInfo(player.getId()).isEditingCustomName = true;
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} 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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_IGNORE_BATTLE));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} 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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} 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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_ATTACK_POWER));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} 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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} 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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_ATTACK_PROBABILITY));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} 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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} 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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_ATTACK_VARIANCE));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} 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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} 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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_ATTACK_EFFECT));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} 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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} 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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_ATTACK_EFFECT_PROBABILITY));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} 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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} 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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_DEFENSE_DAMAGE));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} 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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} 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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_DEFENSE_DAMAGE_PROBABILITY));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} 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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} 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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_EVASION));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} 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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} 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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_SPEED));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} 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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} 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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_CATEGORY));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} 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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} 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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_DECISION_ATTACK));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} 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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} 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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_DECISION_DEFEND));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} 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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} 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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_DECISION_FLEE));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} 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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
} else if (editingInfo != null) {
- getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
} 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));
+ PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.SERVER_EDIT));
return 1;
})
.then(Commands.literal("leave_battle_cooldown").executes(c -> {
import com.burnedkirby.TurnBasedMinecraft.common.TurnBasedMinecraftMod;
import com.burnedkirby.TurnBasedMinecraft.common.Battle.Decision;
-import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import net.minecraft.resources.ResourceLocation;
import net.minecraft.network.FriendlyByteBuf;
-import net.neoforged.neoforge.network.NetworkEvent;
-import net.neoforged.neoforge.network.simple.MessageFunctions;
+import net.minecraft.world.entity.player.Player;
+import net.neoforged.neoforge.network.handling.PlayPayloadContext;
-public class PacketBattleDecision
+public class PacketBattleDecision implements CustomPacketPayload
{
+ public static final ResourceLocation ID = new ResourceLocation(TurnBasedMinecraftMod.MODID, "network_packetbattledecision");
+
private int battleID;
private Battle.Decision decision;
private int targetIDOrItemID;
this.targetIDOrItemID = targetIDOrItemID;
}
- public static class Encoder implements MessageFunctions.MessageEncoder<PacketBattleDecision> {
- public Encoder() {}
+ public PacketBattleDecision(final FriendlyByteBuf buf) {
+ this.battleID = buf.readInt();
+ this.decision = Decision.valueOf(buf.readInt());
+ this.targetIDOrItemID = buf.readInt();
+ }
- @Override
- public void encode(PacketBattleDecision pkt, FriendlyByteBuf buf) {
- buf.writeInt(pkt.battleID);
- buf.writeInt(pkt.decision.getValue());
- buf.writeInt(pkt.targetIDOrItemID);
- }
+ @Override
+ public void write(FriendlyByteBuf buf) {
+ buf.writeInt(battleID);
+ buf.writeInt(decision.getValue());
+ buf.writeInt(targetIDOrItemID);
}
- public static class Decoder implements MessageFunctions.MessageDecoder<PacketBattleDecision> {
- public Decoder() {}
+ @Override
+ public ResourceLocation id() {
+ return ID;
+ }
+
+ public static class PayloadHandler {
+ private static final PayloadHandler INSTANCE = new PayloadHandler();
- @Override
- public PacketBattleDecision decode(FriendlyByteBuf buf) {
- return new PacketBattleDecision(buf.readInt(), Decision.valueOf(buf.readInt()), buf.readInt());
+ public static PayloadHandler getInstance() {
+ return INSTANCE;
}
- }
- public static class Consumer implements MessageFunctions.MessageConsumer<PacketBattleDecision> {
- public Consumer() {}
-
- @Override
- public void handle(PacketBattleDecision pkt, NetworkEvent.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);
+ public void handleData(final PacketBattleDecision pkt, final PlayPayloadContext ctx) {
+ ctx.workHandler().submitAsync(() -> {
+ Battle b = TurnBasedMinecraftMod.proxy.getBattleManager().getBattleByID(pkt.battleID);
+ if(b != null)
+ {
+ Player player = ctx.player().get();
+ b.setDecision(player.getId(), pkt.decision, pkt.targetIDOrItemID);
+ }
+ }).exceptionally(e -> {
+ ctx.packetHandler().disconnect(Component.literal("Exception handling PacketBattleDecision! " + e.getMessage()));
+ return null;
+ });
}
}
}
import com.burnedkirby.TurnBasedMinecraft.common.TurnBasedMinecraftMod;
import net.minecraft.client.Minecraft;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import net.minecraft.resources.ResourceLocation;
import net.minecraft.world.entity.Entity;
import net.minecraft.network.FriendlyByteBuf;
-import net.neoforged.neoforge.network.NetworkEvent;
-import net.neoforged.neoforge.network.simple.MessageFunctions;
+import net.neoforged.neoforge.network.handling.PlayPayloadContext;
-public class PacketBattleInfo
+public class PacketBattleInfo implements CustomPacketPayload
{
+ public static final ResourceLocation ID = new ResourceLocation(TurnBasedMinecraftMod.MODID, "network_packetbattleinfo");
private Collection<Integer> sideA;
private Collection<Integer> sideB;
private long decisionNanos;
this.turnTimerEnabled = turnTimerEnabled;
}
- public static class Encoder implements MessageFunctions.MessageEncoder<PacketBattleInfo> {
- public Encoder() {}
-
- @Override
- public 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 PacketBattleInfo(final FriendlyByteBuf buf) {
+ int sideACount = buf.readInt();
+ int sideBCount = buf.readInt();
+ this.sideA = new ArrayList<>(sideACount);
+ this.sideB = new ArrayList<>(sideBCount);
+ for (int i = 0; i < sideACount; ++i) {
+ this.sideA.add(buf.readInt());
+ }
+ for (int i = 0; i < sideBCount; ++i) {
+ this.sideB.add(buf.readInt());
}
+ this.decisionNanos = buf.readLong();
+ this.maxDecisionNanos = buf.readLong();
+ this.turnTimerEnabled = buf.readBoolean();
}
- public static class Decoder implements MessageFunctions.MessageDecoder<PacketBattleInfo> {
- public Decoder() {}
-
- @Override
- public 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 write(FriendlyByteBuf buf) {
+ buf.writeInt(sideA.size());
+ buf.writeInt(sideB.size());
+ for(Integer id : sideA) {
+ buf.writeInt(id);
+ }
+ for(Integer id : sideB) {
+ buf.writeInt(id);
}
+ buf.writeLong(decisionNanos);
+ buf.writeLong(maxDecisionNanos);
+ buf.writeBoolean(turnTimerEnabled);
}
- public static class Consumer implements MessageFunctions.MessageConsumer<PacketBattleInfo> {
- public Consumer() {}
+ @Override
+ public ResourceLocation id() {
+ return ID;
+ }
+
+ public static class PayloadHandler {
+ private static final PayloadHandler INSTANCE = new PayloadHandler();
+
+ public static PayloadHandler getInstance() {
+ return INSTANCE;
+ }
- @Override
- public void handle(PacketBattleInfo pkt, NetworkEvent.Context ctx) {
- ctx.enqueueWork(() -> {
+ public void handleData(final PacketBattleInfo pkt, final PlayPayloadContext ctx) {
+ ctx.workHandler().submitAsync(() -> {
if(TurnBasedMinecraftMod.proxy.getLocalBattle() == null)
{
return;
TurnBasedMinecraftMod.proxy.setBattleGuiBattleChanged();
TurnBasedMinecraftMod.proxy.setBattleGuiTurnTimerEnabled(pkt.turnTimerEnabled);
TurnBasedMinecraftMod.proxy.setBattleGuiTurnTimerMax((int)(pkt.maxDecisionNanos / 1000000000L));
+ }).exceptionally(e -> {
+ ctx.packetHandler().disconnect(Component.literal("Exception handling PacketBattleInfo! " + e.getMessage()));
+ return null;
});
- ctx.setPacketHandled(true);
}
}
}
import com.burnedkirby.TurnBasedMinecraft.common.Utility;
import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
import net.minecraft.resources.ResourceKey;
+import net.minecraft.resources.ResourceLocation;
import net.minecraft.world.level.Level;
import net.neoforged.fml.loading.FMLEnvironment;
-import net.neoforged.neoforge.network.NetworkEvent;
-import net.neoforged.neoforge.network.simple.MessageFunctions;
+import net.neoforged.neoforge.network.handling.PlayPayloadContext;
-public class PacketBattleMessage
+public class PacketBattleMessage implements CustomPacketPayload
{
+ public static final ResourceLocation ID = new ResourceLocation(TurnBasedMinecraftMod.MODID, "network_packetbattlemessage");
+
+ @Override
+ public void write(FriendlyByteBuf buf) {
+ buf.writeInt(messageType.getValue());
+ buf.writeInt(entityIDFrom);
+ buf.writeInt(entityIDTo);
+ buf.writeUtf(Utility.serializeDimension(dimension));
+ buf.writeInt(amount);
+ buf.writeUtf(custom);
+ }
+
+ @Override
+ public ResourceLocation id() {
+ return ID;
+ }
+
public enum MessageType
{
ENTERED(0),
this.custom = custom;
}
- public static class Encoder implements MessageFunctions.MessageEncoder<PacketBattleMessage> {
- public Encoder() {}
-
- @Override
- public 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 PacketBattleMessage(final FriendlyByteBuf buf) {
+ this.messageType = MessageType.valueOf(buf.readInt());
+ this.entityIDFrom = buf.readInt();
+ this.entityIDTo = buf.readInt();
+ this.dimension = Utility.deserializeDimension(buf.readUtf());
+ this.amount = buf.readInt();
+ this.custom = buf.readUtf();
}
- public static class Decoder implements MessageFunctions.MessageDecoder<PacketBattleMessage> {
- public Decoder() {}
-
- @Override
- public 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 PayloadHandler {
+ private static final PayloadHandler INSTANCE = new PayloadHandler();
- public static class Consumer implements MessageFunctions.MessageConsumer<PacketBattleMessage> {
- public Consumer() {}
+ public static PayloadHandler getInstance() {
+ return INSTANCE;
+ }
- @Override
- public void handle(PacketBattleMessage pkt, NetworkEvent.Context ctx) {
- ctx.enqueueWork(() -> {
+ public void handleData(final PacketBattleMessage pkt, final PlayPayloadContext ctx) {
+ ctx.workHandler().submitAsync(() -> {
if (FMLEnvironment.dist.isClient()) {
TurnBasedMinecraftMod.proxy.handlePacket(pkt, ctx);
}
+ }).exceptionally(e -> {
+ ctx.packetHandler().disconnect(Component.literal("Exception handling PacketBattleMessage! " + e.getMessage()));
+ return null;
});
- ctx.setPacketHandled(true);
}
}
}
import com.burnedkirby.TurnBasedMinecraft.common.TurnBasedMinecraftMod;
import net.minecraft.network.FriendlyByteBuf;
-import net.neoforged.neoforge.network.NetworkEvent;
-import net.neoforged.neoforge.network.simple.MessageFunctions;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import net.minecraft.resources.ResourceLocation;
+import net.neoforged.neoforge.network.handling.PlayPayloadContext;
-public class PacketBattleRequestInfo
+public class PacketBattleRequestInfo implements CustomPacketPayload
{
+ public static final ResourceLocation ID = new ResourceLocation(TurnBasedMinecraftMod.MODID, "network_packetbattlerequestinfo");
+
private int battleID;
public PacketBattleRequestInfo() {}
this.battleID = battleID;
}
- public static class Encoder implements MessageFunctions.MessageEncoder<PacketBattleRequestInfo> {
- public Encoder() {}
-
- @Override
- public void encode(PacketBattleRequestInfo pkt, FriendlyByteBuf buf) {
- buf.writeInt(pkt.battleID);
- }
+ public PacketBattleRequestInfo(final FriendlyByteBuf buf) {
+ battleID = buf.readInt();
}
- public static class Decoder implements MessageFunctions.MessageDecoder<PacketBattleRequestInfo> {
- public Decoder() {}
+ @Override
+ public void write(FriendlyByteBuf buf) {
+ buf.writeInt(battleID);
+ }
- @Override
- public PacketBattleRequestInfo decode(FriendlyByteBuf buf) {
- return new PacketBattleRequestInfo(buf.readInt());
- }
+ @Override
+ public ResourceLocation id() {
+ return ID;
}
- public static class Consumer implements MessageFunctions.MessageConsumer<PacketBattleRequestInfo> {
- public Consumer() {}
+ public static class PayloadHandler {
+ private static final PayloadHandler INSTANCE = new PayloadHandler();
+
+ public static PayloadHandler getInstance() {
+ return INSTANCE;
+ }
- @Override
- public void handle(PacketBattleRequestInfo pkt, NetworkEvent.Context ctx) {
- ctx.enqueueWork(() -> {
+ public void handleData(final PacketBattleRequestInfo pkt, final PlayPayloadContext ctx) {
+ ctx.workHandler().submitAsync(() -> {
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.replyHandler().send(new PacketBattleInfo(
+ b.getSideAIDs(),
+ b.getSideBIDs(),
+ b.getTimerNanos(),
+ TurnBasedMinecraftMod.proxy.getConfig().getDecisionDurationNanos(),
+ !TurnBasedMinecraftMod.proxy.getConfig().isBattleDecisionDurationForever()));
+ }).exceptionally(e -> {
+ ctx.packetHandler().disconnect(Component.literal("Exception handling PacketBattleRequestInfo! " + e.getMessage()));
+ return null;
});
- ctx.setPacketHandled(true);
}
}
}
import com.burnedkirby.TurnBasedMinecraft.common.EntityInfo;
import com.burnedkirby.TurnBasedMinecraft.common.TurnBasedMinecraftMod;
import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import net.minecraft.resources.ResourceLocation;
import net.neoforged.fml.loading.FMLEnvironment;
-import net.neoforged.neoforge.network.NetworkEvent;
-import net.neoforged.neoforge.network.simple.MessageFunctions;
+import net.neoforged.neoforge.network.handling.PlayPayloadContext;
import java.util.HashMap;
import java.util.Map;
-public class PacketEditingMessage
+public class PacketEditingMessage implements CustomPacketPayload
{
+ public static final ResourceLocation ID = new ResourceLocation(TurnBasedMinecraftMod.MODID, "network_packeteditingmessage");
+
+ @Override
+ public void write(FriendlyByteBuf buf) {
+ buf.writeInt(type.getValue());
+ if(entityInfo.classType != null) {
+ buf.writeUtf(entityInfo.classType.getName());
+ } else {
+ buf.writeUtf("unknown");
+ }
+ buf.writeBoolean(entityInfo.ignoreBattle);
+ buf.writeInt(entityInfo.attackPower);
+ buf.writeInt(entityInfo.attackProbability);
+ buf.writeInt(entityInfo.attackVariance);
+ buf.writeUtf(entityInfo.attackEffect.toString());
+ buf.writeInt(entityInfo.attackEffectProbability);
+ buf.writeInt(entityInfo.defenseDamage);
+ buf.writeInt(entityInfo.defenseDamageProbability);
+ buf.writeInt(entityInfo.evasion);
+ buf.writeInt(entityInfo.speed);
+ buf.writeUtf(entityInfo.category);
+ buf.writeInt(entityInfo.decisionAttack);
+ buf.writeInt(entityInfo.decisionDefend);
+ buf.writeInt(entityInfo.decisionFlee);
+ buf.writeUtf(entityInfo.customName);
+ }
+
+ @Override
+ public ResourceLocation id() {
+ return ID;
+ }
+
public enum Type
{
ATTACK_ENTITY(0),
}
}
- public static class Encoder implements MessageFunctions.MessageEncoder<PacketEditingMessage> {
- public Encoder() {}
-
- @Override
- public 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 PacketEditingMessage(final FriendlyByteBuf buf) {
+ this.type = Type.valueOf(buf.readInt());
+ this.entityInfo = new EntityInfo();
+ try {
+ this.entityInfo.classType = this.entityInfo.getClass().getClassLoader().loadClass(buf.readUtf());
+ } catch (ClassNotFoundException e) { /* ignored */ }
+ this.entityInfo.ignoreBattle = buf.readBoolean();
+ this.entityInfo.attackPower = buf.readInt();
+ this.entityInfo.attackProbability = buf.readInt();
+ this.entityInfo.attackVariance = buf.readInt();
+ this.entityInfo.attackEffect = EntityInfo.Effect.fromString(buf.readUtf());
+ this.entityInfo.attackEffectProbability = buf.readInt();
+ this.entityInfo.defenseDamage = buf.readInt();
+ this.entityInfo.defenseDamageProbability = buf.readInt();
+ this.entityInfo.evasion = buf.readInt();
+ this.entityInfo.speed = buf.readInt();
+ this.entityInfo.category = buf.readUtf();
+ this.entityInfo.decisionAttack = buf.readInt();
+ this.entityInfo.decisionDefend = buf.readInt();
+ this.entityInfo.decisionFlee = buf.readInt();
+ this.entityInfo.customName = buf.readUtf();
}
- public static class Decoder implements MessageFunctions.MessageDecoder<PacketEditingMessage> {
- public Decoder() {}
-
- @Override
- public 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 PayloadHandler {
+ private static final PayloadHandler INSTANCE = new PayloadHandler();
- public static class Consumer implements MessageFunctions.MessageConsumer<PacketEditingMessage> {
- public Consumer() {}
+ public static PayloadHandler getInstance() {
+ return INSTANCE;
+ }
- @Override
- public void handle(PacketEditingMessage pkt, NetworkEvent.Context ctx) {
- ctx.enqueueWork(() -> {
+ public void handleData(final PacketEditingMessage pkt, final PlayPayloadContext ctx) {
+ ctx.workHandler().submitAsync(() -> {
if (FMLEnvironment.dist.isClient()) {
TurnBasedMinecraftMod.proxy.handlePacket(pkt, ctx);
}
+ }).exceptionally(e -> {
+ ctx.packetHandler().disconnect(Component.literal("Exception handling PacketEditingMessage! " + e.getMessage()));
+ return null;
});
- ctx.setPacketHandled(true);
}
}
-}
+}
\ No newline at end of file
import com.burnedkirby.TurnBasedMinecraft.common.TurnBasedMinecraftMod;
import net.minecraft.network.FriendlyByteBuf;
-import net.neoforged.api.distmarker.Dist;
-import net.neoforged.fml.DistExecutor;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import net.minecraft.resources.ResourceLocation;
import net.neoforged.fml.loading.FMLEnvironment;
-import net.neoforged.neoforge.network.NetworkEvent;
-import net.neoforged.neoforge.network.simple.MessageFunctions;
+import net.neoforged.neoforge.network.handling.PlayPayloadContext;
-public class PacketGeneralMessage
+public class PacketGeneralMessage implements CustomPacketPayload
{
+ public static final ResourceLocation ID = new ResourceLocation(TurnBasedMinecraftMod.MODID, "network_packetgeneralmessage");
+
String message;
public String getMessage() {
this.message = message;
}
- public static class Encoder implements MessageFunctions.MessageEncoder<PacketGeneralMessage> {
- public Encoder() {}
-
- @Override
- public void encode(PacketGeneralMessage pkt, FriendlyByteBuf buf) {
- buf.writeUtf(pkt.message);
- }
+ public PacketGeneralMessage(final FriendlyByteBuf buf) {
+ this.message = buf.readUtf();
}
- public static class Decoder implements MessageFunctions.MessageDecoder<PacketGeneralMessage> {
- public Decoder() {}
+ @Override
+ public void write(FriendlyByteBuf buf) {
+ buf.writeUtf(message);
+ }
- @Override
- public PacketGeneralMessage decode(FriendlyByteBuf buf) {
- return new PacketGeneralMessage(buf.readUtf());
- }
+ @Override
+ public ResourceLocation id() {
+ return ID;
}
- public static class Consumer implements MessageFunctions.MessageConsumer<PacketGeneralMessage> {
- public Consumer() {}
+ public static class PayloadHandler {
+ private static final PayloadHandler INSTANCE = new PayloadHandler();
+
+ public static PayloadHandler getInstance() {
+ return INSTANCE;
+ }
- @Override
- public void handle(PacketGeneralMessage pkt, NetworkEvent.Context ctx) {
- ctx.enqueueWork(() -> {
+ public void handleData(final PacketGeneralMessage pkt, final PlayPayloadContext ctx) {
+ ctx.workHandler().submitAsync(() -> {
if (FMLEnvironment.dist.isClient()) {
TurnBasedMinecraftMod.proxy.handlePacket(pkt, ctx);
}
+ }).exceptionally(e -> {
+ ctx.packetHandler().disconnect(Component.literal("Exception handling PacketGeneralMessage! " + e.getMessage()));
+ return null;
});
- ctx.setPacketHandled(true);
}
}
}
Implements turn-based-battle in Minecraft.
'''
-logoFile="/assets/com_burnedkirby_turnbasedminecraft/tbmm_icon.png"
+logoFile="assets/com_burnedkirby_turnbasedminecraft/tbmm_icon.png"
# A dependency - use the . to indicate dependency for a specific modid. Dependencies are optional.
[[dependencies.com_burnedkirby_turnbasedminecraft]] #optional
# the modid of the dependency
modId="neoforge" #mandatory
# Does this dependency have to exist - if not, ordering below must be specified
- mandatory=true #mandatory
+ type="required" #mandatory
# The version range of the dependency
versionRange="${neo_version_range}" #mandatory
# An ordering relationship for the dependency - BEFORE or AFTER required if the relationship is not mandatory
# Here's another dependency
[[dependencies.com_burnedkirby_turnbasedminecraft]]
modId="minecraft"
- mandatory=true
+ type="required"
versionRange="${minecraft_version_range}"
ordering="NONE"
side="BOTH"
projects / TurnBasedMinecraftMod / commitdiff