make war timer server-sided

src/main/kotlin/breadmod/ClientForgeEventBus.kt

@@ -1,20 +1,17 @@
 package breadmod
 
 import breadmod.ClientModEventBus.toolGunBindList
-import breadmod.client.gui.WarTicker
+import breadmod.client.gui.WarTickerClient
+import breadmod.commands.client.AltToolGunModelCommand
 import breadmod.datagen.tool_gun.BreadModToolGunModeProvider.Companion.TOOL_GUN_DEF
 import breadmod.item.tool_gun.ToolGunItem
 import breadmod.network.PacketHandler.NETWORK
 import breadmod.network.serverbound.tool_gun.ToolGunConfigurationPacket
-import breadmod.registry.ModConfiguration
 import breadmod.util.gui.IHoldScreen
 import breadmod.util.render.modifierMatches
 import breadmod.util.render.renderBuffer
 import breadmod.util.render.rgMinecraft
 import com.mojang.blaze3d.platform.InputConstants
-import com.mojang.brigadier.Command
-import com.mojang.brigadier.StringReader
-import com.mojang.brigadier.arguments.ArgumentType
 import net.minecraft.client.KeyMapping
 import net.minecraft.client.Minecraft
 import net.minecraft.client.gui.screens.Screen
@@ -162,60 +159,16 @@ object ClientForgeEventBus {
 
     @SubscribeEvent
     fun registerClientCommands(event: RegisterClientCommandsEvent) {
-        // todo it would probably be ideal to have each sub command be their own class for cleanness sakes
-        // CommandMek.java
         event.dispatcher.register(Commands.literal("breadmod")
-            .then(Commands.literal("increase_timer")
-                .then(Commands.argument("amount", IntArgument())
-                    .executes { amount ->
-                        val arg = amount.getArgument("amount", Int::class.java)
-                        WarTicker.increaseTimer(arg)
-                        return@executes Command.SINGLE_SUCCESS
-                    }
-                )
-            )
-            .then(Commands.literal("reset_timer")
-                .executes {
-                    WarTicker.reset()
-                    return@executes Command.SINGLE_SUCCESS
-                }
-            )
-            .then(Commands.literal("start_timer")
-                .executes {
-                    WarTicker.active = true
-                    return@executes Command.SINGLE_SUCCESS
-                }
-            )
-            .then(Commands.literal("end_timer")
-                .executes {
-                    WarTicker.active = false
-                    return@executes Command.SINGLE_SUCCESS
-                }
-            )
-            .then(Commands.literal("alt_toolgun_model")
-                .then(Commands.argument("value", BooleanArgument())
-                    .executes { value ->
-                        val arg = value.getArgument("value", Boolean::class.java)
-                        ModConfiguration.CLIENT.ALT_TOOLGUN_MODEL.set(arg)
-                        return@executes Command.SINGLE_SUCCESS
-                    }
-                )
-            )
+            .then(AltToolGunModelCommand.register())
         )
     }
 
-    private class IntArgument : ArgumentType<Int> {
-        override fun parse(reader: StringReader): Int = reader.readInt()
-    }
-    private class BooleanArgument : ArgumentType<Boolean> {
-        override fun parse(reader: StringReader): Boolean = reader.readBoolean()
-    }
-
     @Suppress("UNUSED_PARAMETER")
     @SubscribeEvent
     fun onTick(event: ClientTickEvent) {
         if (Minecraft.getInstance().level == null || Minecraft.getInstance().player == null) return
 
-        WarTicker.tick()
+        WarTickerClient.tick()
     }
 }

src/main/kotlin/breadmod/CommonForgeEventBus.kt

@@ -1,9 +1,17 @@
 package breadmod
 
+import breadmod.commands.server.WarTimerServerCommand
 import breadmod.datagen.tool_gun.ModToolGunModeDataLoader
+import breadmod.network.PacketHandler
+import breadmod.network.clientbound.war_timer.WarTimerSynchronizationPacket
+import net.minecraft.commands.Commands
+import net.minecraft.server.level.ServerPlayer
 import net.minecraftforge.event.AddReloadListenerEvent
+import net.minecraftforge.event.RegisterCommandsEvent
+import net.minecraftforge.event.TickEvent
 import net.minecraftforge.eventbus.api.SubscribeEvent
 import net.minecraftforge.fml.common.Mod
