Teleport the player twice to fix #50

https://redstoner.com/forums/threads/3653-chatgroup-bug

chatgroups.py

@@ -102,8 +102,9 @@ def save_groups():
 @hook.event("player.AsyncPlayerChatEvent", "normal")
 def on_chat(event):
     sender = event.getPlayer()
+    user = get_py_player(sender)
     msge = event.getMessage()
-    if not event.isCancelled():
+    if (not user.logging_in) and (not event.isCancelled()):
         sender_id = uid(sender)
         key = get_key(sender_id)
         keylen = len(key)

damnspam.py

@@ -173,8 +173,6 @@ def on_block_break(event):
 def on_interact(event):
     if (str(event.getAction()) == "RIGHT_CLICK_BLOCK") and not event.isCancelled():
         sender = event.getPlayer()
-        if sender.isSneaking():
-            return
         block   = event.getClickedBlock()
         pos_str = location_str(block)
         data    = inputs.get(pos_str)

imbusy.py

@@ -209,43 +209,110 @@ def reply(sender):
             reply_targets[target.getName()] = (sender_name, True)
     return True
 
-try:
 
-    def msg_interception(sender, args):
-        return not is_player(sender) or len(args) <= 1 or whisper(sender, args[0])
+class CommandWrapper(Command):
 
-    def reply_interception(sender, args):
-        return not is_player(sender) or len(args) == 0 or reply(sender)
+    def __init__(self, wrapped, checker):
+        Command.__init__(self, wrapped.getName())
+        self.setDescription(wrapped.getDescription())
+        self.setPermission(wrapped.getPermission())
+        self.setUsage(wrapped.getUsage())
+        self.setAliases(wrapped.getAliases())
+        self.wrapped = wrapped
+        self.checker = checker
 
-    def tpa_interception(sender, args):
-        if len(args) == 0 or not is_player(sender):
-            return True
-        target = server.getPlayer(args[0])
-        if target is not None and not can_send(sender, target):
-            msg(sender, "&c[&fBUSY&c] %s&r is busy!" % target.getDisplayName())
-            return False
+    def execute(self, sender, label, args):
+        try:
+            if not is_player(sender) or self.checker(sender, args):
+                return self.wrapped.execute(sender, label, args)
+        except:
+            error(trace())
         return True
 
-    def tpahere_interception(sender, args):
-        return tpa_command_checker(sender, args)
+    def tabComplete(self, sender, alias, args):
+        return self.wrapped.tabComplete(sender, alias, args)
 
-    def mail_interception(sender, args):
-        if len(args) < 3 or args[0].lower() != "send" or not is_player(sender):
-            return True
-        target = server.getPlayer(args[1])
-        if target is not None and not can_send(sender, target):
-            msg(sender, "&c[&fBUSY&c] %s&r is busy!" % target.getDisplayName())
-            return False
+
+def msg_command_checker(sender, args):
+    return len(args) <= 1 or whisper(sender, args[0])
+
+def reply_command_checker(sender, args):
+    return len(args) == 0 or reply(sender)
+
+def tpa_command_checker(sender, args):
+    if len(args) == 0:
         return True
+    target = server.getPlayer(args[0])
+    if target is not None and not can_send(sender, target):
+        msg(sender, "&c[&fBUSY&c] %s&r is busy!" % target.getDisplayName())
+        return False
+    return True
 
-    register = shared["modules"]["misc"].CommandInterceptions.register
-    register("essentials", "msg", msg_interception)
-    register("minecraft", "tell", msg_interception)
-    register("essentials", "reply", reply_interception)
-    register("essentials", "tpa", tpa_interception)
-    register("essentials", "tpahere", tpahere_interception)
-    register("essentials", "mail", mail_interception)
+def tpahere_command_checker(sender, args):
+    return tpa_command_checker(sender, args)
 
