🔖 LambdaControls v1.1.0: Chording update.

spigot/build.gradle

@@ -0,0 +1,50 @@
+plugins {
+    id 'java-library'
+}
+
+archivesBaseName = project.archives_base_name + "-spigot"
+
+repositories {
+    maven { url = 'https://hub.spigotmc.org/nexus/content/groups/public/' }
+    maven { url = 'https://libraries.minecraft.net/' }
+}
+
+configurations {
+    include
+}
+
+dependencies {
+    api project(":core")
+    include(project(":core")) {
+        exclude group: 'com.google.code.gson'
+        exclude group: 'com.google.guava'
+    }
+    api 'org.spigotmc:spigot-api:1.15.1-R0.1-SNAPSHOT'
+    api 'io.netty:netty-all:4.1.28.Final'
+}
+
+processResources {
+    inputs.property "version", project.version
+
+    from(sourceSets.main.resources.srcDirs) {
+        include "plugin.yml"
+
+        expand 'version': project.version.toString().replace("#", "")
+    }
+}
+
+jar {
+    from '../LICENSE'
+
+    dependsOn configurations.include
+    from {
+        (configurations.include).collect {
+            it.isDirectory() ? it : zipTree(it)
+        }
+    }
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}

spigot/src/main/java/me/lambdaurora/lambdacontrols/LambdaControlsConfig.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols;
+
+import com.electronwill.nightconfig.core.file.FileConfig;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.File;
+
+/**
+ * Represents the LambdaControls Spigot configuration.
+ */
+public class LambdaControlsConfig
+{
+    private static final boolean DEFAULT_FRONT_BLOCK_PLACING = true;
+
+    protected final FileConfig           config = FileConfig.builder("config/lambdacontrols.toml").concurrent().defaultResource("/server_config.toml").build();
+    private final   LambdaControlsSpigot plugin;
+
+    public LambdaControlsConfig(@NotNull LambdaControlsSpigot plugin)
+    {
+        this.plugin = plugin;
+    }
+
+    public void load()
+    {
+        File configDir = new File("config/");
+        if (!configDir.exists())
+            configDir.mkdirs();
+        this.config.load();
+        this.plugin.log("Configuration loaded.");
+        LambdaControlsFeature.FRONT_BLOCK_PLACING.setAllowed(this.config.getOrElse("gameplay.front_block_placing", DEFAULT_FRONT_BLOCK_PLACING));
+    }
+}

spigot/src/main/java/me/lambdaurora/lambdacontrols/LambdaControlsSpigot.java