+import net.minecraftforge.network.PacketDistributor
 
 @Suppress("unused")
 @Mod.EventBusSubscriber(modid = ModMain.ID, bus = Mod.EventBusSubscriber.Bus.FORGE)
@@ -12,4 +20,62 @@ object CommonForgeEventBus {
     fun onResourceReload(event: AddReloadListenerEvent) {
         event.addListener(ModToolGunModeDataLoader)
     }
+
+    /**
+     * A map holding a war timer for every player on the server
+     * * First int holds the time left.
+     * * Second int holds the delay (or ticker) before the time left decrements by one.
+     * * Third int holds the increasing timer (how long the timer will increase for).
+     * * First boolean is for the timer being active or not.
+     * * Second boolean is if the timer is currently increasing in time.
+     * * Players need to manually be added to the timer map using the warTimer command
+     * * Server automatically pauses the player's timer if they leave and unpauses when they rejoin
+     * * Timer is automatically removed if their time left is 0 or their timer is force ended by an admin
+     */
+    val warTimerMap: MutableMap<ServerPlayer, Pair<Triple<Int, Int, Int>, Pair<Boolean, Boolean>>> = mutableMapOf()
+
+    @SubscribeEvent
+    fun serverTick(event: TickEvent.ServerTickEvent) {
+        warTimerTick()
+    }
+
+    private fun warTimerTick() {
+        warTimerMap.forEach { (key, value) ->
+            val timeLeft = value.first.first
+            val ticker = value.first.second
+            val increaseTime = value.first.third
+            val active = value.second.first
+            val isIncreasing = value.second.second
+
+            warTimerMap[key]?.let {
+                if (active && !isIncreasing) {
+                    if (ticker == 0 && timeLeft > 0) {
+                        val timeDecrement = timeLeft - 1
+                        warTimerMap[key] = Triple(timeDecrement, 41, increaseTime) to it.second
+                        PacketHandler.NETWORK.send(
+                            PacketDistributor.PLAYER.with { key },
+                            WarTimerSynchronizationPacket(timeDecrement)
+                        )
+                    } else if (timeLeft > 0) {
+                        val tickerDecrement = ticker - 1
+                        warTimerMap[key] = Triple(timeLeft, tickerDecrement, increaseTime) to it.second
+                    }
+                }
+                if (increaseTime > 0 && isIncreasing) {
+                    val increasingDecrement = increaseTime - 1
+                    val increasingTime = timeLeft + 1
+                    warTimerMap[key] = Triple(increasingTime, ticker, increasingDecrement) to it.second
+                } else if (isIncreasing && increaseTime == 0) {
+                    warTimerMap[key] = Triple(timeLeft, ticker, increaseTime) to (it.second.first to false)
+                }
+            }
+        }
+    }
+
+    @SubscribeEvent
+    fun registerCommands(event: RegisterCommandsEvent) {
+        event.dispatcher.register(Commands.literal("breadmod")
+            .then(WarTimerServerCommand.register())
+        )
+    }
 }

src/main/kotlin/breadmod/ServerForgeEventBus.kt

@@ -3,8 +3,10 @@ package breadmod
 import breadmod.datagen.tool_gun.ModToolGunModeDataLoader
 import breadmod.network.PacketHandler.NETWORK
 import breadmod.network.clientbound.tool_gun.ToolGunModeDataPacket
+import breadmod.CommonForgeEventBus.warTimerMap
 import net.minecraft.server.level.ServerPlayer
 import net.minecraftforge.api.distmarker.Dist
+import net.minecraftforge.event.entity.player.PlayerEvent
 import net.minecraftforge.event.entity.player.PlayerEvent.PlayerLoggedInEvent
 import net.minecraftforge.eventbus.api.SubscribeEvent
 import net.minecraftforge.fml.common.Mod
@@ -24,5 +26,20 @@ object ServerForgeEventBus {
                 ToolGunModeDataPacket(next.second, next.third, list.hasNext())
             )
         }
