Hooks work! (netcode untested)

Author: thecodewarrior

netcode.md

@@ -0,0 +1,31 @@
+# Netcode
+
+I'll attempt to describe how the netcode works here, mostly for my own reference later. In server communication I will 
+use the term "the client" to refer to the player whose hooks we're processing, and "other clients" to refer to other 
+players in the vicinity. I will also use the term "canonical" to refer to the state on the server, since the server is
+king.
+
+## Syncing
+
+On the client, so long as the syncing is up to date, the player's own hooks are always in the canonical order. However, 
+other players' hooks may not be in canonical order. For this reason controllers are only ticked on the client for the
+client's player. Other players' hooks will still move and hit blocks on their own, but the controller will not be 
+invoked for them.
+
+## Firing a hook
+
+To fire a hook:
+
+- **[Client]** Adds a hook to the client-side `HookedPlayerData` with a random UUID [1]
+- **[Client]** Sends a `FireHookPacket` that contains the firing parameters (start position + direction) to the server
+- **[Server]** Receives the `FireHookPacket` and performs some validation on the inputs
+- **[Server]** If the packet fails validation,
+  - **[Server]** The full `HookedPlayerData` is sent to the client in a `SyncHookedDataPacket` to correct the discrepancy
+- **[Server]** If the packet succeeds validation, 
+  - **[Server]** The server adds a hook to the server-side `HookedPlayerData` with a random UUID
+  - **[Server]** The full `HookedPlayerData` is sent back to the player in a `SyncHookedDataPacket`, ensuring that 
+    everything on the client is exactly up to date.
+  - **[Server]** A `SyncHookPacket` is sent to other clients
+
+[1]: The client-side hook with this temporary UUID will be seamlessly replaced by the server-side hook with the 
+canonical UUID

src/generated/resources/.cache/cache

@@ -1,2 +1,5 @@
+d5ad42510969279aea44a0b2019f1498716dc852 assets/hooked/models/item/diamond_hook.json
+60e9f401cbf0bda316cc2509b9da561f31488bac assets/hooked/models/item/ender_hook.json
 24cf6a03abc3fa15e34d2e1519249e535b423acd assets/hooked/models/item/iron_hook.json
-a294c4eba37684d7a375d14d165038df0b9c02d4 data/curios/tags/items/hooked.json
+7a73fe9d10afdb403d96cb483c1d559e8bb8fa00 assets/hooked/models/item/wood_hook.json
+84587976d102955f8ef61a2bd3d3f5174eb82d61 data/curios/tags/items/hooked.json

src/generated/resources/assets/hooked/models/item/diamond_hook.json

@@ -0,0 +1,6 @@
+{
+  "parent": "item/generated",
+  "textures": {
+    "layer0": "hooked:item/diamond_hook"
+  }
+}

src/generated/resources/assets/hooked/models/item/ender_hook.json

@@ -0,0 +1,6 @@
+{
+  "parent": "item/generated",
+  "textures": {
+    "layer0": "hooked:item/ender_hook"
+  }
+}

src/generated/resources/assets/hooked/models/item/wood_hook.json

@@ -0,0 +1,6 @@
+{
+  "parent": "item/generated",
+  "textures": {
+    "layer0": "hooked:item/wood_hook"
+  }
+}

src/generated/resources/data/curios/tags/items/hooked.json

@@ -1,6 +1,9 @@
 {
   "replace": false,
   "values": [
-    "hooked:iron_hook"
+    "hooked:wood_hook",
+    "hooked:iron_hook",
+    "hooked:diamond_hook",
+    "hooked:ender_hook"
   ]
 }

src/main/kotlin/dev/thecodewarrior/hooked/HookedMod.kt

@@ -6,9 +6,13 @@ import com.teamwizardry.librarianlib.foundation.BaseMod
 import com.teamwizardry.librarianlib.foundation.util.TagWrappers
 import dev.thecodewarrior.hooked.client.HookRenderManager
 import dev.thecodewarrior.hooked.client.Keybinds
-import dev.thecodewarrior.hooked.hook.processor.CommonHookProcessor
+import dev.thecodewarrior.hooked.hook.processor.ClientHookProcessor
+import dev.thecodewarrior.hooked.hook.processor.ServerHookProcessor
 import dev.thecodewarrior.hooked.hook.type.HookType
+import dev.thecodewarrior.hooked.network.BasicHookJumpPacket
 import dev.thecodewarrior.hooked.network.FireHookPacket
+import dev.thecodewarrior.hooked.network.SyncHookDataPacket
+import dev.thecodewarrior.hooked.network.SyncIndividualHooksPacket
 import net.minecraft.inventory.container.PlayerContainer
 import net.minecraft.util.Tuple
 import net.minecraftforge.client.event.TextureStitchEvent