@@ -0,0 +1,148 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols;
+
+import io.netty.buffer.Unpooled;
+import me.lambdaurora.lambdacontrols.event.PlayerChangeControlsModeEvent;
+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 org.bukkit.plugin.java.JavaPlugin;
+import org.bukkit.plugin.messaging.PluginMessageListener;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+import static me.lambdaurora.lambdacontrols.LambdaControlsConstants.*;
+
+/**
+ * Represents the LambdaControls spigot plugin which provides extra features for servers.
+ *
+ * @author LambdAurora
+ * @version 1.1.0
+ * @since 1.1.0
+ */
+public class LambdaControlsSpigot extends JavaPlugin implements PluginMessageListener, Listener
+{
+    private static final Map<Player, ControlsMode> PLAYERS_CONTROLS_MODE = new HashMap<>();
+    public final         LambdaControlsConfig      config                = new LambdaControlsConfig(this);
+
+    @Override
+    public void onEnable()
+    {
+        super.onEnable();
+
+        this.config.load();
+
+        // Note that Spigot has a bullshit channel size restriction as Minecraft SUPPORTS UP TO 32767 AS CHANNEL SIZE.
+        // Please stop using that bad server software, move over Sponge or idk other things. REALLY.
+        this.getServer().getMessenger().registerIncomingPluginChannel(this, CONTROLS_MODE_CHANNEL.toString(), this);
+        this.getServer().getMessenger().registerOutgoingPluginChannel(this, CONTROLS_MODE_CHANNEL.toString());
+        this.getServer().getMessenger().registerOutgoingPluginChannel(this, FEATURE_CHANNEL.toString());
+        this.getServer().getMessenger().registerIncomingPluginChannel(this, HELLO_CHANNEL.toString(), this);
+        this.getServer().getPluginManager().registerEvents(this, this);
+
+        this.getServer().getOnlinePlayers().forEach(player -> {
+            PLAYERS_CONTROLS_MODE.put(player, ControlsMode.DEFAULT);
+
+            this.requestPlayerControlsMode(player);
+            this.updatePlayerFeature(player, LambdaControlsFeature.FRONT_BLOCK_PLACING);
+        });
+    }
+
+    @Override
+    public void onDisable()
+    {
+        super.onDisable();
+
+        this.getServer().getMessenger().unregisterIncomingPluginChannel(this, CONTROLS_MODE_CHANNEL.toString());
+        this.getServer().getMessenger().unregisterOutgoingPluginChannel(this, CONTROLS_MODE_CHANNEL.toString());
+        this.getServer().getMessenger().unregisterOutgoingPluginChannel(this, FEATURE_CHANNEL.toString());
+        this.getServer().getMessenger().unregisterIncomingPluginChannel(this, HELLO_CHANNEL.toString());
+
+        PLAYERS_CONTROLS_MODE.clear();
+    }
+
+    public void requestPlayerControlsMode(@NotNull Player player)
+    {
+        player.sendPluginMessage(this, CONTROLS_MODE_CHANNEL.toString(), new byte[0]);
+    }
+
+    public void updatePlayerFeature(@NotNull Player player, @NotNull LambdaControlsFeature feature)
+    {
+        Objects.requireNonNull(player);
+        Objects.requireNonNull(feature);
+
+        player.sendPluginMessage(this, FEATURE_CHANNEL.toString(), this.makeFeatureMessage(feature));
+    }
+
+    /**
+     * Prints a message to the terminal.
+     *
+     * @param info The message to print.
+     */
+    public void log(String info)
+    {
+        this.getLogger().info(info);
+    }
+
+    @Override
+    public void onPluginMessageReceived(@NotNull String channel, @NotNull Player player, @NotNull byte[] message)
+    {
+        if (channel.equals(HELLO_CHANNEL.toString())) {
+            NettyPacketBuffer buffer = new NettyPacketBuffer(Unpooled.copiedBuffer(message));
+            String version = buffer.readString(16);
+            ControlsMode.byId(buffer.readString(32)).ifPresent(controlsMode -> {
+                PLAYERS_CONTROLS_MODE.put(player, controlsMode);
+                PlayerChangeControlsModeEvent event = new PlayerChangeControlsModeEvent(player, controlsMode);
+                this.getServer().getPluginManager().callEvent(event);
+            });
+            this.updatePlayerFeature(player, LambdaControlsFeature.FRONT_BLOCK_PLACING);
+        } else if (channel.equals(CONTROLS_MODE_CHANNEL.toString())) {
+            NettyPacketBuffer buffer = new NettyPacketBuffer(Unpooled.copiedBuffer(message));
+            ControlsMode.byId(buffer.readString(32)).ifPresent(controlsMode -> {
+                PLAYERS_CONTROLS_MODE.put(player, controlsMode);
+                PlayerChangeControlsModeEvent event = new PlayerChangeControlsModeEvent(player, controlsMode);
+                this.getServer().getPluginManager().callEvent(event);
+            });
+        }
+    }
+
+    /**
+     * Returns a packet byte buffer made for the lambdacontrols:feature plugin message.
+     *
+     * @param feature The feature data to send.
+     * @return The packet byte buffer.
+     */
+    public byte[] makeFeatureMessage(@NotNull LambdaControlsFeature feature)
+    {
+        Objects.requireNonNull(feature, "Feature cannot be null.");
+        NettyPacketBuffer buffer = new NettyPacketBuffer(Unpooled.buffer());
+        buffer.writeString(feature.getName());
+        buffer.writeBoolean(feature.isAllowed());
+        return buffer.array();
+    }
+
+    @EventHandler
+    public void onPlayerJoin(@NotNull PlayerJoinEvent event)
+    {
+        PLAYERS_CONTROLS_MODE.put(event.getPlayer(), ControlsMode.DEFAULT);
+    }
+
+    @EventHandler
+    public void onPlayerLeave(@NotNull PlayerQuitEvent event)
+    {
+        PLAYERS_CONTROLS_MODE.remove(event.getPlayer());
+    }
+}

spigot/src/main/java/me/lambdaurora/lambdacontrols/NettyPacketBuffer.java