+
+        val serverPlayer = event.entity as ServerPlayer
+        warTimerMap[serverPlayer]?.let {
+            // sets the joining players active timer state to true so it continues ticking down
+            warTimerMap[serverPlayer] = it.first to (true to it.second.second)
+        }
+    }
+
+    @SubscribeEvent
+    fun onPlayerLeave(event: PlayerEvent.PlayerLoggedOutEvent) {
+        val serverPlayer = event.entity as ServerPlayer
+        // sets the leaving players active timer state to false so it won't tick down anymore
+        warTimerMap[serverPlayer]?.let {
+            warTimerMap[serverPlayer] = it.first to (false to it.second.second)
+        }
     }
 }

src/main/kotlin/breadmod/client/gui/WarOverlay.kt

@@ -1,8 +1,8 @@
 package breadmod.client.gui
 
 import breadmod.ModMain.modLocation
-import breadmod.client.gui.WarTicker.lastScroll
-import breadmod.client.gui.WarTicker.scroll
+import breadmod.client.gui.WarTickerClient.lastScroll
+import breadmod.client.gui.WarTickerClient.scroll
 import breadmod.util.ModFonts
 import breadmod.util.render.rgMinecraft
 import breadmod.util.render.scaleFlat
@@ -28,12 +28,12 @@ class WarOverlay : AbstractModGuiOverlay() {
         pBuffer: MultiBufferSource,
         pPlayer: LocalPlayer
     ) {
-        val seconds = WarTicker.timer % 60
-        val minutes = WarTicker.timer / 60
+        val seconds = WarTickerClient.timer % 60
+        val minutes = WarTickerClient.timer / 60
         val formattedSeconds = if (seconds < 10) "0$seconds" else seconds
         val formattedMinutes = if (minutes < 10) "0$minutes" else minutes
         val colorPair: Triple<Float, Float, Float> =
-            if (WarTicker.isIncreasing) Triple(0.376f, 0.91f, 0.471f)
+            if (WarTickerClient.isIncreasing) Triple(0.376f, 0.91f, 0.471f)
             else Triple(0.973f, 0f, 0f)
 
         if (scroll > -110f) {

src/main/kotlin/breadmod/client/gui/WarTickerClient.kt

@@ -0,0 +1,25 @@
+package breadmod.client.gui
+
+object WarTickerClient {
+    var timer = 30
+    var isIncreasing = false
+    var increasingTimer = 0
+    var active = false
+
+    var scroll = -110f
+    var lastScroll = -110f
+
+    fun tick() {
+        if (increasingTimer > 0) { // Increase timer
+            increasingTimer--
+            timer++
+        } else isIncreasing = false
+
+        lastScroll = scroll // hell code until I figure out proper smooth like anims from minecraft's code
+        if (scroll > -110.0 && !active) {
+            scroll -= (1f * 0.5f) * 4.0f
+        } else if (scroll < 0.0 && active) {
+            scroll += (1f * 0.5f) * 4.0f
+        }
+    }
+}

src/main/kotlin/breadmod/commands/CommandArguments.kt

@@ -0,0 +1,13 @@
+package breadmod.commands
+
+import com.mojang.brigadier.StringReader
+import com.mojang.brigadier.arguments.ArgumentType
+
+object CommandArguments {
+    class IntArgument : ArgumentType<Int> {
+        override fun parse(reader: StringReader): Int = reader.readInt()
+    }
+    class BooleanArgument : ArgumentType<Boolean> {
+        override fun parse(reader: StringReader): Boolean = reader.readBoolean()
+    }
+}

src/main/kotlin/breadmod/commands/client/AltToolGunModelCommand.kt

@@ -0,0 +1,20 @@
+package breadmod.commands.client
+
+import breadmod.commands.CommandArguments.BooleanArgument
+import breadmod.registry.ModConfiguration
+import com.mojang.brigadier.Command
+import com.mojang.brigadier.builder.ArgumentBuilder
+import net.minecraft.commands.CommandSourceStack
+import net.minecraft.commands.Commands
+
+internal object AltToolGunModelCommand {
+    fun register(): ArgumentBuilder<CommandSourceStack, *> =
+        Commands.literal("altToolgunModel")
+            .then(Commands.argument("value", BooleanArgument())
+                .executes { value ->
+                    val arg = value.getArgument("value", Boolean::class.java)
+                    ModConfiguration.CLIENT.ALT_TOOLGUN_MODEL.set(arg)
+                    return@executes Command.SINGLE_SUCCESS
+                }
+            )
+}