-except:
-    error("[Imbusy] Failed to intercept commands:")
-    error(trace())
+def mail_command_checker(sender, args):
+    if len(args) < 3 or args[0].lower() != "send":
+        return True
+    target = server.getPlayer(args[1])
+    if target is not None and not can_send(sender, target):
+        msg(sender, "&c[&fBUSY&c] %s&r is busy!" % target.getDisplayName())
+        return False
+    return True
+
+
+@hook.event("player.PlayerCommandPreprocessEvent", "monitor")
+def on_player_command_preprocess(event):
+    message = event.getMessage().split(" ")
+    if len(message) > 1 and message[0].lower() in ("/tell", "/minecraft:tell") and not whisper(event.getPlayer(), message[1]):
+        event.setCancelled(True)
+
+
+def replace_ess_commands():
+
+    try:
+        map_field = server.getPluginManager().getClass().getDeclaredField("commandMap")
+        map_field.setAccessible(True)
+        command_map = map_field.get(server.getPluginManager())
+
+        commands_field = command_map.getClass().getDeclaredField("knownCommands")
+        commands_field.setAccessible(True)
+        map = commands_field.get(command_map)
+
+        ess_msg_cmd = map.get("essentials:msg")
+        ess_reply_cmd = map.get("essentials:reply")
+        ess_tpa_cmd = map.get("essentials:tpa")
+        ess_tpahere_cmd = map.get("essentials:tpahere")
+        ess_mail_cmd = map.get("essentials:mail")
+
+        msg_cmd_wrapper = CommandWrapper(ess_msg_cmd, msg_command_checker)
+        reply_cmd_wrapper = CommandWrapper(ess_reply_cmd, reply_command_checker)
+        tpa_cmd_wrapper = CommandWrapper(ess_tpa_cmd, tpa_command_checker)
+        tpahere_cmd_wrapper = CommandWrapper(ess_tpahere_cmd, tpahere_command_checker)
+        mail_cmd_wrapper = CommandWrapper(ess_mail_cmd, mail_command_checker)
+
+        iterator = map.entrySet().iterator()
+        wrapped_commands = []
+        while iterator.hasNext():
+            entry = iterator.next()
+            value = entry.getValue()
+            changed = True
+            if value is ess_msg_cmd:
+                entry.setValue(msg_cmd_wrapper)
+            elif value is ess_reply_cmd:
+                entry.setValue(reply_cmd_wrapper)
+            elif value is ess_tpa_cmd:
+                entry.setValue(tpa_cmd_wrapper)
+            elif value is ess_tpahere_cmd:
+                entry.setValue(tpahere_cmd_wrapper)
+            elif value is ess_mail_cmd:
+                entry.setValue(mail_cmd_wrapper)
+            else:
+                changed = False
+            if changed:
+                wrapped_commands.append(entry.getKey())
+        info("[imbusy] wrapped commands: /" + ", /".join(wrapped_commands))
+
+    except:
+        error("[Imbusy] Failed to wrap essentials commands")
+        error(trace())

loginsecurity.py

@@ -12,7 +12,7 @@ from player import get_py_player, py_players
 wait_time = 30 #seconds
 admin_perm = "utils.loginsecurity.admin"
 min_pass_length = 8
-blocked_events = ["block.BlockBreakEvent", "block.BlockPlaceEvent", "player.PlayerMoveEvent","player.AsyncPlayerChatEvent"]
+blocked_events = ["block.BlockBreakEvent", "block.BlockPlaceEvent", "player.AsyncPlayerChatEvent"]
 
 
 
@@ -273,4 +273,10 @@ def pre_command_proccess(event):
         args = event.getMessage().split(" ")
         if not args[0].lower() == "/login":
             msg(player.player, "&4You need to login before you do that!")
-            event.setCancelled(True)
+            event.setCancelled(True)
+    
+@hook.event("player.PlayerMoveEvent","normal")
+def player_move(event):
+    user = get_py_player(event.getPlayer())
+    if user.logging_in:
+        event.setTo(event.getFrom())

main.py

@@ -21,8 +21,10 @@ except:
 def on_enable():
     if "blockplacemods" in shared["modules"]:
         shared["modules"]["blockplacemods"].schedule_torch_breaker()
+    if "imbusy" in shared["modules"]:
+        shared["modules"]["imbusy"].replace_ess_commands()
     if "serversigns" in shared["modules"]:
-        shared["modules"]["serversigns"].check_all_signs_and_intercept_command()
+        shared["modules"]["serversigns"].check_all_signs_and_force_commands()
     info("RedstonerUtils enabled!")
 
 

misc.py

@@ -8,131 +8,8 @@ import org.bukkit.inventory.ItemStack as ItemStack
 import org.bukkit.Bukkit as Bukkit
 from basecommands import simplecommand, Validate
 import java.util.Arrays as Arrays
