Merge remote-tracking branch 'origin/dev'

basecommands.py

@@ -1,156 +1,7 @@
 from helpers import *
-import inspect, new
-
-current_subs = []
-current_main = None
 
 to_see_permission = "utils.showpermission" # See cmd permission in help
 
-def maincommand(function):
-    current_main = function
-    return function
-
-class subcommand():
-
-    def __init__(self, cmd, 
-            aliases      = [], 
-            amin         = 0, 
-            amax         = -1, 
-            description  = None, 
-            usage        = "[args...]", 
-            senderLimit  = -1,
-            helpNoargs   = False,
-            helpSubcmd   = False):
-        cmd = cmd.lower()
-        self.description = description
-        self.cmd         = cmd
-        self.usage       = usage
-        self.aliases     = aliases
-        self.amin        = amin
-        self.amax        = amax
-        self.senderLimit = senderLimit
-        self.helpNoargs  = helpNoargs
-        self.helpSubcmd  = helpSubcmd
-        self.permission  = None
-        self.parent      = None
-        self.call        = None
-
-    def __call__(self, f):
-        def call_sub(sender, command, label, args):
-            isPlayer = is_player(sender)
-            if not isSenderValid(senderLimit, isPlayer):
-                return invalidSenderMsg(isPlayer)
-            if not sender.hasPermission(permission):
-                return "&cYou do not have permission to use that command"
-            if ((not args) and helpNoargs) or (helpSubcmd and args and args[0].lower() == "help"):
-                return getHelp(sender)
-            if not checkargs(sender, args, amin, amax):
-                return None
-            return f(sender, command, label, args)
-
-        self.call = call_sub
-        current_subs.append(self)
-        return call_sub
-
-    def getHelp(sender):
-        return helpMsg(sender, "%s %s" % (parent, cmd), description, usage, aliases, permission)
-
-    def setParent(self, parent):
-        self.parent      = parent
-        self.permission  = "utils.%s.%s" % (parent, self.cmd)
-        self.description = self.description if self.description else "Handles /" + parent
-
-    def isCalled(self, subcmd):
-        alias = self.cmd
-        i = 0
-        while i <= len(self.aliases):
-            if alias == subcmd:
-                return True
-            alias = self.aliases[i]
-            i += 1
-        return False
-
-
-def command(cmd,
-                aliases     = [], 
-                usage       = "[args...]", 
-                description = None,
-                senderLimit = -1, 
-                amin        = 0, 
-                amax        = -1, 
-                helpNoargs  = False, 
-                helpSubcmd  = False):
-
-    cmd = cmd.lower()
-
-    subcommands = []
-    for subcmd in current_subs:
-        subcmd.setParent(cmd)
-        subcommands.append(subcmd)
-    info(subcommands)
-    current_subs = []
-
-    main_function = current_main
-    current_main = None
-    if main_function == None and len(subcommands) != 0:
-        error("No main function found for " + cmd)
-
-    permission = "utils." + cmd
-    if not description:
-        description = "Handles " + cmd
-    if not usage:
-        usage = "/%s <subcmd>" % cmd
-
-    def getHelp(sender):
-        return helpMsg(sender, cmd, description, usage, aliases, permission)
-
-    def getCalledCmd(cmdName):
-        for subcmd in subcommands:
-            if subcmd.isCalled(cmdName):
-                return subcmd
-        return None
-
-    def decorator(function):
-
-        if len(subcommands) == 0:
-            main_function = function
-
-        @hook.command(cmd, aliases = aliases)
-        def call(sender, command, label, args):
-            message = run(sender, command, label, args)
-            if message:
-                if message == "HELP":
-                    message = getHelp(sender)
-                msg(sender, message)
-            return True
-
-        def run(sender, command, label, args):
-            isPlayer = is_player(sender)
-            if not isSenderValid(senderLimit, isPlayer):
-                return invalidSenderMsg(isPlayer)
-
-            if args:
-                arg1 = args[0].lower()
-                if (not args) and helpNoargs:
-                    return getHelp(sender)
-                if helpSubcmd and arg1 == "help":
-                    if len(args) > 1:
-                        sub = getCalledCmd(args[1].lower())
-                        return sub.getHelp(sender) if sub and sub.helpSubcmd else "&c%s is not a command!" % args[1]
-                    return getHelp(sender)
-                sub = getCalledCmd(args[0].lower())
-                if sub:
-                    return sub.call(sender, command, label, args[1:])
-            if not sender.hasPermission(permission):
-                return "&cYou do not have permission to use that command"
-            if not checkargs(sender, args, amin, amax):
-                return None
-            return main_function(sender, command, label, args)
-        return call
-    return decorator
-
-
-
 
 def isSenderValid(senderLimit, isPlayer):
     return True if senderLimit == -1 else senderLimit != isPlayer