@@ -34,18 +38,22 @@ object HookedMod: BaseMod(true) {
         HookedModItems.registerItemDatagen(registrationManager)
         HookedModCapabilities.registerCapabilities(registrationManager)
         eventBus.register(HookedModHookTypes)
-        courier.registerCourierPacket<FireHookPacket>(NetworkDirection.PLAY_TO_SERVER)
-
         proxy = SidedSupplier.sided({ HookedClientProxy }, { HookedDedicatedServerProxy })
+
+        courier.registerCourierPacket<FireHookPacket>(NetworkDirection.PLAY_TO_SERVER)
+        courier.registerCourierPacket<SyncIndividualHooksPacket>(NetworkDirection.PLAY_TO_CLIENT)
+        courier.registerCourierPacket<SyncHookDataPacket>(NetworkDirection.PLAY_TO_CLIENT)
+        courier.registerCourierPacket<BasicHookJumpPacket>(NetworkDirection.PLAY_TO_SERVER)
     }
 
     override fun clientSetup(e: FMLClientSetupEvent) {
         ClientRegistry.registerKeyBinding(Keybinds.fireKey)
-        HookRenderManager // registers itself
+        HookRenderManager // registers itself for events
+        ClientHookProcessor // registers itself for events
     }
 
     override fun commonSetup(e: FMLCommonSetupEvent) {
-        CommonHookProcessor // registers itself
+        ServerHookProcessor // registers itself for events
     }
 
     override fun interModCommsEnqueue(e: InterModEnqueueEvent) {
@@ -70,6 +78,7 @@ object HookedMod: BaseMod(true) {
         RegistryBuilder<HookType>()
             .setName(loc("hooked:hook_type"))
             .setType(HookType::class.java)
+            .setDefaultKey(loc("hooked:none"))
             .create()
     }
 }

src/main/kotlin/dev/thecodewarrior/hooked/HookedModHookTypes.kt

@@ -7,12 +7,18 @@ import net.minecraftforge.event.RegistryEvent
 import net.minecraftforge.eventbus.api.SubscribeEvent
 
 object HookedModHookTypes {
-    val iron = BasicHookType(2, 16.0, 0.8, 0.4, 0.5, 0.05).also {
-        it.registryName = loc("hooked:iron_hook")
-    }
+    val types: List<HookType> = listOf(
+        BasicHookType(1, 8.0, 0.4, 0.5, 0.2, 0.05).also { it.registryName = loc("hooked:wood_hook") },
+        BasicHookType(2, 16.0, 0.8, 0.5, 0.4, 0.05).also { it.registryName = loc("hooked:iron_hook") },
+        BasicHookType(4, 24.0, 1.2, 0.5, 1.0, 0.05).also { it.registryName = loc("hooked:diamond_hook") },
+        BasicHookType(1, 64.0, 64.0, 0.5, 2.25, 0.05).also { it.registryName = loc("hooked:ender_hook") },
+    )
 
     @SubscribeEvent
     fun registerTypes(e: RegistryEvent.Register<HookType>) {
-        e.registry.register(iron)
+        e.registry.register(HookType.NONE)
+        types.forEach {
+            e.registry.register(it)
+        }
     }
 }

src/main/kotlin/dev/thecodewarrior/hooked/HookedModItems.kt

@@ -6,19 +6,25 @@ import com.teamwizardry.librarianlib.foundation.registration.RegistrationManager
 import dev.thecodewarrior.hooked.item.HookItem
 
 object HookedModItems {
+    val hooks = mutableListOf<LazyItem>()
     val ironHook: LazyItem = LazyItem()
 
     internal fun registerItems(registrationManager: RegistrationManager) {
-        ironHook.from(registrationManager.add(
-            ItemSpec("iron_hook")
-                .maxStackSize(1)
-                .item { HookItem(it.itemProperties, HookedModHookTypes.iron) }
-                .datagen { simpleModel() }
-        ))
+        HookedModHookTypes.types.forEach { type ->
+            val item = registrationManager.add(
+                ItemSpec(type.registryName!!.path)
+                    .maxStackSize(1)
+                    .item { HookItem(it.itemProperties, type) }
+                    .datagen { simpleModel() }
+            )
+            if(type.registryName!!.path == "iron_hook")
+                ironHook.from(item)
+            hooks.add(item)
+        }
         registrationManager.itemGroupIcon = ironHook
     }
 
     internal fun registerItemDatagen(registrationManager: RegistrationManager) {
-        registrationManager.datagen.itemTags.add(HookedMod.HOOKED_CURIOS_TAG, ironHook.get())
+        registrationManager.datagen.itemTags.add(HookedMod.HOOKED_CURIOS_TAG, *hooks.map { it.get() }.toTypedArray())
     }
 }

src/main/kotlin/dev/thecodewarrior/hooked/capability/HookedPlayerData.kt

@@ -33,7 +33,15 @@ class HookedPlayerData(val player: PlayerEntity): BaseCapability() {
 
     var controller: HookPlayerController = HookPlayerController.NONE
 
-    var needsSync: Boolean = true
+    /**
+     * State that is only ever used on the *logical* server. This includes things like syncing status.
+     */
+    class ServerState {
+        val dirtyHooks: MutableList<Hook> = mutableListOf()
+        var forceFullSyncToClient: Boolean = false
+        var forceFullSyncToOthers: Boolean = false
+    }
+    var serverState: ServerState = ServerState()
 
     override fun deserializeNBT(nbt: CompoundNBT) {
         val oldType = type
@@ -52,15 +60,6 @@ class HookedPlayerData(val player: PlayerEntity): BaseCapability() {
         return nbt
     }
 
-    /**
-     * Marks this data to be synced in its entirety with clients.
-     *
-     * TODO: make single-hook sync packets for other players, since they aren't critical to keep exactly up to date.
-     */
-    fun markForSync() {
-        needsSync = true
-    }
-
     companion object {
         @JvmStatic
         @CapabilityInject(HookedPlayerData::class)