-import org.bukkit.command.Command as Command
-import java.util.HashMap as HashMap
 
 
-"""
-This section is a little tool to intercept commands. 
-It can intercept any aliases of the command, which it does by default.
-
-An intercepter is a function that is run before the command is executed,
-which takes the parameters: sender, args
-It should return a boolean value to specify whether it should be executed.
-
-The optional tab completer is a function that takes the following parameters:
-  original_completions (List<String>), sender, alias, args
-and it should return a List<String>. By default it returns the original completions.
-"""
-
-class CommandInterceptions:
-
-    def __init__(self):
-        raise Exception("Instances of 'CommandInterceptions' are not meant to exist")
-
-    registrations = {} # cmd : (intercepter, tab_completer)
-    interceptions = {} # original_obj : replacement_obj
-    cmd_map = None     # CustomHashMap
-
-    @staticmethod
-    def register(plugin_name, command, intercepter, tab_completer = None):
-        key = (plugin_name + ":" + command if plugin_name else command).lower()
-        CommandInterceptions.registrations[key] = (intercepter, tab_completer)
-        if CommandInterceptions.cmd_map.containsKey(key):
-            CommandInterceptions.add_interception(key, CommandInterceptions.cmd_map.get(key))
-
-
-    class Intercepter(Command):
-
-        def __init__(self, wrapped, intercepter, tab_completer):
-            try:
-                Command.__init__(self, wrapped.getName())
-                self.setDescription(wrapped.getDescription())
-                self.setPermission(wrapped.getPermission())
-                self.setUsage(wrapped.getUsage())
-
-                # I had to dig deep in spigot code to find out what's happening
-                # But without this snippet, the server shuts itself down because 
-                # commands can't be aliases for themselves (shrug) :)
-                aliases = wrapped.getAliases()
-                try:
-                    aliases.remove(wrapped.getLabel())
-                except:
-                    pass
-                self.setAliases(aliases)
-                self.wrapped = wrapped
-                self.intercepter = intercepter
-                self.tab_completer = tab_completer
-            except:
-                error(trace())
-
-        def execute(self, sender, label, args):
-            if self.intercepter(sender, args):
-                return self.wrapped.execute(sender, label, args)
-            return True
-
-        def tabComplete(self, sender, alias, args):
-            return self.tab_completer(self.wrapped.tabComplete(sender, alias, args), sender, alias, args)
-
-
-    @staticmethod
-    def add_interception(key, intercepted):
-        registration = CommandInterceptions.registrations[key]
-        tab_completer = registration[1]
-        if tab_completer is None:
-            tab_completer = lambda original_completions, sender, alias, args: original_completions
-        cmd_intercepter = CommandInterceptions.Intercepter(intercepted, registration[0], tab_completer)
-        CommandInterceptions.interceptions[intercepted] = cmd_intercepter
-        for entry in CommandInterceptions.cmd_map.entrySet():
-            if entry.getValue() is intercepted:
-                entry.setValue(cmd_intercepter)
-
-    @staticmethod
-    def init_interceptions():
-
-        # The map object in the command map used by spigot is previously already a hashmap, we replace its put() here
-        class CustomHashMap(HashMap):
-
-            def __init__(self, replaced):
-                HashMap.__init__(self)
-                for entry in replaced.entrySet():
-                    self.put(entry.getKey(), entry.getValue())
-
-            def java_put(self, key, value):
-                return HashMap.put(self, key, value)
-
-            def put(self, key, value):
-                for intercepted in CommandInterceptions.interceptions:
-                    if value is intercepted:
-                        return self.java_put(key, CommandInterceptions.interceptions[intercepted])
-                ret = self.java_put(key, value)
-                if key in CommandInterceptions.registrations:
-                    CommandInterceptions.add_interception(key, value)
-                return ret
-
-        try:
-            map_field = server.getPluginManager().getClass().getDeclaredField("commandMap")
-            map_field.setAccessible(True)
-            command_map = map_field.get(server.getPluginManager())
-
-            commands_field = command_map.getClass().getDeclaredField("knownCommands")
-            commands_field.setAccessible(True)
-            CommandInterceptions.cmd_map = CustomHashMap(commands_field.get(command_map))
-            commands_field.set(command_map, CommandInterceptions.cmd_map)
-        except:
-            error("[Interceptions] Failed to wrap the command map:")
-            error(trace())
-CommandInterceptions.init_interceptions()
-
-
-def worldedit_calc_intercepter(sender, args):
-    if not sender.hasPermission("worldedit.calc"):
-        noperm(sender)
-        return False
-    return True
-
-CommandInterceptions.register("worldedit", "/calc", worldedit_calc_intercepter)
-
 
 @hook.event("player.PlayerJoinEvent", "monitor")
 def on_join(event):