@@ -0,0 +1,102 @@
+package me.lambdaurora.lambdacontrols;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.handler.codec.DecoderException;
+import io.netty.handler.codec.EncoderException;
+
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+
+public class NettyPacketBuffer extends PacketBuffer
+{
+    public NettyPacketBuffer(ByteBuf byteBuf)
+    {
+        super(byteBuf);
+    }
+
+    @Override
+    public int readVarint()
+    {
+        int var1 = 0;
+        int var2 = 0;
+        byte var3;
+
+        do {
+            var3 = this.readByte();
+            var1 |= (var3 & 127) << var2++ * 7;
+
+            if (var2 > 5)
+                throw new RuntimeException("VarInt too big");
+        } while ((var3 & 128) == 128);
+
+        return var1;
+    }
+
+    @Override
+    public void writeVarint(int input)
+    {
+        while ((input & -128) != 0) {
+            this.writeByte(input & 127 | 128);
+            input >>>= 7;
+        }
+
+        this.writeByte(input);
+    }
+
+    @Override
+    public String readString(int maxLength)
+    {
+        int var2 = this.readVarint();
+
+        if (var2 > maxLength * 4)
+            throw new DecoderException("The received encoded string buffer length is longer than maximum allowed (" + var2 + " > " + maxLength * 4 + ")");
+        else if (var2 < 0)
+            throw new DecoderException("The received encoded string buffer length is less than zero! Weird string!");
+        else {
+            String var3 = this.readCharSequence(var2, StandardCharsets.UTF_8).toString();
+
+            if (var3.length() > maxLength)
+                throw new DecoderException("The received string length is longer than maximum allowed (" + var2 + " > " + maxLength + ")");
+            else
+                return var3;
+        }
+    }
+
+    @Override
+    public void writeString(String string)
+    {
+        byte[] var2 = string.getBytes(Charset.forName("UTF-8"));
+
+        if (var2.length > 32767) {
+            throw new EncoderException("String too big (was " + string.length() + " data encoded, max " + 32767 + ")");
+        } else {
+            this.writeVarint(var2.length);
+            this.writeCharSequence(string, StandardCharsets.UTF_8);
+        }
+    }
+
+    @Override
+    public boolean equals(Object o)
+    {
+        if (this == o)
+            return true;
+        if (o == null || getClass() != o.getClass())
+            return false;
+
+        NettyPacketBuffer buffer = (NettyPacketBuffer) o;
+
+        return byteBuf.equals(buffer.byteBuf);
+    }
+
+    @Override
+    public int compareTo(ByteBuf buffer)
+    {
+        return this.byteBuf.compareTo(buffer);
+    }
+
+    @Override
+    public String toString()
+    {
+        return this.byteBuf.toString();
+    }
+}

spigot/src/main/java/me/lambdaurora/lambdacontrols/event/PlayerChangeControlsModeEvent.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.event;
+
+import me.lambdaurora.lambdacontrols.ControlsMode;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.player.PlayerEvent;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Represents an event which is fired when a player change their controls mode.
+ *
+ * @author LambdAurora
+ * @version 1.1.0
+ * @since 1.1.0
+ */
+public class PlayerChangeControlsModeEvent extends PlayerEvent
+{
+    private static final HandlerList  HANDLERS = new HandlerList();
+    private final        ControlsMode controlsMode;
+
+    public PlayerChangeControlsModeEvent(@NotNull Player who, @NotNull ControlsMode controlsMode)
+    {
+        super(who);
+        this.controlsMode = controlsMode;
+    }
+
+    /**
+     * Returns the controls mode of the player.
+     *
+     * @return The player's controls mode.
+     */
+    public ControlsMode getControlsMode()
+    {
+        return this.controlsMode;
+    }
+
+    @Override
+    public String toString()
+    {
+        return "PlayerChangeControlsModeEvent{" +
+                "player=" + this.player +
+                ", controls_mode=" + this.controlsMode +
+                '}';
+    }
+
+    @Override
+    public @NotNull HandlerList getHandlers()
+    {
+        return HANDLERS;
+    }
+
+    public static @NotNull HandlerList getHandlerList()
+    {
+        return HANDLERS;
+    }
+}

spigot/src/main/resources/plugin.yml

@@ -0,0 +1,6 @@
+name: LambdaControls
+version: ${version}
+description: A quick Spigot plugin for LambdaControls which allow server admins to disable some features.
+
+main: me.lambdaurora.lambdacontrols.LambdaControlsSpigot
+api-version: 1.13

spigot/src/main/resources/server_config.toml

@@ -0,0 +1,6 @@
+# LambdaControls server configuration.
+
+# Gameplay settings
+[gameplay]
+    # Allows front block placing like in Bedrock Edition.
+    front_block_placing = true