diff --git a/build.gradle.kts b/build.gradle.kts index da576f7..7045105 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -2,6 +2,7 @@ import xyz.jpenilla.resourcefactory.bukkit.BukkitPluginYaml plugins { kotlin("jvm") version libs.versions.kotlin.get() + kotlin("plugin.serialization") version libs.versions.kotlin.get() alias(libs.plugins.paperweight.userdev) alias(libs.plugins.shadow) alias(libs.plugins.run.paper) @@ -15,13 +16,14 @@ repositories { dependencies { paperweight.paperDevBundle(libs.versions.paper.api.get()) implementation(libs.kotlin.stdlib) + implementation(libs.msgpack) compileOnly(libs.better.model) } bukkitPluginYaml { main = "fr.nextstation.unmei.Unmei" - apiVersion = "26.1.2" + apiVersion = "26.3" load = BukkitPluginYaml.PluginLoadOrder.STARTUP authors.addAll("Azur84","gamer_noir") diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index 201db41..e3795bc 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -10,10 +10,12 @@ run-task = "3.1.0" resource-factory = "1.4.0" better-model = "3.5.0" +msgpack = "0.6.1" [libraries] kotlin-stdlib = { module = "org.jetbrains.kotlin:kotlin-stdlib-jdk8", version.ref = "kotlin" } better-model = { module = "io.github.toxicity188:bettermodel-api", version.ref = "better-model" } +msgpack = { module = "com.ensarsarajcic.kotlinx:serialization-msgpack", version.ref = "msgpack"} [plugins] paperweight-userdev = { id = "io.papermc.paperweight.userdev", version.ref = "paperweight-userdev" } diff --git a/src/main/kotlin/fr/nextstation/unmei/Unmei.kt b/src/main/kotlin/fr/nextstation/unmei/Unmei.kt index b001db1..0ea9ba8 100644 --- a/src/main/kotlin/fr/nextstation/unmei/Unmei.kt +++ b/src/main/kotlin/fr/nextstation/unmei/Unmei.kt @@ -1,12 +1,16 @@ package fr.nextstation.unmei +import fr.nextstation.unmei.blocks.ChunksDataManager import fr.nextstation.unmei.events.PlayerEvents +import fr.nextstation.unmei.network.PacketInjector import org.bukkit.plugin.java.JavaPlugin class Unmei : JavaPlugin() { + val customBlockChunkManager = ChunksDataManager(this) override fun onEnable() { - server.pluginManager.registerEvents(PlayerEvents(), this) + server.pluginManager.registerEvents(PlayerEvents, this) + server.pluginManager.registerEvents(PacketInjector, this) } override fun onDisable() { diff --git a/src/main/kotlin/fr/nextstation/unmei/blocks/ChunksData.kt b/src/main/kotlin/fr/nextstation/unmei/blocks/ChunksData.kt new file mode 100644 index 0000000..e79b637 --- /dev/null +++ b/src/main/kotlin/fr/nextstation/unmei/blocks/ChunksData.kt @@ -0,0 +1,15 @@ +package fr.nextstation.unmei.blocks + +import kotlinx.serialization.Serializable +import org.bukkit.NamespacedKey +import org.bukkit.block.Block + +@Serializable +data class ChunksData ( + val blocks: HashMap, String>, +) { + fun getKey(block: Block): NamespacedKey? { + val string = blocks[Triple(block.x,block.y,block.z)] ?: return null + return NamespacedKey.fromString(string) + } +} \ No newline at end of file diff --git a/src/main/kotlin/fr/nextstation/unmei/blocks/ChunksDataManager.kt b/src/main/kotlin/fr/nextstation/unmei/blocks/ChunksDataManager.kt new file mode 100644 index 0000000..659ef49 --- /dev/null +++ b/src/main/kotlin/fr/nextstation/unmei/blocks/ChunksDataManager.kt @@ -0,0 +1,38 @@ +package fr.nextstation.unmei.blocks + +import com.ensarsarajcic.kotlinx.serialization.msgpack.MsgPack +import org.bukkit.Chunk +import org.bukkit.NamespacedKey +import org.bukkit.persistence.PersistentDataType +import org.bukkit.plugin.java.JavaPlugin + +class ChunksDataManager(val plugin: JavaPlugin) { + companion object { + val CUSTOM_BLOCK_DATA = NamespacedKey("unmei", "custom_block") + } + + val cache = mutableMapOf() + + fun getBlocksData(chunk: Chunk): ChunksData { + val map = cache.computeIfAbsent(chunk.chunkKey) { + val buffer = chunk.persistentDataContainer.get(CUSTOM_BLOCK_DATA, PersistentDataType.BYTE_ARRAY) + ?: return@computeIfAbsent ChunksData(HashMap()) + try { + val data = MsgPack.decodeFromByteArray(ChunksData.serializer(), buffer) + return@computeIfAbsent data + } catch (error: Error) { + plugin.logger.warning("Failed to Decode chunk ${chunk.chunkKey}: ${error.message}") + return@computeIfAbsent ChunksData(HashMap()) + } + } + return map + } + + fun saveBlocksData(chunk: Chunk) { + val data = cache[chunk.chunkKey]?: return + + val buffer = MsgPack.encodeToByteArray(ChunksData.serializer(), data) + + chunk.persistentDataContainer.set(CUSTOM_BLOCK_DATA, PersistentDataType.BYTE_ARRAY, buffer) + } +} \ No newline at end of file diff --git a/src/main/kotlin/fr/nextstation/unmei/events/PlayerEvents.kt b/src/main/kotlin/fr/nextstation/unmei/events/PlayerEvents.kt index ebe9f01..f73c5af 100644 --- a/src/main/kotlin/fr/nextstation/unmei/events/PlayerEvents.kt +++ b/src/main/kotlin/fr/nextstation/unmei/events/PlayerEvents.kt @@ -1,17 +1,30 @@ package fr.nextstation.unmei.events +import fr.nextstation.unmei.Unmei +import org.bukkit.Material import org.bukkit.event.EventHandler import org.bukkit.event.Listener -import org.bukkit.event.block.Action +import org.bukkit.event.block.BlockDamageEvent import org.bukkit.event.player.PlayerInteractEvent -class PlayerEvents : Listener { +class PlayerEvents(val plugin: Unmei) : Listener { @EventHandler fun rightClick (event : PlayerInteractEvent){ - if (event.action == Action.RIGHT_CLICK_BLOCK) { - event.player.teleport(event.player.location.add(0.0,10.0,0.0)); - - } +// if (event.action == Action.RIGHT_CLICK_BLOCK) { +// event.player.teleport(event.player.location.add(0.0,10.0,0.0)); +// +// } } + @EventHandler + fun blockBreak(event: BlockDamageEvent) { + val player = event.player + + if (event.block.blockData.material == Material.COMMAND_BLOCK) { + val data = plugin.customBlockChunkManager.getBlocksData(event.block.chunk) + if (data.getKey(event.block) != null) { + TODO() + } + } + } } \ No newline at end of file diff --git a/src/main/kotlin/fr/nextstation/unmei/network/PacketInjector.kt b/src/main/kotlin/fr/nextstation/unmei/network/PacketInjector.kt new file mode 100644 index 0000000..3d20ad7 --- /dev/null +++ b/src/main/kotlin/fr/nextstation/unmei/network/PacketInjector.kt @@ -0,0 +1,66 @@ +package fr.nextstation.unmei.network + +import io.netty.channel.Channel +import net.minecraft.network.protocol.game.ClientboundUpdateAttributesPacket +import net.minecraft.world.entity.ai.attributes.AttributeInstance +import org.bukkit.Bukkit +import org.bukkit.NamespacedKey +import org.bukkit.attribute.Attribute +import org.bukkit.craftbukkit.entity.CraftPlayer +import org.bukkit.entity.Player +import org.bukkit.event.EventHandler +import org.bukkit.event.Listener +import org.bukkit.event.player.PlayerJoinEvent +import org.bukkit.event.player.PlayerQuitEvent +import java.util.UUID + +object PacketInjector: Listener { + private var disabled: Boolean = false + private val channels = mutableMapOf() + private val injectors = mutableMapOf() + + fun getChannel(player: Player): Channel { + return channels.getOrPut(player.uniqueId) { + (player as CraftPlayer).handle.connection.connection.channel + } + } + + @EventHandler + fun joinInject(event: PlayerJoinEvent) { + if (disabled) return + val player = event.player as CraftPlayer + val channel = getChannel(player) + + if (!injectors.contains(channel)) { + inject(player, channel) + } + } + + @EventHandler + fun quit(event: PlayerQuitEvent) { + channels.remove(event.player.uniqueId) + } + + fun disable() { + if (!disabled) { + disabled = true + + for (player in Bukkit.getServer().onlinePlayers) { + uninject(getChannel(player)) + } + } + } + + fun inject(player: Player, channel: Channel) { + val injector = PipelineInjector(player) + channel.pipeline().addBefore("packet_handler", "unmei_packet", injector) + + injectors[channel] = injector + } + + fun uninject(channel: Channel) { + channel.eventLoop().execute { + channel.pipeline().remove(injectors[channel]) + } + } +} \ No newline at end of file diff --git a/src/main/kotlin/fr/nextstation/unmei/network/PipelineInjector.kt b/src/main/kotlin/fr/nextstation/unmei/network/PipelineInjector.kt new file mode 100644 index 0000000..f1a6b76 --- /dev/null +++ b/src/main/kotlin/fr/nextstation/unmei/network/PipelineInjector.kt @@ -0,0 +1,45 @@ +package fr.nextstation.unmei.network + +import io.netty.channel.ChannelDuplexHandler +import io.netty.channel.ChannelHandlerContext +import io.netty.channel.ChannelPromise +import net.minecraft.network.protocol.game.ClientboundBlockChangedAckPacket +import net.minecraft.network.protocol.game.ClientboundUpdateAttributesPacket +import net.minecraft.network.protocol.game.ServerboundPlayerActionPacket +import org.bukkit.NamespacedKey +import org.bukkit.attribute.Attribute +import org.bukkit.attribute.AttributeModifier +import org.bukkit.entity.Player + +class PipelineInjector(val player: Player): ChannelDuplexHandler() { + val attributeModifier = AttributeModifier(NamespacedKey("unmei","no_break"), -1.0, AttributeModifier.Operation.MULTIPLY_SCALAR_1) +// val clientSet = mutableSetOf() +// val serverSet = mutableSetOf() + + override fun channelRead(ctx: ChannelHandlerContext, msg: Any) { +// val name = msg.javaClass.name +// if (serverSet.add(name)) { +// println(name) +// } + +// if (msg is ServerboundPlayerActionPacket) { +// if (msg.action == ServerboundPlayerActionPacket.Action.START_DESTROY_BLOCK) { +// println("hi") +// } +// if (msg.action == ServerboundPlayerActionPacket.Action.STOP_DESTROY_BLOCK || msg.action == ServerboundPlayerActionPacket.Action.ABORT_DESTROY_BLOCK) { +// println("bye") +// } +// } + + super.channelRead(ctx, msg) + } + + override fun write(ctx: ChannelHandlerContext, msg: Any, promise: ChannelPromise) { +// val name = msg.javaClass.name +// if (clientSet.add(name)) { +// println(name) +// } + + super.write(ctx, msg, promise) + } +} \ No newline at end of file