@@ -339,7 +216,8 @@ pythoners = (
     "e452e012-2c82-456d-853b-3ac8e6b581f5", # Nemes
     "ae795aa8-6327-408e-92ab-25c8a59f3ba1", # jomo
     "d2693e91-93e1-4e3f-929f-f38e1ce8df03", # Pepich1851
-    "51f2ad3c-6cc8-40ea-aa2b-f25970316921"  # Dico200
+    "51f2ad3c-6cc8-40ea-aa2b-f25970316921", # Dico200
+    "15ad0e60-8691-4e29-9de9-2d6b538bf56d"  # psrcek
 )
 
 @simplecommand("pyeval",

plotter.py

@@ -1,30 +0,0 @@
-#!/usr/bin/python
-
-"""
-*Very basic* start of a custom plot-plugin like PlotMe
-on hold because the PlotMe developer continued to develop PlotMe
-"""
-
-import sys
-
-x_plot_size = 3
-z_plot_size = 3
-padding     = 1
-
-def base_coords(x, z):
-    pid = plot_id(x, z)
-    return [pid[0] * (x_plot_size + padding), pid[1] * (z_plot_size + padding)]
-
-def bounds(x, z):
-    base = base_coords(x, z)
-    return [base, [base[0] + x_plot_size, base[1] + z_plot_size]]
-
-def plot_id(x, z):
-    return [x // (x_plot_size + padding), z // (z_plot_size + padding)]
-
-
-x = int(sys.argv[1])
-z = int(sys.argv[2])
-print "id: %s" % plot_id(x, z)
-print "base: %s" % base_coords(x, z)
-print "bounds: %s" % bounds(x, z)

punishments.py

@@ -55,6 +55,7 @@ class Slave(object):
     def update(self):
         self.blocks -= 1
         if self.blocks <= 0:
+            server.getPlayer(juuid(self.get_uuid())).teleport(server.getWorld(spawn_world).getSpawnLocation())
             server.getPlayer(juuid(self.get_uuid())).teleport(server.getWorld(spawn_world).getSpawnLocation())
             slaves.remove(self)
             save_slaves()

saylol.py

@@ -1,6 +1,7 @@
 from time import time
 from helpers import *
 from random import randrange
+import math
 
 lols     = open_json_file("lol", [])
 timeout  = 15
@@ -83,7 +84,7 @@ def on_lol_command(sender, command, label, args):
         if offset > len(lols):
             msg(sender, "&cNot a valid page (too high).")
             return True
-        msg(sender, "    &9&nLol list page %s" % str(arg1 + 1)) #"\t" symbol displays weirdly, hence the 4 spaces
+        msg(sender, "    &9&nLol list page %s/%s" % (arg1 + 1, int(math.ceil(len(lols) / float(list_limit))))) #"\t" symbol displays weirdly, hence the 4 spaces
         for i in range(offset, min(offset + list_limit, len(lols))):
             msg(sender, "&a%s: &e%s" % (str(i).rjust(3), lols[i]))
         msg(sender, "")        

serversigns.py

@@ -392,32 +392,25 @@ def can_build2(player, block):
     return not event.isCancelled()
 
 
-def check_all_signs_and_intercept_command():
-
-    try:
-        #CommandInterceptions = shared["modules"]["misc"].CommandInterceptions
-        #rsutils_cmd = CommandInterceptions.cmd_map.get("redstonerutils:serversigns")
-        #label = rsutils_cmd.getLabel()
-
-        def interception(sender, args):
-            svs_command(sender, None, None, args)
-            return False
-
-        def tab_completion(original, sender, alias, args):
-            return None
-
-        shared["modules"]["misc"].CommandInterceptions.register("serversigns", "serversigns", interception, tab_completion)
-    except:
-        error("[Serversigns] failed to force commands")
-        error(trace())
-
-    """
-    Check if all registered signs have an associated sign block in the world. 
-    WorldEdit commands could remove them without notification.
-    Pistons might also be able to achieve the same thing.
-    A sign missing from the world won't affect the world so it only checks on start.
-    """
-
+def check_all_signs_and_force_commands():
     for loc in signs:
         if server.getWorld(loc[0]).getBlockAt(loc[1], loc[2], loc[3]).getType() not in (Material.WALL_SIGN, Material.SIGN_POST):
             del signs[loc]
+
+    try:
+        map_field = server.getPluginManager().getClass().getDeclaredField("commandMap")
+        map_field.setAccessible(True)
+        command_map = map_field.get(server.getPluginManager())
+
+        commands_field = command_map.getClass().getDeclaredField("knownCommands")
+        commands_field.setAccessible(True)
+        map = commands_field.get(command_map)
+
+        rsutils_cmd = map.get("redstonerutils:serversigns")
+        map.put("svs", rsutils_cmd)
+        map.put("serversigns", rsutils_cmd)
+        map.put("signsmsg", rsutils_cmd)
+
+    except:
+        error("[Serversigns] failed to force commands")
+        error(trace())