@@ -212,135 +63,3 @@ def simplecommand(cmd,
             return function(sender, command, label, args)
         return call
     return decorator
-
-
-"""
-def advancedcommand(cmd,
-                    aliases = [],
-                    description = None,
-                    usage = None,
-                    senderLimit = -1, 
-                    subCommands = []):
-    cmd = cmd.lower()
-
-    def isSenderValid(isPlayer):
-        return True if senderLimit == -1 else senderLimit != isPlayer
-
-    def getHelp(sender):
-        return helpMsg(sender, cmd, description, usage, aliases)
-
-    def getSubCmd(alias):
-        called = None
-        for sub in subCommands:
-            if sub.isCalled(alias):
-                called = sub
-
-    @hook.command(cmd, aliases = aliases)
-    def call(sender, command, label, args):
-        message = run(sender, command, label, args)
-        if message:
-            if message == "HELP":
-                message = getHelp(sender)
-            msg(sender, message)
-        return True
-
-    def run(sender, command, label, args):
-        isPlayer = is_player(sender)
-        if not isSenderValid(senderLimit, isPlayer):
-            return invalidSenderMsg(isPlayer)
-        if not args:
-            return getHelp()
-        subcmd = args[0].lower()
-        if subcmd == "help":
-            if len(args) == 2:
-                called = getSubCmd(args[1].lower())
-                if called:
-                    return called.getHelp(sender)
-            else:
-                return getHelp()
-        called = getSubCmd(subcmd)
-        if not called:
-            return getHelp()
-        if not isSenderValid(called.senderLimit, isPlayer):
-            return invalidSenderMsg(isPlayer)
-        if not sender.hasPermission(called.permission):
-            return "&cYou do not have permission to use that command"
-        if not checkargs(sender, args[1:], called.amin, called.amax):
-            return None
-        return called.call(sender, command, label, args)
-
-    def decorator(function):
-        #functions = [new.function(c, globals()) for c in function.func_code.co_consts if inspect.iscode(c)]
-        functions = function()
-        for sub in subCommands:
-            sub.setParent(cmd)
-            for func in functions:
-                if sub.cmd == func.__name__.lower():
-                    sub.setCalledFunction(func)
-            if not sub.call:
-                error("No function found for /%s %s" % (cmd, sub.cmd))
-        return call
-    return decorator
-"""
-
-
-"""
-Use this instead of @hook.command for your command methods. (@simplecommand(things...))
-
-It will take care of the following things:
-- Basic permission check. The default permission is utils.<cmd_name>
-- Sender type check. You can pass whether the sender must be a player, a consolesender, or both. (see sender_limit below)
-- Minimum and maximum args. Works with checkargs from helpers.py.
-- A '/<cmd> help' message containing the description, usage and aliases of the command.
-
-Information about some arguments:
-- cmd:              The command you type in chat.
-- usage:            For example "<player> <other_player" and is part of the help message.
-- description:      A brief description of what the command does. (also part of the help message)
-- aliases:          A list of aliases for the command
-- permission:       The basic permission for the command. Defaults to utils.<cmd>
-- sender_limit:     Defines what sendertype can use the command. Leave blank for console & player, 0 for player only, 1 for console only.
-- min_args:         The least arguments for the command.
-- max_args:         You guessed it right. Defaults to infinity (-1).
-- help_noargs:      Whether to send help if no arguments are given
-- help_subcmd:      Whether to send help upon '/<cmd> help'
-
-*** DISCLAIMER ***
-
-Your command function must take four arguments: sender, command, label, args and help_msg.
-help_msg is a function which can be called like 'return help_msg(sender)' to send them information about the command.
-
-Your function must also not return a boolean like before, but a String instead. The string returned will be sent to the player (&-codes supported).
-Use None or "" for no message.
-
-Feel free to edit or give suggestions (but don't break existing commands)
-
-See below for an example command:
-
-@simplecommand("test", usage = "<player>", description = "Kicks a player", aliases = ["kickp", "tek"], permission = "utils.kickuser", sender_limit = 0, min_args = 1, max_args = 2)
-def on_test(sender, command, label, args):
-    target = server.getPlayer(args[0]);
-    if target:
-        target.kickPlayer("Kicked from the server")
-        return None
-    return "&cThat player could not be found"
-"""
-
-"""
-Example @command:
-
-@command("forcefield")
-def forcefield_command():
-
-    @subcommand("add")
-    def func(sender, command, label, args):
-        ...add to whitelist
-
-    @maincommand
-    def other(sender, command, label, args):
-        ...Execute command if no sub commands were called
-
-@command("simplestuff")
-def simplestuff_command(sender, command, label, args):
-    msg(sender, "hi, I do not use subcommands!")
-"""

blockplacemods.py

@@ -5,120 +5,156 @@ import org.bukkit.block.Furnace as Furnace
 import org.bukkit.inventory.ItemStack as ItemStack
 import org.bukkit.Material as Material
 
-denyslabcorrection = open_json_file("denyslabcorrection", []) #Players that don't want slabs corrected
+settingInformation = {
-denyautofill       = open_json_file("denyautocauldronfill", [])
+    "cauldron": [0,
-denyautolevel      = open_json_file("denyautocauldronlevel", [])
+        "easy cauldron water level control",
+        "Toggles whether cauldrons auto-fill upon placement and whether right clicking them with redstone dust or empty hand will cycle their water level"
+    ],
+    "slab":     [0,
+        "automatically flipping placed slabs upside-down",
+        "Toggles whether slabs/steps which you place should be automatically flipped upside-down"
+    ],
+    "furnace":  [1,
+        "automatically filling furnaces upon placement",
+        "Sets your preferred default furnace contents to your currently held itemstack. Use an empty hand to disable this feature."
+    ]
+}
 
-def saveslabs():
+defaultPlayerSettings = {
-    save_json_file("denyslabcorrection", denyslabcorrection)
+    "cauldron": [], 
-def savecauldrons():
+    "slab": [], 
-    save_json_file("denyautocauldronfill", denyautofill)
+    "furnace": {}
-def savelevels():
+}
-    save_json_file("denyautocauldronlevel", denyautolevel)
 
-@simplecommand("autofillcauldron",
+playerSettings = open_json_file("blockplacemods", defaultPlayerSettings)
-        aliases     = ["fillcauldronautomatically"],
-        usage       = "on/off",
-        helpNoargs  = True,
-        description = "Sets whether you want placed cauldrons to fill \nautomatically",
-        amax        = 1,
-        senderLimit = 0)
-def autofillcauldron_command(sender, command, label, args):
-    uuid = uid(server.getPlayer(sender.getName()))
-    if args[0].lower() == "off":
-        if uuid in denyautofill:
-            return "&cAuto fillment of cauldrons is already disabled"
-        denyautofill.append(uuid)
-        savecauldrons()
-        return "&aFilling cauldrons will no longer happen automatically"
-    if args[0].lower() == "on":
-        if uuid not in denyautofill:
-            return "&cAuto fillment of cauldrons is already enabled"
-        denyautofill.remove(uuid)
-        savecauldrons()
-        return "&aFilling cauldrons will happen automatically from now"
-    return "HELP"
 
 
-@simplecommand("autoflipslab",
+#for setting, default in enumerate(defaultPlayerSettings):
-        aliases     = ["autoflipstep", "flipslabautomatically", "flipstepautomatically"],
+#    if playerSettings.get(setting) == None:
-        usage       = "on/off",
+#        playerSettings[setting] = default
-        helpNoargs  = True,
+
-        description = "Sets whether you want placed slabs to be turned \nupside-down",
+def get(setting):
-        amax        = 1,
+    return playerSettings[setting]
-        senderLimit = 0)
-def autoflipslab_command(sender, command, label, args):
-    uuid = uid(server.getPlayer(sender.getName()))
-    if args[0].lower() == "off":
-        if uuid in denyslabcorrection:
-            return "&cAuto flipping of slabs is already disabled"
-        denyslabcorrection.append(uuid)
-        saveslabs()
-        return "&aFlipping slabs will no longer happen automatically"
-    if args[0].lower() == "on":
-        if uuid not in denyslabcorrection:
-            return "&cAuto flipping of slabs is already enabled"
-        denyslabcorrection.remove(uuid)
-        saveslabs()
-        return "&aFlipping slabs will happen automatically from now"
-    return "HELP"
 
 
-@simplecommand("autotakewater",
+def saveSettings():
-        aliases     = ["autocauldronlevel"],
+    save_json_file("blockplacemods", playerSettings)
-        usage       = "on/off",
+
-        helpNoargs  = True,
+
-        description = "Sets whether you want right clicking cauldrons \nwith empty hand or redstone dust \nto lower water level",
+
-        amax        = 1,
+@simplecommand("toggle",
-        senderLimit = 0)
+        aliases = ["set"], 
-def autoflipslab_command(sender, command, label, args):
+        usage = "<setting> [value|info]", 
-    uuid = uid(server.getPlayer(sender.getName()))
+        description = "Toggles or sets your preferences for our redstone utilities.\nThe following settings are available:\n" + ", ".join([x for x in settingInformation]),
-    if args[0].lower() == "off":
+        senderLimit = 0,
-        if uuid in denyautolevel:
+        helpNoargs = True,
-            return "&cTaking water with hand/redstone is already disabled"
+        helpSubcmd = True,
-        denyautolevel.append(uuid)
+        amax = 2)
-        savelevels()
+def toggle_command(sender, command, label, args):
-        return "&aYou can no longer take water with hand/redstone"
+    setting = args[0].lower()
-    if args[0].lower() == "on":
+    info = settingInformation.get(setting)
-        if uuid not in denyautolevel:
+    if info == None:
-            return "&cTaking water with hand/redstone is already enabled"
+        return "&cThat setting could not be found. For command help, use &o/toggle"
-        denyautolevel.remove(uuid)
+
-        savelevels()
+    values = get(setting)
-        return "&aYou can take water with hand/redstone from now"
+    player = server.getPlayer(sender.getName())
-    return "HELP"
+    uuid   = uid(player)
+    arglen = len(args)
+
+    if info[0] == 0: # Toggle
+        enabled = uuid not in values
+        new     = None
+        if arglen == 1:
+            new = not enabled
+        else:
+            arg2 = args[1].lower()
+            if arg2 == "info":
+                return " &aSetting %s:\n &9%s\n &6Accepted arguments: None or one of the following:\n &oon, enable, off, disable, toggle, switch" % (setting, info[2])
+            elif arg2 in ("toggle", "switch"):
+                new = not enabled
+            elif arg2 in ("on", "enable"):
+                new = True
+            elif arg2 in ("off", "disable"):
+                new = False
+            else:
+                return "&cArgument '%s' was not recognized. \nTry one of the following: &oon, off, toggle" % arg2
+        if enabled == new:
+            return "&cAlready %s: &a%s" % ("enabled" if enabled else "disabled", info[1])
+        if new:
+            values.remove(uuid)
+        else:
+            values.append(uuid)
+        saveSettings()
+        return ("&aEnabled " if new else "&aDisabled ") + info[1]
+
+    elif info[0] == 1: # Save ItemStack in hand
+        if arglen == 1:
+            item = fromStack(player.getItemInHand())
+            if 0 in (item[0], item[1]):
+                del values[uuid]
+                return "&aDisabled " + info[1]
+            values[uuid] = item
+            saveSettings()
+            return "&aEnabled %s, with currently held itemstack" % info[1]
+        if args[1].lower() == "info":
+            return "&aSetting %s:\n&9%s" % (setting, info[2])
+        return "&cArgument '%s' was not recognized. \nUse /toggle %s info for more information." % setting
+
+    return None #This shouldn't happen
+
+
+def fromStack(itemStack):
+    return [itemStack.getTypeId(), itemStack.getAmount(), itemStack.getData().getData()]
+def toStack(lst):
+    return ItemStack(lst[0], lst[1], lst[2])
+
+def isEnabled(toggleSetting, uuid):
+    return uuid not in get(toggleSetting)
+
 
 
 @hook.event("block.BlockPlaceEvent", "monitor")
 def on_block_place(event):
-    if event.isCancelled():
+    try:
-        return
+        if event.isCancelled():
-    player = event.getPlayer()
+            return
-    if player.getWorld().getName() not in ("Creative", "Trusted", "world"):
+        player = event.getPlayer()
-        return
+        if not is_creative(player):
-    uuid = uid(player)
+            return
-    block = event.getBlockPlaced()
+
-    material = str(block.getType())
+        uuid     = uid(player)
-    if uuid not in denyslabcorrection and material in ("WOOD_STEP", "STEP") and block.getData() < 8:
+        block    = event.getBlockPlaced()
-        block.setData(block.getData() + 8) # Flip upside down
+        material = str(block.getType())
-    elif uuid not in denyautofill and material == "CAULDRON":
+        if isEnabled("slab", uuid) and material in ("WOOD_STEP", "STEP") and block.getData() < 8:
-        block.setData(3) #3 layers of water, 3 signal strength
+            block.setData(block.getData() + 8) # Flip upside down
-    elif material == "FURNACE":
+        elif isEnabled("cauldron", uuid) and material == "CAULDRON":
-        state = block.getState()
+            block.setData(3) #3 layers of water, 3 signal strength
-        state.getInventory().setSmelting(ItemStack(Material.REDSTONE))
+        elif material == "FURNACE":
-        state.update()
+            stack = get("furnace").get(uuid)
+            if stack == None:
+                return
+            state = block.getState()
+            state.getInventory().setSmelting(toStack(stack))
+            state.update()
+    except:
+        error(trace())
+
 
 @hook.event("player.PlayerInteractEvent", "monitor")
 def on_interact(event):
-    player = event.getPlayer()
+    try:
-    if uid(player) in denyautolevel or player.getWorld().getName() not in ("Creative", "Trusted", "world"):
+        player = event.getPlayer()
-        return
+        if (isEnabled("cauldron", uid(player)) 
-    if str(event.getAction()) != "RIGHT_CLICK_BLOCK":
+                and is_creative(player)
-        return
+                and str(event.getAction()) == "RIGHT_CLICK_BLOCK"
-    if event.hasItem() and not str(event.getItem().getType()) == "REDSTONE":
+                and (not event.hasItem() or str(event.getItem().getType()) == "REDSTONE")
-        return
+                and str(event.getClickedBlock().getType()) == "CAULDRON"
-    block = event.getClickedBlock()
+            ):
-    event2 = BlockBreakEvent(block, player)
+            block = event.getClickedBlock()
-    server.getPluginManager().callEvent(event2)
+            event2 = BlockBreakEvent(block, player)
-    data = block.getData()
+            server.getPluginManager().callEvent(event2)
-    if not event2.isCancelled() and str(block.getType()) == "CAULDRON":
+            if not event2.isCancelled():
-        block.setData(data - 1 if data > 0 else 3)
+                block.setData(block.getData() - 1 if block.getData() > 0 else 3)
+    except:
+        error(trace())
+

damnspam.py

@@ -102,7 +102,7 @@ def on_block_break(event):
     global removing_input
 
     if removing_input:
-        return True
+        return
     sender = event.getPlayer()
     block  = event.getBlock()
     btype  = str(block.getType()).lower()

misc.py

@@ -36,6 +36,53 @@ def on_join(event):
         player.teleport(player.getWorld().getSpawnLocation())
 
 
+@hook.event("player.PlayerGameModeChangeEvent", "low")
+def on_gamemode(event):
+    user = event.getPlayer()
+    if str(event.getNewGameMode()) != "SPECTATOR" and user.getWorld().getName() == "Trusted" and not user.hasPermission("mv.bypass.gamemode.Trusted"):
+        event.setCancelled(True)
+
+
+@hook.event("player.PlayerBedEnterEvent")
+def on_bed_enter(event):
+    if event.getPlayer().getWorld().getName() in ("Survival_1", "TrustedSurvival_1"):
+        event.getPlayer().setSleepingIgnored(True)
+
+
+@hook.event("player.PlayerBedLeaveEvent")
+def on_bed_leave(event):
+    event.getPlayer().setSleepingIgnored(False)
+
+
+@hook.event("player.PlayerTeleportEvent")
+def on_player_teleport(event):
+    """
+    Disable spectator teleportation
+    """
+    player = event.getPlayer()
+    if not event.isCancelled() and str(event.getCause()) == "SPECTATE" and not player.hasPermission("utils.tp.spectate"):
+        event.setCancelled(True)
+        msg(event.getPlayer(), "&cSpectator teleportation is disabled")
+
+
+@hook.event("block.BlockFromToEvent", "highest")
+def on_flow(event):
+    if event.isCancelled():
+        return
+    block = event.getToBlock()
+    if block.getWorld().getName() == "Creative" and rs_material_broken_by_flow(str(block.getType())):
+        event.setCancelled(True)
+
+def rs_material_broken_by_flow(material):
+    if material in ("REDSTONE", "LEVER", "TRIPWIRE"):
+        return True
+    parts = material.split("_")
+    length = len(parts)
+    return length > 1 and (parts[0] == "DIODE" or parts[1] in ("TORCH", "WIRE", "BUTTON", "HOOK") or (length == 3 and parts[1] == "COMPARATOR"))
+
+
+
+
 @simplecommand("sudo",
         usage        = "<player> [cmd..]",
         description  = "Makes <player> write [cmd..] in chat",
@@ -57,6 +104,7 @@ def on_sudo_command(sender, command, label, args):
     return "&cPlayer %s not found!" % target
 
 
+
 @simplecommand("me", 
         usage        = "[message..]",
         description  = "Sends a message in third person",
@@ -66,60 +114,14 @@ def on_me_command(sender, command, label, args):
     broadcast("utils.me", text + " ".join(args), usecolor = sender.hasPermission("essentials.chat.color"))
     return None
 
-#
-#@hook.command("gm")
-#def on_gm_command(sender, args):
-#  """
-#  /gm - custom gamemode command with extra perms for greater control
-#  """
-#  if not is_player(sender):
-#    msg(sender, "&cDerp! Can't run that from console!")
-#    return True
-#  if not checkargs(sender, args, 1, 2):
-#    return True
-#  mode = args[0]
-#  target = args[1]
-#  if target and not sender.hasPermission("utils.gm.other"):
-#    msg(sender, "&cYou cannot change the gamemode of another player!")
-#  else:
-#    target = sender
-#  if mode < 0 or mode > 3:
-#    msg(sender, "&cThat gamemode does not exist!")
-#  elif sender.hasPermission("utils.gm." % mode):
-#    runas(server.getConsoleSender(), "gamemode " % mode % " " % target)
-#  else:
-#    msg(sender, "&cYou cannot access that gamemode!")
-#  return True
 
 
-last_shear = 0.0
-
-@hook.event("player.PlayerInteractEntityEvent")
-def on_player_entity_interact(event):
-    """
-    Clicking redstone_sheep with shears will drop redstone + wool
-    also makes a moo sound for the shearer
-    """
-    global last_shear
-    if not event.isCancelled():
-        shear_time = now()
-        if last_shear + 0.4 < shear_time:
-            last_shear = shear_time
-            sender = event.getPlayer()
-            entity = event.getRightClicked()
-            if is_player(entity) and uid(entity) == "ae795aa8-6327-408e-92ab-25c8a59f3ba1" and str(sender.getItemInHand().getType()) == "SHEARS" and is_creative(sender):
-                for _ in range(5):
-                    entity.getWorld().dropItemNaturally(entity.getLocation(), ItemStack(bukkit.Material.getMaterial("REDSTONE")))
-                    entity.getWorld().dropItemNaturally(entity.getLocation(), ItemStack(bukkit.Material.getMaterial("WOOL")))
-                sender.playSound(entity.getLocation(), "mob.cow.say", 1, 1)
-
-"""
 @hook.command("pluginversions")
 def on_pluginversions_command(sender, command, label, args):
-    ""
+    """
     /pluginversions
     print all plugins + versions; useful when updating plugins
-    ""
+    """
     try:
         plugin_header(sender, "Plugin versions")
         plugins = [pl.getDescription() for pl in list(ArrayList(java_array_to_list(server.getPluginManager().getPlugins())))]
@@ -131,7 +133,6 @@ def on_pluginversions_command(sender, command, label, args):
         return True
     except:
         error(trace())
-"""
 
 
 @hook.command("echo")
@@ -143,6 +144,7 @@ def on_echo_command(sender, command, label, args):
     msg(sender, " ".join(args).replace("\\n", "\n"))
 
 
+
 def eval_thread(sender, code):
     """
     /pyeval
@@ -160,29 +162,6 @@ def eval_thread(sender, code):
         msg(sender, ">>> %s: %s" % (eclass.__name__, e) + "\n ", False, "c")
     thread.exit()
 
-"""
-def eval_argument_thread(event):
-    words = event.getMessage()[5:].split(" ")
-    for i in range(len(words)):
-        word = words[i]
-        if is_pyeval_call(word):
-            code = word[5:]
-            try:
-                result = unicode(eval(code))
-            except:
-                e = exc_info()[1]
-                try:
-                    eclass = e.__class__
-                except AttributeError:
-                    eclass = type(e)
-                msg(event.getPlayer(), ">>> %s: %s" % (eclass.__name__, e) + "\n ", False, "c")
-                result = code
-            words[i] = result
-    event.setMessage(" ".join(words))
-    thread.exit()
-"""
-
-
 @simplecommand("pyeval",
         usage       = "[code..]",
         description = "Runs python [code..] and returns the result",
@@ -193,6 +172,7 @@ def on_pyeval_command(sender, command, label, args):
     return None
 
 
+
 @simplecommand("tempadd",
         usage       = "<user> <group> [duration]",
         description = "Temporarily adds <user> to <group> for \n[duration] minutes. Defaults to 1 week.",
@@ -220,6 +200,7 @@ def tempadd_command(sender, command, label, args):
     return "&aAdded to group for %dd%dh%dm" % (d, h, m)
 
 
+
 @hook.command("modules")
 def on_modules_command(sender, command, label, args):
     """
@@ -229,46 +210,3 @@ def on_modules_command(sender, command, label, args):
     plugin_header(sender, "Modules")
     msg(sender, ", ".join([(("&a" if mod in shared["modules"] else "&c") + mod) for mod in shared["load_modules"]]))
 
-
-@hook.event("player.PlayerTeleportEvent")
-def on_player_teleport(event):
-    """
-    Disable spectator teleportation
-    """
-    player = event.getPlayer()
-    if not event.isCancelled() and str(event.getCause()) == "SPECTATE" and not player.hasPermission("utils.tp.spectate"):
-        event.setCancelled(True)
-        msg(event.getPlayer(), "&cSpectator teleportation is disabled")
-
-@hook.event("block.BlockFromToEvent", "highest")
-def on_flow(event):
-    if event.isCancelled():
-        return
-    block = event.getToBlock()
-    if block.getWorld().getName() == "Creative" and rs_material_broken_by_flow(str(block.getType())):
-        event.setCancelled(True)
-
-def rs_material_broken_by_flow(material):
-    if material in ("REDSTONE", "LEVER", "TRIPWIRE"):
-        return True
-    parts = material.split("_")
-    length = len(parts)
-    return length > 1 and (parts[0] == "DIODE" or parts[1] in ("TORCH", "WIRE", "BUTTON", "HOOK") or (length == 3 and parts[1] == "COMPARATOR"))
-
-
-"""
-@hook.event("player.AsyncPlayerChatEvent", "lowest")
-def on_chat(event):
-    user = event.getPlayer()
-    if user.hasPermission("utils.pyeval"):
-        thread.start_new_thread(eval_argument_thread, (event,))
-
-@hook.event("player.PlayerCommandPreprocessEvent", "lowest")
-def on_cmd(event):
-    user = event.getPlayer()
-    if user.hasPermission("utils.pyeval"):
-        thread.start_new_thread(eval_argument_thread, (event,))
-
-def is_pyeval_call(string):
-    return len(string) > 5 and string[:5] == "EVAL:"
-"""